Jpp/266-docker/JModK40_8cc_source.html

 #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"


 /**

  * \file

  *

  * Auxiliary program to add noise to Monte Carlo event.

  * This program will be deprecated (JTriggerEfficiency.cc should be used instead).

  * \author mdejong

  */

 int main(int argc, char **argv)

 {

   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();

 }

JAANET::JHit_t
Auxiliary class to set-up Hit.
Definition: JHit_t.hh:25

JSUPPORT::JMeta
Auxiliary class for ROOT I/O of application specific meta data.
Definition: JMeta.hh:70

JSUPPORT::JFileRecorder
Object writing to file.
Definition: JFileRecorder.hh:41

JPARSER::JParser
Utility class to parse command line options.
Definition: JParser.hh:1500

JDETECTOR::JModuleData::reset
void reset(size_t size)
Reset buffers.
Definition: JPMTSimulator.hh:229

JLANG::JException
General exception.
Definition: JException.hh:23

JSupport.hh
ROOT TTree parameter settings of various packages.

JDETECTOR::JK40DefaultSimulator
Default implementation of the simulation of K40 background.
Definition: JK40DefaultSimulator.hh:29

JTOOLS::JRange::include
range_type include(argument_type x)
Include given value to range.
Definition: JRange.hh:386

JDETECTOR::JModuleData
Data structure for PMT data corresponding to a detector module.
Definition: JPMTSimulator.hh:212

STATUS
#define STATUS(A)
Definition: JMessage.hh:63

JDETECTOR::JDetector
Detector data structure.
Definition: JDetector.hh:80

JHit_t.hh

JPHYSICS::JTimeRange
JTOOLS::JRange< double > JTimeRange
Type definition for time range (unit [ns]).
Definition: JPhysics/JTimeRange.hh:19

JFileRecorder.hh
Recording of objects on file according a format that follows from the file name extension.

JPARSER::initialised
Empty structure for specification of parser element that is initialised (i.e. does not require input)...
Definition: JParser.hh:66

JAANET::getTime
double getTime(const Hit &hit)
Get true time of hit.
Definition: JAAnetToolkit.hh:79

outputFile
string outputFile
Definition: JDAQTimesliceSelector.cc:37

JDetector.hh
Data structure for detector geometry and calibration.

std::vector
Definition: JSTDTypes.hh:12

JAANET::is_noise
bool is_noise(const Hit &hit)
Verify hit origin.
Definition: JAAnetToolkit.hh:103

JSUPPORT::JLimit
Auxiliary class for defining the range of iterations of objects.
Definition: JLimit.hh:41

JAANET::detector
Detector file.
Definition: JHead.hh:196

make_field
#define make_field(A,...)
macro to convert parameter to JParserTemplateElement object
Definition: JParser.hh:1961

JTOOLS::JRange::add
range_type & add(argument_type x)
Add offset.
Definition: JRange.hh:435

JMeta.hh
ROOT I/O of application specific meta data.

JAAnetToolkit.hh
Definition of hit and track types and auxiliary methods for handling Monte Carlo data.

JDETECTOR::JK40DefaultSimulatorInterface::generateHits
virtual void generateHits(const JModule &module, const JTimeRange &period, JModuleData &output) const
Generate hits.
Definition: JK40DefaultSimulatorInterface.hh:112

debug
int debug
debug level
Definition: JSirene.cc:63

KM3NETDAQ::getMaximalTime
double getMaximalTime(const double R_Hz)
Get maximal time for given rate.
Definition: JHighRateVeto.hh:35

JTOOLS::JRange< double >

JMessage.hh
General purpose messaging.

JSUPPORT::JMultipleFileScanner< Head >
Template specialisation of JMultipleFileScanner for Monte Carlo header.
Definition: JMonteCarloFileSupportkit.hh:337

FATAL
#define FATAL(A)
Definition: JMessage.hh:67

JMultipleFileScanner.hh
Scanning of objects from multiple files according a format that follows from the extension of each fi...

JMonteCarloFileSupportkit.hh

JTOOLS::JRange::is_valid
bool is_valid() const
Check validity of range.
Definition: JRange.hh:311

JDETECTOR::load
void load(const std::string &file_name, JDetector &detector)
Load detector from input file.
Definition: JDetectorToolkit.hh:440

Evt.hh

JSUPPORT::JMultipleFileScanner
General purpose class for object reading from a list of file names.
Definition: JMultipleFileScanner.hh:167

JParser.hh
Utility class to parse command line options.

JAANET::HIT_TYPE_NOISE
Random noise.
Definition: JAAnetToolkit.hh:68

JK40DefaultSimulator.hh

JDetectorToolkit.hh

JSUPPORT::JLimit::getLimit
const JLimit & getLimit() const
Get limit.
Definition: JLimit.hh:73

detector
do set_variable DETECTOR_TXT $WORKDIR detector
Definition: detector-XY:fit1d.sh:37

Head.hh

JPHYSICS::JK40Rates
Auxiliary class for K40 rates.
Definition: JK40Rates.hh:41

Evt
The Evt class respresent a Monte Carlo (MC) event as well as an offline event.
Definition: Evt.hh:19

DEBUG
#define DEBUG(A)
Message macros.
Definition: JMessage.hh:62

JTimeRange.hh

main
int main(int argc, char *argv[])
Definition: Main.cpp:15