JTriggeredEventsOnly.cc

Go to the documentation of this file.

 
#include <string>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <set>
 
#include "km3net-dataformat/offline/Head.hh"
#include "km3net-dataformat/offline/MultiHead.hh"
#include "km3net-dataformat/offline/Evt.hh"
 
#include "JDAQ/JDAQTimesliceIO.hh"
#include "JDAQ/JDAQEventIO.hh"
#include "JDAQ/JDAQSummarysliceIO.hh"
 
#include "JTrigger/JTriggerParameters.hh"
 
#include "JSupport/JSingleFileScanner.hh"
#include "JSupport/JTreeScanner.hh"
#include "JSupport/JFileRecorder.hh"
#include "JSupport/JMonteCarloFileSupportkit.hh"
#include "JSupport/JTriggerParametersSupportkit.hh"
#include "JSupport/JSummaryFileRouter.hh"
#include "JSupport/JMeta.hh"
#include "JSupport/JSupport.hh"
 
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"
 
namespace mc_keys {
 
  const char* const  primarylepton_t =  "primarylepton:";
}
 
/**
 * \file
 * Auxiliary program to select number of DAQ events.
 *
 * \author mdejong
 */
int main(int argc, char **argv)
{
  using namespace std;
  using namespace JPP;
 
  string                     inputFile;
  JFileRecorder<JAllTypes_t> outputFile;
  JLimit_t                numberOfEvents;
  int                     debug;
 
  try {
 
    JParser<> zap("Auxiliary program to select number of DAQ events.");
 
    zap['f'] = make_field(inputFile);
    zap['o'] = make_field(outputFile);
    zap['n'] = make_field(numberOfEvents)      = JLimit::max();
    zap['d'] = make_field(debug)               = 1;
 
    zap(argc, argv);
  }
  catch(const exception& error) {
    FATAL(error.what() << endl);
  }
 
 
  outputFile.open();
 
  outputFile.put(JMeta(argc,argv));
 
  try { outputFile.put(getHeader(inputFile)); }            catch(const exception&) {}
  try { outputFile.put(getMultiHeader(inputFile)); }       catch(const exception&) {}
  try { outputFile.put(getTriggerParameters(inputFile)); } catch(const exception&) {}
 
  JTreeScanner<Evt>  mc     (inputFile);
  JSummaryFileRouter summary(inputFile);
 
  int trigger_counter  = 0;
 
  set<int> frame_index;
 
  for (JSingleFileScanner<JDAQEvent> in(inputFile, numberOfEvents); in.hasNext(); ) {
 
    STATUS("event: " << setw(10) << in.getCounter() << '\r'); DEBUG(endl);
 
    JDAQEvent* tev   = in.next();
    Evt*       event = mc.getEntry(tev->getCounter());
 
    summary.update(*tev);
 
    if (tev->getFrameIndex() != summary.getFrameIndex()) {
      WARNING("Frame index " << tev->getFrameIndex() << " != " << summary.getFrameIndex() << endl);
    }
 
    if (Evt::ROOT_IO_VERSION < 16) {
 
      for (vector<Trk>::iterator i = event->mc_trks.begin(); i != event->mc_trks.end(); ++i) {
 
        const std::string& tag = i->comment;
 
        if        (tag == mc_keys::track_in_t) {
 
          i->status = TRK_ST_FINALSTATE;
 
        } else if (tag == mc_keys::track_t) {
 
        } else if (tag == mc_keys::neutrino_t) {
 
          i->status = TRK_ST_PRIMARYNEUTRINO;
 
        } else if (tag == mc_keys::track_primary_t) {
          
          i->status = TRK_ST_PRIMARYCOSMIC;
 
        } else if (tag == mc_keys::track_bundle_t) {
 
          i->type   = PDG_MUONBUNDLE;
          i->status = TRK_ST_MUONBUNDLE;
 
        } else if (tag == mc_keys::primarylepton_t) {
 
          i->status = TRK_ST_FINALSTATE;
        }
      }
    }
 
    tev->setCounter(trigger_counter);
 
    outputFile.put(*tev);
    outputFile.put(*event);
 
    if (frame_index.insert(summary.getFrameIndex()).second) {
      outputFile.put(summary);
    }
 
    ++trigger_counter;
  }
  STATUS(endl);
 
  outputFile.close();
}