JConvertDusj.cc File Reference

#include <string>
#include <iostream>
#include <iomanip>
#include <algorithm>
#include "TROOT.h"
#include "TFile.h"
#include "km3net-dataformat/offline/Head.hh"
#include "km3net-dataformat/offline/Evt.hh"
#include "km3net-dataformat/offline/io_online.hh"
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "JDetector/JModuleRouter.hh"
#include "JAAnet/JHead.hh"
#include "JAAnet/JHeadToolkit.hh"
#include "JDAQ/JDAQEventIO.hh"
#include "JDAQ/JDAQSummarysliceIO.hh"
#include "JSupport/JSingleFileScanner.hh"
#include "JSupport/JTreeScanner.hh"
#include "JSupport/JFileRecorder.hh"
#include "JSupport/JMonteCarloFileSupportkit.hh"
#include "JSupport/JSupportToolkit.hh"
#include "JSupport/JSupport.hh"
#include "JSupport/JMeta.hh"
#include "Jeep/JeepToolkit.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"

Go to the source code of this file.

Functions
int	main (int argc, char **argv)
	Auxiliary program to convert data to Dusj format. More...

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

Auxiliary program to convert data to Dusj format.

Author

mdejong

Definition at line 44 of file JConvertDusj.cc.

{
  using namespace std;
  using namespace JPP;
  using namespace KM3NETDAQ;
 
  JSingleFileScanner<JDAQEvent> inputFile;
  JFileRecorder<JTYPELIST<Head, Evt, JDAQSummaryslice, JMeta>::typelist> outputFile;
  JLimit_t&              numberOfEvents = inputFile.getLimit();
  string                 detectorFile;
  int                    debug;
 
  try {
 
    JParser<> zap("Auxiliary program to convert data to Dusj format.");
 
    zap['f'] = make_field(inputFile);
    zap['o'] = make_field(outputFile)          = "dusj.evt";
    zap['a'] = make_field(detectorFile);
    zap['n'] = make_field(numberOfEvents)      = JLimit::max();
    zap['d'] = make_field(debug)               = 2;
 
    zap(argc, argv);
  }
  catch(const exception& error) {
    FATAL(error.what() << endl);
  }
 
 
  JDetector detector;
 
  try {
    load(detectorFile, detector);
  }
  catch(const JException& error) {
    FATAL(error);
  }
 
  const JModuleRouter router(detector);
 
 
  outputFile.open();
 
  Vec offset(0,0,0);
 
  int mc_run_id = 0;
    
  Head header;
 
  try {
 
    header = getHeader(inputFile);
 
    JHead buffer(header);
 
    offset    = getOffset(buffer);
    mc_run_id = buffer.start_run.run_id;
 
  } catch(const exception& error) {
 
    JHead buffer(header);
    
    buffer.start_run.run_id = getRunNumber<JDAQSummaryslice>(inputFile);
    buffer.push(&JHead::start_run);
 
    copy(buffer, header);    
  }
  {
    JHead buffer(header);
 
    buffer.DAQ.livetime_s = getLivetime(inputFile);
    buffer.push(&JHead::DAQ);
    
    copy(buffer, header);
  }
  
  outputFile.put(header);
  outputFile.put(JMeta(argc, argv));
 
  for (JTreeScanner<Evt> mc(inputFile); inputFile.hasNext(); ) {
 
    STATUS("event: " << setw(10) << inputFile.getCounter() << '\r'); DEBUG(endl);
 
    JDAQEvent* tev   = inputFile.next();
      
    Evt out;
 
    if (mc.getEntries() != 0) {
 
      Evt* event = mc.getEntry(tev->getCounter());
 
      if (event != NULL) {
 
        out = *event;
 
        if (out.mc_run_id == 0) {
          out.mc_run_id = mc_run_id;
        }
 
        for (vector<Trk>::iterator i = out.mc_trks.begin(); i != out.mc_trks.end(); ++i) {
          i->pos += offset;
        }
      }
 
    } else {
 
      out.mc_id     = inputFile.getCounter();
      out.mc_run_id = tev->getRunNumber();
    }
    
    read(out, *tev);
 
    out.hits.clear();
 
    for (JDAQEvent::const_iterator<JDAQSnapshotHit> i = tev->begin<JDAQSnapshotHit>(); i != tev->end<JDAQSnapshotHit>(); ++i) {
 
      const JModule& module = router.getModule(i->getModuleID());
      const JPMT&    pmt    = module.getPMT   (i->getPMT());
        
      Hit hit;
        
      hit.id         = out.hits.size() + 1;
      hit.dom_id     = i->getModuleID();
      //hit.channel_id = i->getPMT();
      //hit.tdc        = i->getT();
      //hit.tot        = i->getToT();
      hit.pmt_id     = pmt.getID();
      hit.t          = i->getT();     // getTime(i->getT(),   pmt.getCalibration());
      hit.a          = i->getToT();   // getToT (i->getToT(), pmt.getCalibration());
      //hit.pos        = Vec(pmt.getX(),  pmt.getY(),  pmt.getZ());
      //hit.dir        = Vec(pmt.getDX(), pmt.getDY(), pmt.getDZ());
 
      out.hits.push_back(hit);
    }
 
    // time offset
 
    double t0 = numeric_limits<double>::max();
 
    for (vector<Hit>::const_iterator i = out.hits.begin(); i != out.hits.end(); ++i) {
      if (t0 > i->t) {
        t0 = i->t;
      }
    }
 
    for (vector<Hit>::iterator i = out.hits.begin(); i != out.hits.end(); ++i) {
      i->t -= t0;
    }
 
    if (out.mc_t > 0.0 && t0 != numeric_limits<double>::max()) {
      out.mc_t -= t0;
    }
 
    out.id = inputFile.getCounter();
 
    outputFile.put(out);
  }
 
  STATUS(endl);
  /*
  JSingleFileScanner<JTYPELIST<JDAQSummaryslice, JMeta>::typelist> io(inputFile);
 
  io >> outputFile;
  */
  outputFile.close();
}