#include <string>
#include <iostream>
#include <iomanip>
#include <vector>
#include "TROOT.h"
#include "TFile.h"
#include "TRandom3.h"
#include "km3net-dataformat/offline/Head.hh"
#include "km3net-dataformat/offline/Evt.hh"
#include "JAAnet/JAAnetToolkit.hh"
#include "JAAnet/JHit_t.hh"
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "JDetector/JK40DefaultSimulator.hh"
#include "JDetector/JTimeRange.hh"
#include "JSupport/JMultipleFileScanner.hh"
#include "JSupport/JFileRecorder.hh"
#include "JSupport/JMonteCarloFileSupportkit.hh"
#include "JSupport/JSupport.hh"
#include "JSupport/JMeta.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"

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

Detailed Description

Auxiliary program to add noise to Monte Carlo event. This program will be deprecated (JTriggerEfficiency.cc should be used instead).

Author: mdejong

Definition in file JModK40.cc.

Function Documentation

◆ main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 39 of file JModK40.cc.

 {
   using namespace std;
   using namespace JPP;
  
   JMultipleFileScanner<Evt>                                              inputFile;
   JFileRecorder<JTYPELIST<JAAnetTypes_t, JMeta, JRootTypes_t>::typelist> outputFile;
   JLimit_t&      numberOfEvents = inputFile.getLimit();
   string         detectorFile;
   JK40Rates      rates_Hz;
   JTimeRange     period;
   UInt_t         seed;
   int            debug;
  
   try { 
  
     JParser<> zap("Auxiliary program to add noise to Monte Carlo event.");
     
     zap['f'] = make_field(inputFile)       = JPARSER::initialised();
     zap['o'] = make_field(outputFile)      = "modk40.root";
     zap['n'] = make_field(numberOfEvents)  = JLimit::max();
     zap['a'] = make_field(detectorFile);
     zap['T'] = make_field(period)          = JTimeRange::DEFAULT_RANGE;
     zap['B'] = make_field(rates_Hz)        = JPARSER::initialised();
     zap['S'] = make_field(seed)            = 0;
     zap['d'] = make_field(debug)           = 1;
     
     zap['f'] = JPARSER::initialised();
  
     zap(argc, argv);
   }
   catch(const exception &error) {
     FATAL(error.what() << endl);
   }
  
  
   gRandom->SetSeed(seed);
  
  
  
   JDetector detector;
  
   try {
     load(detectorFile, detector);
   }
   catch(const JException& error) {
     FATAL(error);
   }
  
  
   if (period == JTimeRange::DEFAULT_RANGE) {
  
     const double Tmax = getMaximalTime(detector);
  
     period = JTimeRange(-Tmax, +Tmax);
   }
  
  
   const JK40DefaultSimulator modk40(rates_Hz);
  
   outputFile.open();
  
   if (!outputFile.is_open()) {
     FATAL("Error opening file " << outputFile << endl);
   }
  
   outputFile.put(JMeta(argc, argv));
   outputFile.put(*gRandom);
  
   JMultipleFileScanner<Head> io(inputFile);
  
   io >> outputFile;
  
   while (inputFile.hasNext()) {
  
     STATUS("event: " << setw(10) << inputFile.getCounter() << '\r'); DEBUG(endl);
  
     Evt* event = inputFile.next();
  
     JTimeRange time_range(JTimeRange::DEFAULT_RANGE);
  
     vector<Hit>::iterator __end = event->mc_hits.end();
  
     for (vector<Hit>::iterator i = event->mc_hits.begin(); i != __end; ) {
  
       if (is_noise(*i)) {
  
         iter_swap(i, --__end);
  
       } else {
  
         time_range.include(getTime(*i));
         
         ++i;
       }
     }
  
     event->mc_hits.erase(__end, event->mc_hits.end());
     
     if (time_range.is_valid())
       time_range.add(period);
     else
       time_range = period;
  
  
     const int npe = 1;
  
     JModuleData buffer;
  
     for (JDetector::const_iterator module = detector.begin(); module != detector.end(); ++module) {
  
       buffer.reset(module->size());
       
       modk40.generateHits(*module, time_range, buffer);
       
       for (unsigned int pmt = 0; pmt != buffer.size(); ++pmt) {
         
         const JModuleData::value_type& frame = buffer[pmt];
         
         for (JModuleData::value_type::const_iterator hit = frame.begin(); hit != frame.end(); ++hit) {
           
           event->mc_hits.push_back(JHit_t(event->mc_hits.size() + 1,
                                           module->getPMT(pmt).getID(),
                                           HIT_TYPE_NOISE,
                                           0,
                                           hit->t_ns,
                                           npe));
         }
       }
     }
  
  
     outputFile.put(*event);
   }
   STATUS(endl);
  
   outputFile.put(*gRandom);
   outputFile.close();
 }

Functions

Detailed Description

Function Documentation

◆ main()