Jpp/v16.0.2/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 generate noise in Monte Carlo event.\n

  * 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 generate noise in 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(argc, argv);

   }

   catch(const exception &error) {

     FATAL(error.what() << endl);

   }


   gRandom->SetSeed(seed);


   const int NPE = 1;


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


   if (!inputFile.empty()) {


     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;


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

     }

   } else {


     for (counter_type counter = 0; counter != numberOfEvents; ++counter) {


       STATUS("event: " << setw(10) << counter << '\r'); DEBUG(endl);


       Evt event;


       JModuleData buffer;


       for (JDetector::const_iterator module = detector.begin(); module != detector.end(); ++module) {


         buffer.reset(module->size());


         modk40.generateHits(*module, period, 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:231

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

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

JSupport.hh
ROOT TTree parameter settings of various packages.

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

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

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

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

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

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

JROOT::counter_type
Long64_t counter_type
Type definition for counter.
Definition: JROOT/JCounter.hh:24

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

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:108

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

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

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:446

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:478

Evt.hh

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

JParser.hh
Utility class to parse command line options.

Evt::mc_hits
std::vector< Hit > mc_hits
MC: list of MC truth hits.
Definition: Evt.hh:45

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

JK40DefaultSimulator.hh

DEBUG
then usage $script< input_file >< detector_file > fi set_variable OUTPUT_DIR set_variable SELECTOR JDAQTimesliceL1 set_variable DEBUG case set_variable DEBUG
Definition: JCalibratePMT.sh:21

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:38

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

JTimeRange.hh