offline_EventStorage_v5::DataWriter Class Reference

#include <v5_DataWriter.h>

Inheritance diagram for offline_EventStorage_v5::DataWriter:

Collaboration diagram for offline_EventStorage_v5::DataWriter:

Public Types
using	iovec_const = offline_EventStorage_v5::iovec_const

Public Member Functions
	DataWriter (const std::string &writingPath, const std::string &fileNameCore, const run_parameters_record &rPar, const std::vector< std::string > &fmdStrings, const unsigned int startIndex=1, const CompressionType compression=NONE, const unsigned int compLevel=1)
	constructor with metadata strings
	DataWriter (const std::string &writingPath, boost::shared_ptr< EventStorage::FileNameCallback > theFNCB, const run_parameters_record &rPar, const std::string &project, const std::string &streamType, const std::string &streamName, const std::string &stream, const unsigned int lumiBlockNumber, const std::string &applicationName, const std::vector< std::string > &fmdStrings, const CompressionType compression=NONE, const unsigned int compLevel=1)
	DataWriter (const std::string &writingPath, const std::string &fileNameCore, const run_parameters_record &rPar, const std::string &project, const std::string &streamType, const std::string &streamName, const std::string &stream, const unsigned int lumiBlockNumber, const std::string &applicationName, const std::vector< std::string > &fmdStrings, const CompressionType compression=NONE, const unsigned int compLevel=1)
	~DataWriter ()
	destructor, the way to close the sequence of files
EventStorage::DWError	setMaxFileNE (const unsigned int &maxFileNE)
	max size of 1 file in number of data blocks (or events) 1 putData call is one block
EventStorage::DWError	setMaxFileMB (const unsigned int &maxFileMB)
	max size of 1 file in MB.
void	setGUID (const std::string &GUID)
	Set the GUID for the next file in this sequence.
bool	good () const
	feedback to user
void	cd (const std::string &writingPath)
	set another writing path
bool	inTransition () const
	The file currently open is not closed immediately after cd() this method will return true if we are in transition phase, i.e.
EventStorage::DWError	putData (const unsigned int &dataSize, const void *event)
	Write a single block of data.
EventStorage::DWError	putPrecompressedData (const unsigned int &dataSize, const void *event)
	Write a single block of data already compressed.
EventStorage::DWError	putPrecompressedData (const unsigned int &entries, const iovec_const *my_iovec)
	Write a single block of data already compressed.
EventStorage::DWError	putData (const unsigned int &entries, const struct iovec *my_iovec)
	Write data when you have one event scattered in many blocks, in memory, like in the SFI application.
EventStorage::DWError	putData (const unsigned int &dataSize, const void *event, uint32_t &sizeToDisk)
	Write a single block of data.
EventStorage::DWError	putData (const unsigned int &entries, const iovec_const *my_iovec, uint32_t &sizeToDisk)
	Write data when you have one event scattered in many blocks, in memory, like in the SFI application.
EventStorage::DWError	closeFile ()
	Close the currently open file.
EventStorage::DWError	nextFile ()
	close the file and open next one immediately
std::string	nameFile (const FileStatus &fs) const
	get the name of the current file
int64_t	getPosition () const
	get the offset of the latest written event; one should call it AFTER putData(...)
unsigned int	eventsInFile () const
	number of events written to the currently open file
unsigned int	eventsInFileSequence () const
	number of events written to the file sequence
unsigned int	dataMB_InFile () const
	number of mega bytes written to the current file
unsigned int	dataMB_InFileSequence () const
	number of mega bytes written to the file sequence
void	registerCallBack (EventStorage::DataWriterCallBack *pUserCBclass)
	If you want to define actions to be taken when a file is open or closed register your call-back class here with this method.
CompressionType	getCompression () const
	Returns the compression type for this file.
void	setGuid (const std::string &Guid)
	Externally set the GUID for the next file in this sequence.

Private Member Functions
	DataWriter ()
void	initDW (const std::string &writingPath, boost::shared_ptr< EventStorage::FileNameCallback > theFNCB, const run_parameters_record &rPar, const std::string &project, const std::string &streamType, const std::string &streamName, const std::string &stream, const unsigned int lumiBlockNumber, const std::string &applicationName, const std::vector< std::string > &fmdStrings, const CompressionType compression, const unsigned int compLevel)
EventStorage::DWError	putData_implementation (const unsigned int &entries, const iovec_const *my_iovec, uint32_t &sizeToDisk, bool precompressed=false)
void	date_timeAsInt (uint32_t &getDate, uint32_t &getTime) const
void	openNextFile ()
bool	fileExists (const std::string &name) const
void	setRunParamsRecord (const run_parameters_record &rPar)
void	file_record (void *ri, const void *pi)
void	file_record (const file_name_strings &nst)
void	file_record (const freeMetaDataStrings &fmdStrings)
std::string	getAppName (const std::string &fileNameCore) const
std::string	getElement (const std::string &fileNameCore, const std::string &element) const
uint64_t	getFileSize (const std::string &fileNameCore) const
void	spaceForGuid ()
void	replaceGuid ()

Private Attributes
std::fstream	m_cFile
bool	m_cFileOpen
bool	m_openFailed
file_start_record	m_file_start_record
file_name_strings	m_file_name_strings
internal_run_parameters_record	m_internal_run_parameters_record
file_end_record	m_file_end_record
std::string	m_guid
std::string	m_next_guid
std::string	m_writePath
std::string	m_nextWritePath
std::string	m_fileNameCore
std::string	m_project
std::string	m_streamType
std::string	m_streamName
std::string	m_stream
unsigned int	m_lumiBlockNumber
std::string	m_applicationName
CompressionType	m_compression
unsigned int	m_complevel
DataBuffer *	m_compressed
double	m_cFileMB
long double	m_runMB
uLong	m_check
int64_t	m_latestPosition
EventStorage::DataWriterCallBack *	m_callBack
freeMetaDataStrings	m_fmdStrings
boost::shared_ptr< EventStorage::FileNameCallback >	m_filenamecallback

Detailed Description

Definition at line 44 of file v5_DataWriter.h.

Member Typedef Documentation

iovec_const

using offline_EventStorage_v5::DataWriter::iovec_const = offline_EventStorage_v5::iovec_const

Definition at line 47 of file v5_DataWriter.h.

Constructor & Destructor Documentation

DataWriter() [1/4]

DataWriter::DataWriter	(	const std::string &	writingPath,
		const std::string &	fileNameCore,
		const run_parameters_record &	rPar,
		const std::vector< std::string > &	fmdStrings,
		const unsigned int	startIndex = 1,
		const CompressionType	compression = NONE,
		const unsigned int	compLevel = 1 )

constructor with metadata strings

Parameters

writingPath	directory where to write data
fileNameCore	file name not including the ending "._NNNN.data"
run_parameters_record	rPar other parameters from IS including the run number
fmdStrings	optional vector of strings containing metadata
startIndex	initial file sequence index
compression	Compression type
compLevel	Compression level

Definition at line 73 of file v5_DataWriter.cxx.

{
  boost::shared_ptr<daq::RawFileName> 
    fileName(new daq::RawFileName(fileNameCore));
 
  if ( fileName->hasValidCore() ) {
    m_project         = fileName->project();
    m_streamType      = fileName->streamType();
    m_streamName      = fileName->streamName();
    m_stream          = fileName->stream();
    m_lumiBlockNumber = fileName->lumiBlockNumber();
    m_applicationName = fileName->applicationName();
  } else {
    std::stringstream mystream;
    mystream <<  "FileName " << fileName->fileName() 
         << " has failed interpretation."
         << " The file header will have no values for "
         << " project, stream, lumiBlock and appName";
    ERS_DEBUG(1,mystream.str());
    // EventStorage::RawFileNameIssue myissue(ERS_HERE, mystream.str().c_str() );
    // ers::warning(myissue);
    m_project         = "";
    m_streamType      = "";
    m_streamName      = "";
    m_stream          = ""; 
    m_lumiBlockNumber = 0;
    m_applicationName = "";
  }
 
  fileName->setFileSequenceNumber(startIndex);
 
  initDW(writingPath, fileName, rPar, m_project, m_streamType, m_streamName,
     m_stream, m_lumiBlockNumber, m_applicationName, 
     fmdStrings, compression,compLevel);
 
}

DataWriter() [2/4]

offline_EventStorage_v5::DataWriter::DataWriter	(	const std::string &	writingPath,
		boost::shared_ptr< EventStorage::FileNameCallback >	theFNCB,
		const run_parameters_record &	rPar,
		const std::string &	project,
		const std::string &	streamType,
		const std::string &	streamName,
		const std::string &	stream,
		const unsigned int	lumiBlockNumber,
		const std::string &	applicationName,
		const std::vector< std::string > &	fmdStrings,
		const CompressionType	compression = NONE,
		const unsigned int	compLevel = 1 )

DataWriter() [3/4]

DataWriter::DataWriter	(	const std::string &	writingPath,
		const std::string &	fileNameCore,
		const run_parameters_record &	rPar,
		const std::string &	project,
		const std::string &	streamType,
		const std::string &	streamName,
		const std::string &	stream,
		const unsigned int	lumiBlockNumber,
		const std::string &	applicationName,
		const std::vector< std::string > &	fmdStrings,
		const CompressionType	compression = NONE,
		const unsigned int	compLevel = 1 )

Definition at line 118 of file v5_DataWriter.cxx.

{
  boost::shared_ptr<FileNameCallback> fileName(new SimpleFileName(fileNameCore));
  initDW(writingPath, fileName, rPar, project, streamType, streamName, stream, lumiBlockNumber, applicationName, fmdStrings, compression, compLevel);
  
}

DataWriter() [4/4]

offline_EventStorage_v5::DataWriter::DataWriter ( )

private

~DataWriter()

DataWriter::~DataWriter

(

)

destructor, the way to close the sequence of files

Definition at line 138 of file v5_DataWriter.cxx.

{
  ERS_DEBUG(1,"DataWriter::~DataWriter() called.");
  
  m_file_end_record.status = 1; // This identifies the end of the sequence.
  if(m_cFileOpen) closeFile();
  
  delete m_compressed;
 
  ERS_DEBUG(1,"DataWriter::~DataWriter() finished.");
}

Member Function Documentation

cd()

void DataWriter::cd

(

const std::string &

writingPath

)

set another writing path

Definition at line 651 of file v5_DataWriter.cxx.

                                             {
  m_nextWritePath = writingPath;
  ERS_DEBUG(3,"Directory changed to "<<m_nextWritePath
        <<" (effective for hext file).");
}

closeFile()

DWError DataWriter::closeFile

(

)

Close the currently open file.

Next file will be open anyway if you try to write again afterwards.

Definition at line 465 of file v5_DataWriter.cxx.

{
  ERS_DEBUG(3,"DataWriter::closeFile() called.");
 
  // do statistics
  m_file_end_record.data_in_file = static_cast<unsigned int>(m_cFileMB+0.5);
  m_file_end_record.data_in_run  = static_cast<unsigned int>(m_runMB+0.5);
 
  date_timeAsInt(m_file_end_record.date,m_file_end_record.time);
 
  // write eof record
  file_record(&m_file_end_record,&file_end_pattern);
 
  m_cFile.close();
  std::ostringstream oss;
  oss.width(8);
  (void)oss.fill('0');
  oss << std::hex << std::uppercase <<m_check;
  std::string checksum = oss.str();
  m_check = ::adler32(0L, Z_NULL, 0);
 
  // rename the file
  ERS_DEBUG(3,"Rename file " << nameFile(UNFINISHED) << endl
        << "to " << nameFile(FINISHED));
  if (::rename(nameFile(UNFINISHED).c_str(), nameFile(FINISHED).c_str()) == -1) {
    
    EventStorage::WritingIssue ci(ERS_HERE, "Rename failed.");
    ers::error(ci);
    return EventStorage::DWNOOK;
  }
 
  // check if the file is there
  if(fileExists(nameFile(FINISHED)) && m_cFileOpen) 
    {
      ERS_DEBUG(2,"Finished file "<<nameFile(FINISHED));
      if(m_callBack != NULL) {
    ERS_DEBUG(3,"Execute callback from DataWriter.");
    m_callBack->FileWasClosed(
                   m_filenamecallback->getCurrentFileName(),
                   nameFile(FINISHED),
                   m_streamType,
                   m_streamName,
                   m_applicationName,
                   m_guid,
                   std::move(checksum),
                   m_file_end_record.events_in_file, 
                   m_internal_run_parameters_record.run_number,
                   m_file_start_record.file_number,
                   m_lumiBlockNumber,
                   getFileSize(nameFile(FINISHED))
                   );
      }
      
      // now we can substitute new directory, if specified
      if(m_nextWritePath != "") {
    m_writePath=m_nextWritePath;
    m_nextWritePath="";
    ERS_DEBUG(3,"New writing path became effective. The path is "
          <<m_writePath);
      }
      m_cFileOpen = false;
 
      try{
    m_filenamecallback->advance();
      }catch(EventStorage::ES_SingleFile &e){
    //If opennext file is called, it 
    // will fail there
      }
      return EventStorage::DWOK;
    }
  return EventStorage::DWNOOK;
}

dataMB_InFile()

unsigned int DataWriter::dataMB_InFile

(

)

const

number of mega bytes written to the current file

Definition at line 454 of file v5_DataWriter.cxx.

{
  return static_cast<unsigned int>(m_cFileMB+0.5);
}

dataMB_InFileSequence()

unsigned int DataWriter::dataMB_InFileSequence

(

)

const

number of mega bytes written to the file sequence

Definition at line 459 of file v5_DataWriter.cxx.

{
  return static_cast<unsigned int>(m_runMB+0.5);
}

date_timeAsInt()

void DataWriter::date_timeAsInt ( uint32_t & getDate, uint32_t & getTime ) const

private

Definition at line 233 of file v5_DataWriter.cxx.

{
    long a_time;
    time(&a_time);
    
    struct tm  t;
    localtime_r( &a_time, &t);
    
    getDate= 1000000*t.tm_mday+
         10000*(1+t.tm_mon)+
         1900+t.tm_year;
 
    getTime= 10000*t.tm_hour+
         100*t.tm_min+
         t.tm_sec ;
}

eventsInFile()

unsigned int DataWriter::eventsInFile

(

)

const

number of events written to the currently open file

Definition at line 444 of file v5_DataWriter.cxx.

{
  return m_file_end_record.events_in_file;
}

eventsInFileSequence()

unsigned int DataWriter::eventsInFileSequence

(

)

const

number of events written to the file sequence

Definition at line 449 of file v5_DataWriter.cxx.

{
  return m_file_end_record.events_in_run;
}

file_record() [1/3]

void DataWriter::file_record ( const file_name_strings & nst )

private

Definition at line 684 of file v5_DataWriter.cxx.

                                                                                {
  
  const char *cName = nst.appName.c_str();
  const char *cTag = nst.fileNameCore.c_str();
 
  uint32_t sizeName =  nst.appName.size();
  uint32_t sizeTag =  nst.fileNameCore.size();
 
  m_cFile.write(ccharAddress(offline_EventStorage_v5::file_name_strings_marker),sizeof(uint32_t));
  m_check =  ::adler32(m_check,reinterpret_cast<const Bytef*>
             (&offline_EventStorage_v5::file_name_strings_marker),
             sizeof(uint32_t));
 
  m_cFile.write(charAddress(sizeName),sizeof(uint32_t));
  m_check =  ::adler32(m_check,cbytefAddress(sizeName),sizeof(uint32_t));
  m_cFile.write(cName,sizeName);
  m_check =  ::adler32(m_check,reinterpret_cast<const Bytef*>(cName),sizeName);
 
  char ns = sizeName % 4;
  if(ns){ 
    m_cFile.write("    ",4-ns);
    m_check = ::adler32(m_check,reinterpret_cast<const Bytef*>("    "),4-ns);
  }
 
  m_cFile.write(charAddress(sizeTag),sizeof(uint32_t));
  m_check = ::adler32(m_check,bytefAddress(sizeTag),sizeof(uint32_t));
  m_cFile.write(cTag,sizeTag);
  m_check = ::adler32(m_check,reinterpret_cast<const Bytef*>(cTag),sizeTag);
 
  ns = sizeTag % 4;
  if(ns){ 
    m_cFile.write("    ",4-ns);
    m_check = ::adler32(m_check,reinterpret_cast<const Bytef*>("    "),4-ns);
  }
 
}

file_record() [2/3]

void DataWriter::file_record ( const freeMetaDataStrings & fmdStrings )

private

Definition at line 721 of file v5_DataWriter.cxx.

{
  ERS_DEBUG(2,"Writing the metadata strings.");
 
  m_cFile.write(ccharAddress(offline_EventStorage_v5::free_strings_marker),sizeof(uint32_t));
  m_check = ::adler32(m_check, reinterpret_cast<const Bytef*>
            (&offline_EventStorage_v5::free_strings_marker),
            sizeof(uint32_t));
 
  uint32_t nstrings = fmdStrings.size();
  m_cFile.write(charAddress(nstrings),sizeof(uint32_t));
  m_check = ::adler32(m_check, bytefAddress(nstrings),
            sizeof(uint32_t));
 
  vector<string>::const_iterator it;
  for(it=fmdStrings.begin(); it!=fmdStrings.end(); ++it) {
 
    const char *cst = it->c_str();
    uint32_t slen =  it->size();
   
    m_cFile.write(charAddress(slen),sizeof(uint32_t));
    m_check = ::adler32(m_check,bytefAddress(slen),sizeof(uint32_t));
    m_cFile.write(cst,slen);
    m_check = ::adler32(m_check,reinterpret_cast<const Bytef*>(cst),slen);
    char ns = slen % 4;
    if(ns){ 
      m_cFile.write("    ",4-ns);
      m_check = ::adler32(m_check,reinterpret_cast<const Bytef*>("    "),4-ns);
    }
  }
}

file_record() [3/3]

void DataWriter::file_record ( void * ri, const void * pi )

private

Definition at line 666 of file v5_DataWriter.cxx.

                                                     {
 
  uint32_t *record = reinterpret_cast<uint32_t *>(ri);
  const uint32_t *pattern = reinterpret_cast<const uint32_t *>(pi);
  int size=pattern[1];
 
  for(int i=0; i<size; i++) {
    if(pattern[i] != 0) {
      m_cFile.write(reinterpret_cast<const char*>(pattern+i),sizeof(uint32_t));
      m_check = ::adler32(m_check,reinterpret_cast<const Bytef*>(pattern+i),sizeof(uint32_t));
    } else {
      m_cFile.write(reinterpret_cast<char*>(record+i),sizeof(uint32_t));
      m_check = ::adler32(m_check,reinterpret_cast<const Bytef*>(record+i),sizeof(uint32_t));
    }
  }
}

fileExists()

bool DataWriter::fileExists ( const std::string & name ) const

private

Definition at line 556 of file v5_DataWriter.cxx.

{
  ifstream test(name.c_str(),ios::binary | ios::in);
  bool isThere = test.good();
  test.close();
    
  return isThere;
}

getAppName()

std::string offline_EventStorage_v5::DataWriter::getAppName ( const std::string & fileNameCore ) const

private

getCompression()

offline_EventStorage_v5::CompressionType DataWriter::getCompression

(

)

const

Returns the compression type for this file.

Definition at line 807 of file v5_DataWriter.cxx.

{
  return m_compression;
}

getElement()

std::string offline_EventStorage_v5::DataWriter::getElement ( const std::string & fileNameCore, const std::string & element ) const

private

getFileSize()

uint64_t DataWriter::getFileSize ( const std::string & fileNameCore ) const

private

Definition at line 794 of file v5_DataWriter.cxx.

{
  struct stat64 tmp;
  if (::stat64(fileNameCore.c_str(), &tmp) == -1) {
    EventStorage::WritingIssue ci(ERS_HERE, "stat64 failed.");
    ers::error(ci);
    return 0;
  }
  
  return tmp.st_size;
}

getPosition()

int64_t DataWriter::getPosition

(

)

const

get the offset of the latest written event; one should call it AFTER putData(...)

Definition at line 438 of file v5_DataWriter.cxx.

{
  return m_latestPosition;
}

good()

bool DataWriter::good

(

)

const

feedback to user

Definition at line 251 of file v5_DataWriter.cxx.

{
 
    if(m_openFailed) return false;
 
    if(m_cFileOpen) 
    {
      return m_cFile.good();
    }
    else
    {
    return true;
    }
 
}

initDW()

void DataWriter::initDW ( const std::string & writingPath, boost::shared_ptr< EventStorage::FileNameCallback > theFNCB, const run_parameters_record & rPar, const std::string & project, const std::string & streamType, const std::string & streamName, const std::string & stream, const unsigned int lumiBlockNumber, const std::string & applicationName, const std::vector< std::string > & fmdStrings, const CompressionType compression, const unsigned int compLevel )

private

Definition at line 151 of file v5_DataWriter.cxx.

{
  m_project         = project;
  m_streamType      = streamType;
  m_streamName      = streamName;
  m_stream          = stream;
  m_lumiBlockNumber = lumiBlockNumber;
  m_applicationName = applicationName;
 
  m_filenamecallback = theFNCB;
 
  reset_record(&m_file_start_record,&file_start_pattern);
  reset_record(&m_internal_run_parameters_record,&run_parameters_pattern);
  reset_record(&m_file_end_record,&file_end_pattern);
  m_cFileMB = 0.0;
  m_runMB = 0.0;
  m_latestPosition = -1;
 
  m_writePath = writingPath;
  m_nextWritePath = "";
  //m_fileNameCore = fileNameCore;
 
  m_file_name_strings.appName = m_applicationName;
  // m_file_name_strings.appName = getAppName(fileNameCore);
  m_file_name_strings.fileNameCore = m_filenamecallback->getCoreName();
 
  setRunParamsRecord(rPar);
 
  m_file_start_record.sizeLimit_MB = 0;
  m_file_start_record.sizeLimit_dataBlocks = 0;
  date_timeAsInt(m_file_start_record.date,m_file_start_record.time);
  
  m_cFileOpen=false;
  m_openFailed = false;
  
  m_callBack = NULL;
 
  m_fmdStrings = fmdStrings;
 
  m_compression = compression;
  m_complevel = compLevel;
  m_compressed = new DataBuffer();
 
  // add stream, project, compression, lumiBlock 
  // (if they are valid) to meta-data:
  m_fmdStrings.push_back("Stream=" + m_stream );
  m_fmdStrings.push_back("Project=" + m_project );
  std::ostringstream o;
  o << m_lumiBlockNumber;
  m_fmdStrings.push_back("LumiBlock=" + o.str());
  
  if(m_compression != offline_EventStorage_v5::NONE){
    m_fmdStrings.push_back(offline_EventStorage_v5::compressiontag +
               "=" + offline_EventStorage_v5::type_to_string(m_compression));
  }
 
  m_check = ::adler32(0L, Z_NULL, 0);
  
  m_guid = "";
  m_next_guid = "";
  this->spaceForGuid();
  this->openNextFile();
 
}

inTransition()

bool DataWriter::inTransition

(

)

const

The file currently open is not closed immediately after cd() this method will return true if we are in transition phase, i.e.

the file has not yet been closed after a cd()

Definition at line 657 of file v5_DataWriter.cxx.

                                    {
 
  bool inT=false;
  if((m_nextWritePath != "") && 
     (m_nextWritePath != m_writePath)) inT=true;
  return inT;
 
}

nameFile()

string DataWriter::nameFile

(

const FileStatus &

fs

)

const

get the name of the current file

Definition at line 642 of file v5_DataWriter.cxx.

{
  ostringstream n;
  n << m_writePath << "/";
  n << m_filenamecallback->getCurrentFileName((FINISHED == fs)?false:true);
  string name = n.str();
  return name;      
}

nextFile()

DWError DataWriter::nextFile

(

)

close the file and open next one immediately

Definition at line 539 of file v5_DataWriter.cxx.

{
  ERS_DEBUG(2,"DataWriter::nextFile() called.");
 
  DWError we=closeFile();
   
/*  if (m_freename)
  {
    EventStorage::ES_SingleFile ci(ERS_HERE, "DataWriter called with freename = 1. DataWriter wants to go to next file, but cannot, since indexing is forbidden. Either deactive freename (so files can be indexed, or increase the file size limit (or turn it off)");
    throw ci;  
  }*/
 
  openNextFile();
  if(m_openFailed) we=EventStorage::DWNOOK;
  return we;
}

openNextFile()

void DataWriter::openNextFile ( )

private

Definition at line 565 of file v5_DataWriter.cxx.

{
  m_cFileMB=0.0;
  m_file_end_record.events_in_file=0;
  
  try{
    m_file_start_record.file_number = m_filenamecallback->getIndex();
  }catch(EventStorage::ES_SingleFile &e){
    m_file_start_record.file_number++;
  }
  date_timeAsInt(m_file_start_record.date,m_file_start_record.time);
 
  ERS_DEBUG(2,"Trying to open file "<<nameFile(UNFINISHED));
  
  while(fileExists(nameFile(UNFINISHED)) 
    || fileExists(nameFile(FINISHED))) 
    {
    
      if(fileExists(nameFile(UNFINISHED))) {
    string err = "found an existing file with name " + nameFile(UNFINISHED);
    EventStorage::WritingIssue ci(ERS_HERE, err.c_str());
    ers::warning(ci);
    
      } else {
    
    string err = "found an existing file with name " + nameFile(FINISHED);
    EventStorage::WritingIssue ci(ERS_HERE, err.c_str());
    ers::warning(ci);
      }
      m_filenamecallback->fileAlreadyExists();
      
      m_file_start_record.file_number = m_filenamecallback->getIndex();
      
      ostringstream oss;
      oss << "increase file number to ";
      oss << m_file_start_record.file_number;
      EventStorage::WritingIssue ci(ERS_HERE, oss.str().c_str());
      ers::warning(ci);
    }
  ERS_DEBUG(2,"OK to write file with number "<<m_file_start_record.file_number);
 
  ERS_DEBUG(2,"Opening file: " << nameFile(UNFINISHED));
 
  m_cFile.clear();
  m_cFile.open(nameFile(UNFINISHED).c_str(),
           ios::out | ios::app | ios::binary);
 
  m_check = ::adler32(0L, Z_NULL, 0);
 
  file_record(&m_file_start_record,&file_start_pattern);
  file_record(m_file_name_strings);
 
  this->replaceGuid();
 
  ERS_DEBUG(3,"Writing "<<m_fmdStrings.size()<<" metadata strings.");
  if(m_fmdStrings.size()>0) file_record(m_fmdStrings);
  file_record(&m_internal_run_parameters_record,&run_parameters_pattern);
  ERS_DEBUG(3,"Status of the file. good() returns "<<m_cFile.good());
  m_cFileOpen = m_cFile.good();
  m_openFailed = !m_cFile.good();
  
  if((m_callBack != NULL) && m_cFileOpen) {
    ERS_DEBUG(3,"Execute callback from DataWriter.");
    m_callBack->FileWasOpened(
                   m_filenamecallback->getCurrentFileName(),
                   nameFile(UNFINISHED),
                   m_streamType,
                   m_streamName,
                   m_applicationName,
                   m_guid,
                   m_internal_run_parameters_record.run_number,
                   m_file_start_record.file_number,
                   m_lumiBlockNumber
                   );
      }
}

putData() [1/4]

DWError DataWriter::putData	(	const unsigned int &	dataSize,
		const void *	event )

Write a single block of data.

If one of the size limits would be exceeded, the current file will be closed and another one will be opened automatically.

Parameters

dataSize	size of the event in bytes
*event	start of the event data in memory

Definition at line 298 of file v5_DataWriter.cxx.

{
 
  uint32_t todisk;
  iovec_const iov;
  iov.iov_base = event;
  iov.iov_len = dataSize;
  return this->putData(1, &iov, todisk);
}

putData() [2/4]

DWError DataWriter::putData	(	const unsigned int &	dataSize,
		const void *	event,
		uint32_t &	sizeToDisk )

Write a single block of data.

If one of the size limits would be exceeded, the current file will be closed and another one will be opened automatically.

Parameters

dataSize	size of the eveny in bytes
*event	start of the event data in memory
&sizeToDisk	will be update with the actual chunck size on disk

Definition at line 315 of file v5_DataWriter.cxx.

                                                                                                {
  
  iovec_const iov;
  iov.iov_base = event;
  iov.iov_len = dataSize;
  return this->putData(1, &iov, sizeToDisk);
}

putData() [3/4]

DWError DataWriter::putData	(	const unsigned int &	entries,
		const iovec_const *	my_iovec,
		uint32_t &	sizeToDisk )

Write data when you have one event scattered in many blocks, in memory, like in the SFI application.

If one of the size limits would be exceeded, the current file will be closed and another one will be opened automatically.

Parameters

entries	number of the data chunks
my_iovec	locations of the data chunks
&sizeToDisk	will be update with the actual chunck size on disk

Definition at line 323 of file v5_DataWriter.cxx.

                                                                                                          {
  return this->putData_implementation(entries, my_iovec, sizeToDisk);
}

putData() [4/4]

DWError DataWriter::putData	(	const unsigned int &	entries,
		const struct iovec *	my_iovec )

Write data when you have one event scattered in many blocks, in memory, like in the SFI application.

If one of the size limits would be exceeded, the current file will be closed and another one will be opened automatically.

Parameters

number	of the data chunks
locations	of the data chunks

Definition at line 309 of file v5_DataWriter.cxx.

{
  uint32_t todisk;
  return this->putData(entries, my_iovec, todisk);
}

putData_implementation()

DWError DataWriter::putData_implementation ( const unsigned int & entries, const iovec_const * my_iovec, uint32_t & sizeToDisk, bool precompressed = false )

private

Definition at line 346 of file v5_DataWriter.cxx.

                                                                                                                                             {
 
  ERS_DEBUG(3,"DataWriter::putData called for an iovec.");
  if(!m_cFileOpen) openNextFile();
 
  if(!m_cFileOpen) return EventStorage::DWNOOK;
  
  if(!m_cFile.good()) return EventStorage::DWNOOK;
  
  // calculate events size
  unsigned int dataSize = 0;
  for(unsigned int i = 0; i<entries; i++) {
    dataSize += my_iovec[i].iov_len;
  }
 
 
  
  sizeToDisk = dataSize;
  
  
  // apply limits 
  if(m_file_start_record.sizeLimit_MB>0) { 
    double eventMB=static_cast<double>(dataSize)/(1024*1024);
    double dataMB=m_cFileMB+eventMB;
    if(static_cast<unsigned int>(dataMB+0.5) > 
       m_file_start_record.sizeLimit_MB) {
      ERS_DEBUG(3,"Approaching file size limit in MB.");
      nextFile();
    }
  }
  
  if((m_file_start_record.sizeLimit_dataBlocks>0) && 
     (m_file_end_record.events_in_file >= m_file_start_record.sizeLimit_dataBlocks)){
    ERS_DEBUG(3,"Approaching file size limit in number of events.");
    nextFile();
  }
 
  //Here we should compress, so that we have the effective size
  //for the event record 
  if(m_compression == ZLIB && !precompressed){
    try{
        offline_EventStorage_v5::zlibcompress(*m_compressed, sizeToDisk,
                 entries, my_iovec, dataSize, m_complevel);
    }catch(offline_EventStorage_v5::CompressionIssue& ex){
      EventStorage::WritingIssue ci(ERS_HERE, "Data compression failed.", ex);
      ers::error(ci);
      return EventStorage::DWNOOK;
    }
  }
  
  // prepare the event record
  data_separator_record dsR = data_separator_pattern;
  dsR.data_block_number = m_file_end_record.events_in_run + 1;
  dsR.data_block_size = sizeToDisk;
  
  // remember the position
  m_latestPosition = m_cFile.tellg();
  
  // write the event record followed by event data    
  file_record(&dsR,&data_separator_pattern);
  
  
  if(m_compression != ZLIB || precompressed){
    for (unsigned int i =0; i<entries; i++){
      m_cFile.write(static_cast<const char*>(my_iovec[i].iov_base),
            my_iovec[i].iov_len);
      
      m_check = ::adler32(m_check, 
              static_cast<const Bytef *>(my_iovec[i].iov_base), 
              my_iovec[i].iov_len);
    }
  }else{
    m_cFile.write(static_cast<const char *>(m_compressed->handle()), sizeToDisk);
    m_check = ::adler32(m_check, 
            static_cast<const Bytef *>(m_compressed->handle()), 
            sizeToDisk);
  }
  
  // update statistics
  m_cFileMB += static_cast<double>(sizeToDisk)/(1024*1024);
  m_runMB += static_cast<double>(sizeToDisk)/(1024*1024);
  m_file_end_record.events_in_file++;
  m_file_end_record.events_in_run++;
  
  ERS_DEBUG(3,"Event "<< m_file_end_record.events_in_run<<" is written at offset "<<m_latestPosition);
  
  if(!m_cFile.good()) return EventStorage::DWNOOK;
  
  return EventStorage::DWOK;
}

putPrecompressedData() [1/2]

DWError DataWriter::putPrecompressedData	(	const unsigned int &	dataSize,
		const void *	event )

Write a single block of data already compressed.

WARNING* the library has now way to check if the compression algorithm matches the declared file type. The data is directly written to the file without check, completely trusting the caller. Use with care! If one of the size limits would be exceeded, the current file will be closed and another one will be opened automatically.

Parameters

dataSize	size of the eveny in bytes
*event	start of the event data in memory

Definition at line 328 of file v5_DataWriter.cxx.

                                       {
 
  iovec_const iov;
  iov.iov_base = event;
  iov.iov_len = dataSize;
  return this->putPrecompressedData(1, &iov);
}

putPrecompressedData() [2/2]

DWError DataWriter::putPrecompressedData	(	const unsigned int &	entries,
		const iovec_const *	my_iovec )

Write a single block of data already compressed.

WARNING* the library has now way to check if the compression algorithm matches the declared file type. The data is directly written to the file without check, completely trusting the caller. Use with care! If one of the size limits would be exceeded, the current file will be closed and another one will be opened automatically.

Parameters

number	of the data chunks
locations	of the data chunks

Definition at line 338 of file v5_DataWriter.cxx.

                                                 {
 
  uint32_t todisk;
  return this->putData_implementation(entries, my_iovec, todisk, true);
}

registerCallBack()

void DataWriter::registerCallBack

(

EventStorage::DataWriterCallBack *

pUserCBclass

)

If you want to define actions to be taken when a file is open or closed register your call-back class here with this method.

Definition at line 753 of file v5_DataWriter.cxx.

                                                                  {
  m_callBack = pUserCBclass;
  if(m_callBack != NULL) {
    m_callBack->FileWasOpened(
                   m_filenamecallback->getCurrentFileName(),
                   nameFile(UNFINISHED),
                   m_streamType,
                   m_streamName,
                   m_applicationName,
                   m_guid,
                   m_internal_run_parameters_record.run_number,
                   m_file_start_record.file_number,
                   m_lumiBlockNumber
                   );
  }
}

replaceGuid()

void DataWriter::replaceGuid ( )

private

Definition at line 775 of file v5_DataWriter.cxx.

                             {
  using namespace std;
  
  if (m_next_guid == ""){
    offline_poolCopy_v5::Guid g(true);
    m_guid = g.toString();
  }else{
    m_guid = m_next_guid;
    m_next_guid = "";
  }
  
  m_fmdStrings[0] = "GUID=" + m_guid;
}

setGUID()

void offline_EventStorage_v5::DataWriter::setGUID

(

const std::string &

GUID

)

Set the GUID for the next file in this sequence.

setGuid()

void DataWriter::setGuid

(

const std::string &

Guid

)

Externally set the GUID for the next file in this sequence.

Definition at line 789 of file v5_DataWriter.cxx.

                                             {
  m_next_guid = Guid;
}

setMaxFileMB()

DWError DataWriter::setMaxFileMB

(

const unsigned int &

maxFileMB

)

max size of 1 file in MB.

The file is closed before this limit is overrun.

Definition at line 269 of file v5_DataWriter.cxx.

{
    m_file_start_record.sizeLimit_MB = maxFileMB;
    return EventStorage::DWOK;
}

setMaxFileNE()

DWError DataWriter::setMaxFileNE

(

const unsigned int &

maxFileNE

)

max size of 1 file in number of data blocks (or events) 1 putData call is one block

Definition at line 275 of file v5_DataWriter.cxx.

{
    m_file_start_record.sizeLimit_dataBlocks = maxFileNE;
    return EventStorage::DWOK;
}

setRunParamsRecord()

void DataWriter::setRunParamsRecord ( const run_parameters_record & rPar )

private

Definition at line 281 of file v5_DataWriter.cxx.

{
    // accept the params, whatever they are
    // run number is in this record (and only there)
    m_internal_run_parameters_record.marker = rPar.marker; 
    m_internal_run_parameters_record.record_size = rPar.record_size; 
    m_internal_run_parameters_record.run_number = rPar.run_number; 
    m_internal_run_parameters_record.max_events = rPar.max_events;
    m_internal_run_parameters_record.rec_enable = rPar.rec_enable;
    m_internal_run_parameters_record.trigger_type = rPar.trigger_type;
    m_internal_run_parameters_record.detector_mask_1of2 = rPar.detector_mask & 0xFFFFFFFF;
    m_internal_run_parameters_record.detector_mask_2of2 = (rPar.detector_mask>> 32); 
    m_internal_run_parameters_record.beam_type = rPar.beam_type;
    m_internal_run_parameters_record.beam_energy = rPar.beam_energy;
}

spaceForGuid()

void DataWriter::spaceForGuid ( )

private

Definition at line 770 of file v5_DataWriter.cxx.

                              {
  string e("");
  m_fmdStrings.insert(m_fmdStrings.begin(),e);
}

Member Data Documentation

m_applicationName

std::string offline_EventStorage_v5::DataWriter::m_applicationName

private

Definition at line 326 of file v5_DataWriter.h.

m_callBack

EventStorage::DataWriterCallBack* offline_EventStorage_v5::DataWriter::m_callBack

private

Definition at line 338 of file v5_DataWriter.h.

m_cFile

std::fstream offline_EventStorage_v5::DataWriter::m_cFile

private

Definition at line 304 of file v5_DataWriter.h.

m_cFileMB

double offline_EventStorage_v5::DataWriter::m_cFileMB

private

Definition at line 332 of file v5_DataWriter.h.

m_cFileOpen

bool offline_EventStorage_v5::DataWriter::m_cFileOpen

private

Definition at line 306 of file v5_DataWriter.h.

m_check

uLong offline_EventStorage_v5::DataWriter::m_check

private

Definition at line 334 of file v5_DataWriter.h.

m_complevel

unsigned int offline_EventStorage_v5::DataWriter::m_complevel

private

Definition at line 329 of file v5_DataWriter.h.

m_compressed

DataBuffer* offline_EventStorage_v5::DataWriter::m_compressed

private

Definition at line 330 of file v5_DataWriter.h.

m_compression

CompressionType offline_EventStorage_v5::DataWriter::m_compression

private

Definition at line 328 of file v5_DataWriter.h.

m_file_end_record

file_end_record offline_EventStorage_v5::DataWriter::m_file_end_record

private

Definition at line 312 of file v5_DataWriter.h.

m_file_name_strings

file_name_strings offline_EventStorage_v5::DataWriter::m_file_name_strings

private

Definition at line 310 of file v5_DataWriter.h.

m_file_start_record

file_start_record offline_EventStorage_v5::DataWriter::m_file_start_record

private

Definition at line 309 of file v5_DataWriter.h.

m_filenamecallback

boost::shared_ptr<EventStorage::FileNameCallback> offline_EventStorage_v5::DataWriter::m_filenamecallback

private

Definition at line 342 of file v5_DataWriter.h.

m_fileNameCore

std::string offline_EventStorage_v5::DataWriter::m_fileNameCore

private

Definition at line 319 of file v5_DataWriter.h.

m_fmdStrings

freeMetaDataStrings offline_EventStorage_v5::DataWriter::m_fmdStrings

private

Definition at line 340 of file v5_DataWriter.h.

m_guid

std::string offline_EventStorage_v5::DataWriter::m_guid

private

Definition at line 314 of file v5_DataWriter.h.

m_internal_run_parameters_record

internal_run_parameters_record offline_EventStorage_v5::DataWriter::m_internal_run_parameters_record

private

Definition at line 311 of file v5_DataWriter.h.

m_latestPosition

int64_t offline_EventStorage_v5::DataWriter::m_latestPosition

private

Definition at line 336 of file v5_DataWriter.h.

m_lumiBlockNumber

unsigned int offline_EventStorage_v5::DataWriter::m_lumiBlockNumber

private

Definition at line 325 of file v5_DataWriter.h.

m_next_guid

std::string offline_EventStorage_v5::DataWriter::m_next_guid

private

Definition at line 315 of file v5_DataWriter.h.

m_nextWritePath

std::string offline_EventStorage_v5::DataWriter::m_nextWritePath

private

Definition at line 318 of file v5_DataWriter.h.

m_openFailed

bool offline_EventStorage_v5::DataWriter::m_openFailed

private

Definition at line 307 of file v5_DataWriter.h.

m_project

std::string offline_EventStorage_v5::DataWriter::m_project

private

Definition at line 321 of file v5_DataWriter.h.

m_runMB

long double offline_EventStorage_v5::DataWriter::m_runMB

private

Definition at line 333 of file v5_DataWriter.h.

m_stream

std::string offline_EventStorage_v5::DataWriter::m_stream

private

Definition at line 324 of file v5_DataWriter.h.

m_streamName

std::string offline_EventStorage_v5::DataWriter::m_streamName

private

Definition at line 323 of file v5_DataWriter.h.

m_streamType

std::string offline_EventStorage_v5::DataWriter::m_streamType

private

Definition at line 322 of file v5_DataWriter.h.

m_writePath

std::string offline_EventStorage_v5::DataWriter::m_writePath

private

Definition at line 317 of file v5_DataWriter.h.

---

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

• v5_DataWriter.h
• v5_DataWriter.cxx