#include <RawEventFileWriterForBU.h>

Public Member Functions
uint32	adler32 () const

void	doOutputEvent (FRDEventMsgView const &msg)

void	doOutputEvent (boost::shared_array< unsigned char > &msg)

void	doOutputEventFragment (unsigned char *dataPtr, unsigned long dataSize)

void	endOfLS (int ls)

void	initialize (std::string const &destinationDir, std::string const &name, int ls)

void	makeRunPrefix (std::string const &destinationDir)

	RawEventFileWriterForBU (edm::ParameterSet const &ps)

	RawEventFileWriterForBU (std::string const &fileName)

bool	sharedMode () const

void	start ()

void	stop ()

	~RawEventFileWriterForBU ()

Private Member Functions
bool	closefd ()

void	finishFileWrite (int ls)

void	writeJsds ()

Private Attributes
uint32	adlera_

uint32	adlerb_

std::string	destinationDir_

jsoncollector::DataPointDefinition	eolJsonDef_

jsoncollector::DataPointDefinition	eorJsonDef_

jsoncollector::FastMonitor *	fileMon_ = nullptr

std::string	fileName_

unsigned int	lumiClosed_ = 0

jsoncollector::FastMonitor *	lumiMon_ = nullptr

unsigned int	lumiOpen_ = 0

int	microSleep_

std::auto_ptr< std::ofstream >	ost_

int	outfd_ = -1

jsoncollector::IntJ	perFileEventCount_

jsoncollector::IntJ	perFileSize_

jsoncollector::IntJ	perLumiEventCount_

jsoncollector::IntJ	perLumiFileCount_

jsoncollector::IntJ	perLumiLostEventCount_

jsoncollector::IntJ	perLumiSize_

jsoncollector::IntJ	perLumiTotalEventCount_

jsoncollector::IntJ	perRunEventCount_

jsoncollector::IntJ	perRunFileCount_

jsoncollector::IntJ	perRunLastLumi_

jsoncollector::IntJ	perRunLumiCount_

jsoncollector::DataPointDefinition	rawJsonDef_

int	run_ = -1

jsoncollector::FastMonitor *	runMon_ = nullptr

std::string	runPrefix_

bool	writtenJSDs_ =false

Detailed Description

Definition at line 19 of file RawEventFileWriterForBU.h.

Constructor & Destructor Documentation

RawEventFileWriterForBU::RawEventFileWriterForBU ( edm::ParameterSet const & ps )

explicit

Definition at line 25 of file RawEventFileWriterForBU.cc.

References jsoncollector::DataPointDefinition::addLegendItem(), jsoncollector::FastMonitor::commit(), eolJsonDef_, eorJsonDef_, fileMon_, lumiMon_, perFileEventCount_, perFileSize_, perLumiEventCount_, perLumiFileCount_, perLumiLostEventCount_, perLumiSize_, perLumiTotalEventCount_, perRunEventCount_, perRunFileCount_, perRunLastLumi_, perRunLumiCount_, rawJsonDef_, jsoncollector::FastMonitor::registerGlobalMonitorable(), runMon_, jsoncollector::DataPointDefinition::setDefaultGroup(), jsoncollector::JsonMonitorable::setName(), and SUM.

                                                                          :
       // default to .5ms sleep per event
        microSleep_(ps.getUntrackedParameter<int>("microSleep", 0))
        //debug_(ps.getUntrackedParameter<bool>("debug", False))
 {
 
   //per-file JSD and FastMonitor
   rawJsonDef_.setDefaultGroup("legend");
   rawJsonDef_.addLegendItem("NEvents","integer",DataPointDefinition::SUM);
 
   perFileEventCount_.setName("NEvents");
   perFileSize_.setName("NBytes");
 
   fileMon_ = new FastMonitor(&rawJsonDef_,false);
   fileMon_->registerGlobalMonitorable(&perFileEventCount_,false,nullptr);
   fileMon_->registerGlobalMonitorable(&perFileSize_,false,nullptr);
   fileMon_->commit(nullptr);
 
   //per-lumi JSD and FastMonitor
   eolJsonDef_.setDefaultGroup("legend");
   eolJsonDef_.addLegendItem("NEvents","integer",DataPointDefinition::SUM);
   eolJsonDef_.addLegendItem("NFiles","integer",DataPointDefinition::SUM);
   eolJsonDef_.addLegendItem("TotalEvents","integer",DataPointDefinition::SUM);
   eolJsonDef_.addLegendItem("NLostEvents","integer",DataPointDefinition::SUM);
 
   perLumiEventCount_.setName("NEvents");
   perLumiFileCount_.setName("NFiles");
   perLumiTotalEventCount_.setName("TotalEvents");
   perLumiLostEventCount_.setName("NLostEvents");
   perLumiSize_.setName("NBytes");
 
   lumiMon_ = new FastMonitor(&eolJsonDef_,false);
   lumiMon_->registerGlobalMonitorable(&perLumiEventCount_,false,nullptr);
   lumiMon_->registerGlobalMonitorable(&perLumiFileCount_,false,nullptr);
   lumiMon_->registerGlobalMonitorable(&perLumiTotalEventCount_,false,nullptr);
   lumiMon_->registerGlobalMonitorable(&perLumiLostEventCount_,false,nullptr);
   lumiMon_->registerGlobalMonitorable(&perLumiSize_,false,nullptr);
   lumiMon_->commit(nullptr);
 
 
   //per-run JSD and FastMonitor
   eorJsonDef_.setDefaultGroup("legend");
   eorJsonDef_.addLegendItem("NEvents","integer",DataPointDefinition::SUM);
   eorJsonDef_.addLegendItem("NFiles","integer",DataPointDefinition::SUM);
   eorJsonDef_.addLegendItem("NLumis","integer",DataPointDefinition::SUM);
   eorJsonDef_.addLegendItem("LastLumi","integer",DataPointDefinition::SUM);
 
   perRunEventCount_.setName("NEvents");
   perRunFileCount_.setName("NFiles");
   perRunLumiCount_.setName("NLumis");
   perRunLastLumi_.setName("LastLumi");
  
   runMon_ = new FastMonitor(&eorJsonDef_,false);
   runMon_->registerGlobalMonitorable(&perRunEventCount_,false,nullptr);
   runMon_->registerGlobalMonitorable(&perRunFileCount_,false,nullptr);
   runMon_->registerGlobalMonitorable(&perRunLumiCount_,false,nullptr);
   runMon_->registerGlobalMonitorable(&perRunLastLumi_,false,nullptr);
   runMon_->commit(nullptr);
 
 }

RawEventFileWriterForBU::RawEventFileWriterForBU ( std::string const & fileName )

explicit

Definition at line 86 of file RawEventFileWriterForBU.cc.

 {
 
 }

RawEventFileWriterForBU::~RawEventFileWriterForBU ( )

Definition at line 91 of file RawEventFileWriterForBU.cc.

References fileMon_, lumiMon_, and runMon_.

 {
   delete fileMon_;
   delete lumiMon_;
   delete runMon_;
 }

Member Function Documentation

uint32 RawEventFileWriterForBU::adler32 ( ) const

inline

Definition at line 32 of file RawEventFileWriterForBU.h.

References adlera_, and adlerb_.

32 { return (adlerb_ << 16) | adlera_; }

RawEventFileWriterForBU::adlera_

uint32 adlera_

Definition: RawEventFileWriterForBU.h:81

RawEventFileWriterForBU::adlerb_

uint32 adlerb_

Definition: RawEventFileWriterForBU.h:82

bool RawEventFileWriterForBU::closefd ( )

inlineprivate

Definition at line 43 of file RawEventFileWriterForBU.h.

References finishFileWrite(), outfd_, and writeJsds().

Referenced by endOfLS(), and initialize().

43 {if(outfd_>=0){close(outfd_); outfd_=-1; return true;} else return false;}

RawEventFileWriterForBU::outfd_

int outfd_

Definition: RawEventFileWriterForBU.h:46

void RawEventFileWriterForBU::doOutputEvent ( FRDEventMsgView const & msg )

Definition at line 98 of file RawEventFileWriterForBU.cc.

References Exception, fileName_, microSleep_, outfd_, perFileEventCount_, perFileSize_, FRDEventMsgView::size(), FRDEventMsgView::startAddress(), jsoncollector::IntJ::value(), and TriggerAnalyzer::write().

 {
   ssize_t retval =  write(outfd_,(void*)msg.startAddress(), msg.size());
 
   if((unsigned)retval!= msg.size()){
     throw cms::Exception("RawEventFileWriterForBU", "doOutputEvent")
       << "Error writing FED Raw Data event data to "
       << fileName_ << ".  Possibly the output disk "
       << "is full?" << std::endl;
   }
 
   // throttle event output
   usleep(microSleep_);
   perFileEventCount_.value()++;
   perFileSize_.value()+=msg.size();
 
   //  cms::Adler32((const char*) msg.startAddress(), msg.size(), adlera_, adlerb_);
 }

void RawEventFileWriterForBU::doOutputEvent ( boost::shared_array< unsigned char > & msg )

inline

Definition at line 28 of file RawEventFileWriterForBU.h.

References doOutputEventFragment().

28 {};

void RawEventFileWriterForBU::doOutputEventFragment	(	unsigned char *	dataPtr,
		unsigned long	dataSize
	)

Definition at line 117 of file RawEventFileWriterForBU.cc.

References Exception.

Referenced by doOutputEvent().

 {
 
   throw cms::Exception("RawEventFileWriterForBU", "doOutputEventFragment")
     << "Unsupported output mode ";
 
   //cms::Adler32((const char*) dataPtr, dataSize, adlera_, adlerb_);
 }

void RawEventFileWriterForBU::endOfLS ( int ls )

Definition at line 255 of file RawEventFileWriterForBU.cc.

References closefd(), destinationDir_, jsoncollector::FastMonitor::discardCollected(), finishFileWrite(), eostools::ls(), lumiClosed_, lumiMon_, makeRunPrefix(), jsoncollector::FastMonitor::outputFullJSON(), callgraph::path, perLumiEventCount_, perLumiFileCount_, perLumiSize_, perLumiTotalEventCount_, perRunEventCount_, perRunFileCount_, perRunLastLumi_, perRunLumiCount_, run_, runPrefix_, jsoncollector::FastMonitor::snap(), AlCaHLTBitMon_QueryRunRegistry::string, and jsoncollector::IntJ::value().

Referenced by start(), and stop().

 {
   if (closefd()) finishFileWrite(ls);
   lumiMon_->snap(ls);
 
   std::ostringstream ostr;
 
   if (run_==-1) makeRunPrefix(destinationDir_);
 
   ostr << destinationDir_ << "/"<< runPrefix_ << "_ls" << std::setfill('0') << std::setw(4) << ls << "_EoLS" << ".jsn";
   //outfd_ = open(ostr.str().c_str(), O_WRONLY | O_CREAT,  S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP | S_IWOTH | S_IROTH);
   //closefd();
 
   std::string path = ostr.str();
   lumiMon_->outputFullJSON(path, ls);
   lumiMon_->discardCollected(ls);
 
   perRunEventCount_.value() += perLumiEventCount_.value();
   perRunFileCount_.value() += perLumiFileCount_.value();
   perRunLumiCount_.value() += 1;
   perRunLastLumi_.value() = ls;
 
   perLumiEventCount_ = 0;
   perLumiFileCount_ = 0;
   perLumiTotalEventCount_ = 0;
   perLumiSize_ = 0;
   lumiClosed_ =  ls;
 }

void RawEventFileWriterForBU::finishFileWrite ( int ls )

private

Definition at line 222 of file RawEventFileWriterForBU.cc.

References destinationDir_, jsoncollector::FastMonitor::discardCollected(), fileMon_, fileName_, eostools::ls(), lumiOpen_, jsoncollector::FastMonitor::outputFullJSON(), callgraph::path, perFileEventCount_, perFileSize_, perLumiEventCount_, perLumiFileCount_, perLumiSize_, perLumiTotalEventCount_, jsoncollector::FastMonitor::snap(), source, AlCaHLTBitMon_QueryRunRegistry::string, and jsoncollector::IntJ::value().

Referenced by closefd(), endOfLS(), and initialize().

 {
 
     //move raw file from open to run directory
     rename(fileName_.c_str(),(destinationDir_+fileName_.substr(fileName_.rfind("/"))).c_str());
  
     //create equivalent JSON file
     std::stringstream ss;
     //TODO:fix this to use DaqDirector convention and better extension replace
     boost::filesystem::path source(fileName_);
     std::string path = source.replace_extension(".jsn").string();
 
     fileMon_->snap(ls);
     fileMon_->outputFullJSON(path, ls);
     fileMon_->discardCollected(ls);
 
     //move the json file from open
     rename(path.c_str(),(destinationDir_+path.substr(path.rfind("/"))).c_str());
     //there is a small chance that script gets interrupted while this isn't consistent (non-atomic)
     perLumiFileCount_.value()++;
     perLumiEventCount_.value()+=perFileEventCount_.value();
     perLumiSize_.value()+=perFileSize_.value();
     perLumiTotalEventCount_.value()+=perFileEventCount_.value();
     //update open lumi value when first file is completed
     lumiOpen_ =  ls;
 
     edm::LogInfo("RawEventFileWriterForBU") << "Wrote JSON input file: " << path 
                         << " with perFileEventCount = " << perFileEventCount_.value()
                                             << " and size " << perFileSize_.value();
 
 }

void RawEventFileWriterForBU::initialize	(	std::string const &	destinationDir,
		std::string const &	name,
		int	ls
	)

Definition at line 126 of file RawEventFileWriterForBU.cc.

References adlera_, adlerb_, closefd(), destinationDir_, Exception, fileName_, finishFileWrite(), dataset::name, outfd_, perFileEventCount_, perFileSize_, jsoncollector::IntJ::value(), writeJsds(), and writtenJSDs_.

Referenced by start().

 {
   destinationDir_ = destinationDir;
 
   if (closefd()) finishFileWrite(ls);
 
   fileName_ = name;
 
   if (!writtenJSDs_) {
     writeJsds();
 /*    std::stringstream ss;
     ss << destinationDir_ << "/jsd";
     mkdir(ss.str().c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
 
     std::string rawJSDName = ss.str()+"/rawData.jsd";
     std::string eolJSDName = ss.str()+"/EoLS.jsd";
     std::string eorJSDName = ss.str()+"/EoR.jsd";
 
     fileMon_->setDefPath(rawJSDName);
     lumiMon_->setDefPath(eolJSDName);
     runMon_->setDefPath(eorJSDName);
 
     struct stat   fstat;
     if (stat (rawJSDName.c_str(), &fstat) != 0) {
       std::string content;
       JSONSerializer::serialize(&rawJsonDef_,content);
       FileIO::writeStringToFile(rawJSDName, content);
     }
 
     if (stat (eolJSDName.c_str(), &fstat) != 0) {
       std::string content;
       JSONSerializer::serialize(&eolJsonDef_,content);
       FileIO::writeStringToFile(eolJSDName, content);
     }
 
     if (stat (eorJSDName.c_str(), &fstat) != 0) {
       std::string content;
       JSONSerializer::serialize(&eorJsonDef_,content);
       FileIO::writeStringToFile(eorJSDName, content);
     }
 */
     writtenJSDs_=true;
 
   }
 
   outfd_ = open(fileName_.c_str(), O_WRONLY | O_CREAT,  S_IRWXU | S_IRWXG | S_IRWXO);
    edm::LogInfo("RawEventFileWriterForBU") << " opened " << fileName_;
   if(outfd_ < 0) { //attention here... it may happen that outfd_ is *not* set (e.g. missing initialize call...)
     throw cms::Exception("RawEventFileWriterForBU","initialize")
       << "Error opening FED Raw Data event output file: " << name
       << ": " << strerror(errno) << "\n";
   }
 
   perFileEventCount_.value() = 0;
   perFileSize_.value() = 0;
 
 
   adlera_ = 1;
   adlerb_ = 0;
 }

void RawEventFileWriterForBU::makeRunPrefix ( std::string const & destinationDir )

Definition at line 299 of file RawEventFileWriterForBU.cc.

References findQualityFiles::run, run_, runPrefix_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by endOfLS(), sharedMode(), and stop().

 {
   //dirty hack: extract run number from destination directory
   std::string::size_type pos = destinationDir.find("run");
   std::string run = destinationDir.substr(pos+3);
   run_=atoi(run.c_str());
   std::stringstream ss;
   ss << "run" << std::setfill('0') << std::setw(6) << run_;
   runPrefix_ = ss.str();
 }

bool RawEventFileWriterForBU::sharedMode ( ) const

inline

Definition at line 38 of file RawEventFileWriterForBU.h.

References makeRunPrefix(), and AlCaHLTBitMon_QueryRunRegistry::string.

38 {return false;}

void RawEventFileWriterForBU::start ( )

inline

Definition at line 34 of file RawEventFileWriterForBU.h.

References endOfLS(), initialize(), eostools::ls(), dataset::name, stop(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by progressbar.ProgressBar::__next__(), Types.LuminosityBlockRange::cppID(), and Types.EventRange::cppID().

34 {}

void RawEventFileWriterForBU::stop ( )

Definition at line 284 of file RawEventFileWriterForBU.cc.

References destinationDir_, endOfLS(), lumiClosed_, lumiOpen_, makeRunPrefix(), jsoncollector::FastMonitor::outputFullJSON(), callgraph::path, run_, runMon_, runPrefix_, jsoncollector::FastMonitor::snap(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by start().

 {
   if (lumiOpen_>lumiClosed_)  endOfLS(lumiOpen_);
   edm::LogInfo("RawEventFileWriterForBU") << "Writing EOR file!";
   if (!destinationDir_.empty())
     {
       // create EoR file
       if (run_==-1) makeRunPrefix(destinationDir_);
       std::string path = destinationDir_ + "/" + runPrefix_ + "_ls0000_EoR.jsn";
       runMon_->snap(0);
       runMon_->outputFullJSON(path, 0);
     }
 }

void RawEventFileWriterForBU::writeJsds ( )

private

Definition at line 187 of file RawEventFileWriterForBU.cc.

References ws_sso_content_reader::content, destinationDir_, eolJsonDef_, eorJsonDef_, fileMon_, lumiMon_, eostools::mkdir(), rawJsonDef_, runMon_, cond::serialize(), jsoncollector::FastMonitor::setDefPath(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by closefd(), and initialize().

 {
 
   std::stringstream ss;
   ss << destinationDir_ << "/jsd";
   mkdir(ss.str().c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
 
   std::string rawJSDName = ss.str()+"/rawData.jsd";
   std::string eolJSDName = ss.str()+"/EoLS.jsd";
   std::string eorJSDName = ss.str()+"/EoR.jsd";
 
   fileMon_->setDefPath(rawJSDName);
   lumiMon_->setDefPath(eolJSDName);
   runMon_->setDefPath(eorJSDName);
 
   struct stat   fstat;
   if (stat (rawJSDName.c_str(), &fstat) != 0) {
     std::string content;
     JSONSerializer::serialize(&rawJsonDef_,content);
     FileIO::writeStringToFile(rawJSDName, content);
   }
 
   if (stat (eolJSDName.c_str(), &fstat) != 0) {
     std::string content;
     JSONSerializer::serialize(&eolJsonDef_,content);
     FileIO::writeStringToFile(eolJSDName, content);
   }
 
   if (stat (eorJSDName.c_str(), &fstat) != 0) {
     std::string content;
     JSONSerializer::serialize(&eorJsonDef_,content);
     FileIO::writeStringToFile(eorJSDName, content);
   }
 }