JMergeEvt.cc

Go to the documentation of this file.

#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"
 
namespace {
 
  /**
   * Auxiliary data structure for priority queue.
   */
  struct entry_type {
    /**
     * Prioritise two entries.
     *
     * \param  first           first  entry
     * \param  second          second entry
     * \return                 true if first entry higher priority than second; else false
     */
    friend inline bool operator<(const entry_type& first, const entry_type& second)
    {
      return first.evt.mc_event_time.AsDouble() > second.evt.mc_event_time.AsDouble();
    }
 
    size_t index;
    Evt    evt;
  };
 
 
  /**
   * Auxiliary class to determine time of Monte Carlo objects.
   */
  struct JEvaluator_t {
    /**
     * Type definition of time value.
     */
    typedef double value_type;
 
 
    /**
     * Get time of Monte Carlo event.
     *
     * \param  object          Monte Carlo event
     * \return                 time
     */
    inline value_type operator()(const Evt& evt) const
    {
      return evt.mc_event_time.AsDouble();
    }
  };
}
 
 
/**
 * \file
 * Application for merging Monte-Carlo files.
 *
 * \author bjung, mdejong
 */
int main(int argc, char **argv)
{
  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;
}