JMergeEvt.cc File Reference

Application for merging Monte-Carlo files. More...

#include <uuid/uuid.h>
#include <iostream>
#include <iomanip>
#include <string>
#include <deque>
#include <queue>
#include "km3net-dataformat/definitions/weightlist.hh"
#include "km3net-dataformat/offline/MultiHead.hh"
#include "km3net-dataformat/offline/Head.hh"
#include "km3net-dataformat/offline/Evt.hh"
#include "JDAQ/JDAQEventIO.hh"
#include "JDAQ/JDAQTimesliceIO.hh"
#include "JDAQ/JDAQSummarysliceIO.hh"
#include "JTrigger/JTriggerParameters.hh"
#include "Jeep/JPrint.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"
#include "JAAnet/JHead.hh"
#include "JAAnet/JMultiHead.hh"
#include "JReconstruction/JEvt.hh"
#include "JSupport/JMeta.hh"
#include "JSupport/JSupport.hh"
#include "JSupport/JFileRecorder.hh"
#include "JSupport/JMultipleFileScanner.hh"
#include "JSupport/JTreeScanner.hh"
#include "JSupport/JEvtWeightFileScannerSet.hh"
#include "JSupport/JMonteCarloFileSupportkit.hh"

Go to the source code of this file.

Functions
int	main (int argc, char **argv)

Detailed Description

Application for merging Monte-Carlo files.

Author

bjung, mdejong

Definition in file JMergeEvt.cc.

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Definition at line 90 of file JMergeEvt.cc.

{
  using namespace std;
  using namespace JPP;
  using namespace KM3NETDAQ;
 
  typedef JTYPELIST<JRemove<JAllTypes_t, JDAQTimesliceTypes_t>::typelist, JFIT::JEvt>::typelist   typelist;
  
  
  JMultipleFileScanner_t  inputFiles;
  JFileRecorder<typelist> outputFile;
 
  int                     debug;
 
  try {
    
    JParser<> zap;
    
    zap['f'] = make_field(inputFiles);
    zap['o'] = make_field(outputFile)         = "merged.root";
    zap['d'] = make_field(debug)              = 1;
 
    zap(argc, argv);
  }
  catch(const exception& error) {
    FATAL(error.what() << endl);
  }
  
      
  outputFile.open();
 
  outputFile.put(JMeta(argc, argv));
 
  // Create set of filescanners ordered based on header-info
  
  JEvtWeightFileScannerSet<> scanners(inputFiles);
 
  if (scanners.empty()) {
    FATAL("File scanner set is empty");
  }
 
  // Merge multi-headers and obtain common header
 
  const JHead& firstHeader  = scanners.begin()->getHeader();
  JHead        commonHeader = firstHeader;
  JMultiHead   eventHeaders = getMultiHeader(inputFiles);
 
  eventHeaders.merge(firstHeader);
 
  for (JEvtWeightFileScannerSet<>::iterator scanner = next(scanners.begin()); scanner != scanners.end(); ++scanner) {
    
    JHead header = scanner->getHeader();
    commonHeader = commonHeader.getMatch(header);
    
    eventHeaders.insert(header);
  }
 
  eventHeaders.merge();
 
  outputFile.put(static_cast<const MultiHead&>(eventHeaders));
 
  {
    Head buffer;
 
    copy(commonHeader, buffer);
  
    outputFile.put(buffer);
  }
 
 
  typedef JTreeScanner<Evt, JEvaluator_t>  JTreeScanner_t;
 
  vector<JTreeScanner_t> in;
 
  for (JEvtWeightFileScannerSet<>::iterator i = scanners.begin(); i != scanners.end(); ++i) {
    in.push_back(JTreeScanner_t(i->getFilelist()));
  }
  
  counter_type number_of_events = 0;
 
  for (const auto& i : in) {
    number_of_events += i.getEntries();
  }
 
 
  // Update event-weight normalisations
 
  auto getEvt = [eventHeaders, scanners](const entry_type& top) {
 
    Evt out = top.evt;
 
    if (out.w.size() <= WEIGHTLIST_NORMALISATION) {
      out.w.resize(WEIGHTLIST_NORMALISATION + 1, 0.0);
    }
 
    const JUUID headerUUID = (uuid_is_null(out.header_uuid) == 0 ? // is valid
                              eventHeaders.getHeaderUUID(out) : scanners[top.index].getHeader().UUID);
  
    out.w[WEIGHTLIST_NORMALISATION] = eventHeaders.getNormalisation(headerUUID);
      
    uuid_copy(out.header_uuid, headerUUID.uuid);
 
    return out;
  };
 
 
  priority_queue<entry_type, deque<entry_type> > buffer;    // multiplex
 
  for (size_t i = 0; i != in.size(); ++i) {
 
    if (in[i].hasNext()) {
 
      buffer.push({i, *in[i].next()});
 
      --number_of_events;
    }
  }
 
  while (number_of_events != 0) {                           // process
 
    STATUS("event: " << setw(10) << number_of_events << '\r'); DEBUG(endl);
 
    const entry_type& top = buffer.top();
 
    outputFile.put(getEvt(top));
 
    if (in[top.index].hasNext()) {
 
      buffer.push({top.index, *in[top.index].next()});
 
      --number_of_events;
    }
 
    buffer.pop();
  }
 
  while (!buffer.empty()) {                                 // flush
 
    const entry_type& top = buffer.top();
 
    outputFile.put(getEvt(top));
 
    buffer.pop();
  }
 
  JMultipleFileScanner<JRemove<typelist, JAAnetTypes_t>::typelist> io(inputFiles);
 
  io >> outputFile;
 
  outputFile.close();
 
  return 0;
}