Jpp
JEnergy.cc
Go to the documentation of this file.
1 
2 #include <string>
3 #include <iostream>
4 #include <iomanip>
5 #include <vector>
6 #include <set>
7 #include <algorithm>
8 #include <limits>
9 
10 #include "TMath.h"
11 
12 #include "km3net-dataformat/offline/Head.hh"
13 #include "km3net-dataformat/offline/Evt.hh"
14 #include "JDAQ/JDAQEventIO.hh"
15 #include "JDAQ/JDAQTimesliceIO.hh"
16 #include "JDAQ/JDAQSummarysliceIO.hh"
17 
18 #include "JDetector/JDetector.hh"
19 #include "JDetector/JDetectorSubset.hh"
20 #include "JDetector/JDetectorToolkit.hh"
21 #include "JDetector/JModuleRouter.hh"
22 
23 #include "JTrigger/JHit.hh"
24 #include "JTrigger/JFrame.hh"
25 #include "JTrigger/JTimeslice.hh"
26 #include "JTrigger/JHitL0.hh"
27 #include "JTrigger/JHitR1.hh"
28 #include "JTrigger/JBuildL0.hh"
29 #include "JTrigger/JTriggerParameters.hh"
30 
31 #include "JSupport/JMultipleFileScanner.hh"
32 #include "JSupport/JParallelFileScanner.hh"
33 #include "JSupport/JFileRecorder.hh"
34 #include "JSupport/JSupport.hh"
35 #include "JSupport/JMeta.hh"
36 #include "JSupport/JSummaryFileRouter.hh"
37 
38 #include "JFit/JLine1Z.hh"
39 #include "JFit/JEnergy.hh"
40 #include "JFit/JEnergyRegressor.hh"
41 #include "JFit/JFitToolkit.hh"
42 #include "JFit/JFitParameters.hh"
43 #include "JFit/JEvt.hh"
44 #include "JFit/JEvtToolkit.hh"
45 #include "JFit/JEnergyCorrection.hh"
46 #include "JFit/JNPEHit.hh"
47 #include "JFit/JStart.hh"
48 #include "JFit/JMEstimator.hh"
49 #include "JFit/JTimeRange.hh"
50 #include "JFit/JModel.hh"
51 
52 #include "JTools/JConstants.hh"
53 #include "JTools/JFunction1D_t.hh"
54 #include "JTools/JFunctionalMap_t.hh"
55 
56 #include "JPhysics/JPDFTable.hh"
57 #include "JPhysics/JPDFToolkit.hh"
58 #include "JPhysics/JNPETable.hh"
59 
60 #include "JLang/JComparator.hh"
61 
62 #include "Jeep/JParser.hh"
63 #include "Jeep/JMessage.hh"
64 
65 
66 namespace {
67 
68  using namespace JPP;
69 
70 
71  /**
72  * Auxiliary class for energy estimation.
73  */
74  struct JResult {
75  /**
76  * Constructor.
77  *
78  * \param x Energy [log(E/GeV)]
79  * \param chi2 chi2
80  */
81  JResult(const JEnergy& x = 0.0,
82  const double chi2 = std::numeric_limits<double>::max())
83  {
84  this->x = x;
85  this->chi2 = chi2;
86  }
87 
88 
89  /**
90  * Type conversion.
91  *
92  * \return true if valid chi2; else false
93  */
94  operator bool() const
95  {
96  return chi2 != std::numeric_limits<double>::max();
97  }
98 
99  JEnergy x; //!< Energy
100  double chi2; //!< chi2
101  };
102 
103 
104  /**
105  * Type definition of energy range.
106  */
107  typedef JTOOLS::JRange<JEnergy> JEnergyRange;
108 
109 
110  /**
111  * Definition of the various M-Estimators available to use
112  */
113  enum JMEstimator_t {
114  EM_NORMAL = 0,
115  EM_LORENTZIAN = 1,
116  EM_LINEAR = 2,
117  EM_NULL = 3
118  };
119 }
120 
121 
122 /**
123  * \file
124  *
125  * Program to perform JFIT::JRegressor<JEnergy, JGandalf> fit using I/O of JFIT::JEvt data.
126  * \author mdejong
127  */
128 int main(int argc, char **argv)
129 {
130  using namespace std;
131  using namespace JPP;
132  using namespace KM3NETDAQ;
133 
134  typedef JParallelFileScanner< JTypeList<JDAQEvent, JEvt> > JParallelFileScanner_t;
135  typedef JParallelFileScanner_t::multi_pointer_type multi_pointer_type;
136  typedef JTYPELIST<JAllTypes_t, JEvt>::typelist typelist;
137 
138  JParallelFileScanner_t inputFile;
139  JFileRecorder<typelist> outputFile;
140  JLimit_t& numberOfEvents = inputFile.getLimit();
141  string detectorFile;
142  string pdfFile;
143  double roadWidth_m;
144  JTimeRange T_ns;
145  double R_Hz;
146  size_t numberOfPrefits;
147  JEnergyCorrection correct;
148  JEnergyRange X;
149  JStart start;
150  bool reprocess;
151  int mestimator;
152  int debug;
153 
154  try {
155 
156  JParser<> zap("Program to perform fit of muon energy to data.");
157 
158  zap['f'] = make_field(inputFile);
159  zap['o'] = make_field(outputFile) = "energy.root";
160  zap['a'] = make_field(detectorFile);
161  zap['n'] = make_field(numberOfEvents) = JLimit::max();
162  zap['P'] = make_field(pdfFile);
163  zap['R'] = make_field(roadWidth_m) = numeric_limits<double>::max();
164  zap['T'] = make_field(T_ns) = JTimeRange(-50.0, +450.0); // ns
165  zap['B'] = make_field(R_Hz, "Default background rate if no summary data are available.") = 6.0e3;
166  zap['N'] = make_field(numberOfPrefits) = 0;
167  zap['E'] = make_field(correct) = JEnergyCorrection(); // off
168  zap['x'] = make_field(X) = JEnergyRange(1.0, 8.0); // log10(E/GeV)
169  zap['s'] = make_field(start) = JStart(); // off
170  zap['r'] = make_field(reprocess);
171  zap['M'] = make_field(mestimator) = EM_NORMAL, EM_LORENTZIAN, EM_LINEAR, EM_NULL;
172  zap['d'] = make_field(debug) = 1;
173 
174  zap(argc, argv);
175  }
176  catch(const exception& error) {
177  FATAL(error.what() << endl);
178  }
179 
180 
181 
182  cout.tie(&cerr);
183 
184 
185  JDetector detector;
186 
187  try {
188  load(detectorFile, detector);
189  }
190  catch(const JException& error) {
191  FATAL(error);
192  }
193 
194  const JModuleRouter moduleRouter(detector);
195  JSummaryFileRouter summaryRouter(inputFile, R_Hz);
196 
197  typedef vector<JHitL0> JDataL0_t;
198  const JBuildL0<JHitL0> buildL0;
199 
200 
201  typedef JRegressor<JEnergy> JRegressor_t;
202 
203  JRegressor_t::debug = debug;
204  JRegressor_t::T_ns = T_ns;
205 
206  const JEnergy ENERGY_RESOLUTION(0.01); // Energy resolution log10(E/GeV)
207 
208 
209  JRegressor_t fit(pdfFile);
210 
211  switch (mestimator) {
212 
213  case EM_NORMAL:
214  NOTICE("Using the normal M-Estimator." << endl);
215  fit.estimator.reset(new JMEstimatorNormal());
216  break;
217 
218  case EM_LORENTZIAN:
219  NOTICE("Using the Lorentzian M-Estimator." << endl);
220  fit.estimator.reset(new JMEstimatorLorentzian());
221  break;
222 
223  case EM_LINEAR:
224  NOTICE("Using the linear M-Estimator." << endl);
225  fit.estimator.reset(new JMEstimatorNormal());
226  break;
227 
228  case EM_NULL:
229  NOTICE("Using the JEnergy likelihood directly." << endl);
230  fit.estimator.reset(new JMEstimatorNull());
231  break;
232 
233  default:
234  FATAL("Invalid M-Estimator." << endl);
235  }
236 
237 
238  if (fit.getRmax() < roadWidth_m) {
239  roadWidth_m = fit.getRmax();
240  }
241 
242 
243  outputFile.open();
244 
245  outputFile.put(JMeta(argc, argv));
246 
247  while (inputFile.hasNext()) {
248 
249  STATUS("event: " << setw(10) << inputFile.getCounter() << '\r'); DEBUG(endl);
250 
251  multi_pointer_type ps = inputFile.next();
252 
253  JDAQEvent* tev = ps;
254  JEvt* evt = ps;
255  JEvt out;
256 
257  summaryRouter.update(*tev);
258 
259  JEvt::iterator __end = evt->end();
260 
261  if (reprocess) {
262  __end = partition(evt->begin(), __end, JHistory::is_not_event(JMUONENERGY));
263  }
264 
265  if (evt->begin() != __end) {
266 
267  copy(evt->begin(), __end, back_inserter(out));
268 
269  if (numberOfPrefits > 0) {
270  advance(__end = evt->begin(), min(numberOfPrefits, out.size()));
271  }
272 
273  partial_sort(evt->begin(), __end, evt->end(), qualitySorter);
274 
275  __end = partition(evt->begin(), __end, JHistory::is_event(evt->begin()->getHistory()));
276 
277 
278  JDataL0_t dataL0;
279 
280  buildL0(*tev, moduleRouter, true, back_inserter(dataL0));
281 
282 
283  for (JEvt::const_iterator track = evt->begin(); track != __end; ++track) {
284 
285  const JRotation3D R (getDirection(*track));
286  const JLine1Z tz(getPosition (*track).rotate(R), track->getT());
287  const JModel<JLine1Z> match(tz, roadWidth_m, JRegressor_t::T_ns);
288 
289 
290  multiset<JDAQPMTIdentifier> top;
291 
292  for (JDataL0_t::const_iterator i = dataL0.begin(); i != dataL0.end(); ++i) {
293 
294  JHitR1 hit(*i);
295 
296  hit.rotate(R);
297 
298  if (match(hit)) {
299  top.insert(i->getPMTIdentifier());
300  }
301  }
302 
303 
304  vector<JNPEHit> data;
305  vector<JNPEHit> buffer;
306 
307  const JDetectorSubset_t subdetector(detector, getAxis(*track), roadWidth_m);
308 
309  for (JDetector::const_iterator module = subdetector.begin(); module != subdetector.end(); ++module) {
310 
311  size_t total = 0;
312 
313  for (size_t i = 0; i != module->size(); ++i) {
314 
315  const JDAQSummaryFrame& summary = summaryRouter.getSummaryFrame(module->getID());
316 
317  if (!module->getPMT(i).has(JPMT::DAQ_STATUS) &&
318  !summary.testHighRateVeto(i) &&
319  !summary.testFIFOStatus (i)) {
320 
321  double rate_Hz = summary.getRate(i);
322 
323  if (rate_Hz <= 0.0) {
324  rate_Hz = summaryRouter.getRate();
325  }
326 
327  size_t count = top.count(JDAQPMTIdentifier(module->getID(), i));
328 
329  data.push_back(JNPEHit(fit.getNPE(module->getPMT(i), rate_Hz), count));
330 
331  total += count;
332  }
333  }
334 
335  if (total != 0) {
336  buffer.push_back(JNPEHit(fit.getNPE(*module, R_Hz), total));
337  }
338  }
339 
340  // start position of track
341 
342  vector<JNPEHit>::iterator __begin = data.begin();
343 
344  if (start.is_valid() && !buffer.empty()) {
345 
346  sort(buffer.begin(), buffer.end(), make_comparator(&JNPEHit::getZ));
347 
348  vector<JNPEHit>::const_iterator track_start = start.find(buffer.begin(), buffer.end());
349 
350  if (track_start != buffer.end()) {
351 
352  sort(data.begin(), data.end(), make_comparator(&JNPEHit::getZ));
353 
354  __begin = lower_bound(data.begin(), data.end(), track_start->getZ(), make_comparator(&JNPEHit::getZ));
355  }
356  }
357 
358 
359  const int NDF = distance(__begin, data.end()) - 1;
360 
361  if (NDF >= 0) {
362 
363 
364  // 5-point search between given limits
365 
366  const int N = 5;
367 
368  JResult result[N];
369 
370  for (int i = 0; i != N; ++i) {
371  result[i].x = X.getLowerLimit() + i * (X.getUpperLimit() - X.getLowerLimit()) / (N-1);
372  }
373 
374  do {
375 
376  int j = 0;
377 
378  for (int i = 0; i != N; ++i) {
379 
380  if (!result[i]) {
381  result[i].chi2 = fit(result[i].x, __begin, data.end());
382  }
383 
384  if (result[i].chi2 < result[j].chi2) {
385  j = i;
386  }
387  }
388 
389  // squeeze range
390 
391  switch (j) {
392 
393  case 0:
394  result[4] = result[1];
395  result[2] = JResult(0.5 * (result[0].x + result[4].x));
396  break;
397 
398  case 1:
399  result[4] = result[2];
400  result[2] = result[1];
401  break;
402 
403  case 2:
404  result[0] = result[1];
405  result[4] = result[3];
406  break;
407 
408  case 3:
409  result[0] = result[2];
410  result[2] = result[3];
411  break;
412 
413  case 4:
414  result[0] = result[3];
415  result[2] = JResult(0.5 * (result[0].x + result[4].x));
416  break;
417  }
418 
419  result[1] = JResult(0.5 * (result[0].x + result[2].x));
420  result[3] = JResult(0.5 * (result[2].x + result[4].x));
421 
422  } while (result[4].x - result[0].x > ENERGY_RESOLUTION);
423 
424 
425  if (result[1].chi2 != result[3].chi2) {
426 
427  result[2].x += 0.25 * (result[3].x - result[1].x) * (result[1].chi2 - result[3].chi2) / (result[1].chi2 + result[3].chi2 - 2*result[2].chi2);
428  result[2].chi2 = fit(result[2].x, __begin, data.end());
429  }
430 
431  const double chi2 = result[2].chi2;
432  const double E = result[2].x.getE();
433 
434  // Calculate additional variables
435  const double muRange = JPHYSICS::gWater(E); // The range of a muon with the reconstructed energy
436 
437  double noise_likelihood = 0.0; // The log likelihood of every hit being from K40
438  int nhits = 0; // The number of hits selected for JEnergy
439 
440  for (vector<JNPEHit>::const_iterator dom = data.begin(); dom != data.end(); ++dom) {
441 
442  noise_likelihood += log10(dom->getP()); // The probability of getting the observed multiplicity with K40
443  nhits += dom->getN(); // DOM multiplicity
444  }
445 
446 
447  out.push_back(JFit(*track).add(JMUONENERGY));
448 
449  // set corrected energy
450 
451  out.rbegin()->setE(correct(E));
452 
453  // set additional values
454 
455  out.rbegin()->setW(track->getW());
456  out.rbegin()->setW(JENERGY_ENERGY, E);
457  out.rbegin()->setW(JENERGY_CHI2, chi2);
458  out.rbegin()->setW(JENERGY_MUON_RANGE_METRES, muRange);
459  out.rbegin()->setW(JENERGY_NOISE_LIKELIHOOD, noise_likelihood);
460  out.rbegin()->setW(JENERGY_NDF, NDF);
461  out.rbegin()->setW(JENERGY_NUMBER_OF_HITS, nhits);
462  }
463  }
464 
465  // apply default sorter
466 
467  sort(out.begin(), out.end(), qualitySorter);
468  }
469 
470  outputFile.put(out);
471  }
472  STATUS(endl);
473 
474  JSingleFileScanner<JRemove<typelist, JEvt>::typelist> io(inputFile);
475 
476  io >> outputFile;
477 
478  outputFile.close();
479 }
JMUONENERGY
static const int JMUONENERGY
Definition: reconstruction.hh:17
JFIT::JMEstimatorLorentzian
Lorentzian M-estimator.
Definition: JMEstimator.hh:79
JEnergyRegressor.hh
JMeta.hh
Head.hh
KM3NETDAQ::JDAQFrameStatus::testHighRateVeto
bool testHighRateVeto() const
Test high-rate veto status.
Definition: JDAQFrameStatus.hh:201
KM3NETDAQ::JDAQEvent
DAQ Event.
Definition: JDAQEvent.hh:30
JTriggerParameters.hh
JFIT::JEnergy
Data structure for fit of energy.
Definition: JEnergy.hh:24
JSUPPORT::JSummaryFileRouter::update
void update(const JDAQHeader &header)
Update router.
Definition: JSummaryFileRouter.hh:72
JFileRecorder.hh
JSUPPORT::JLimit
Auxiliary class for defining the range of iterations of objects.
Definition: JLimit.hh:41
JMessage.hh
JROOT::advance
counter_type advance(counter_type &counter, const counter_type value, const counter_type limit=std::numeric_limits< counter_type >::max())
Advance counter.
Definition: JCounter.hh:35
JENERGY_CHI2
static const int JENERGY_CHI2
chi2 from JEnergy.cc
Definition: fitparameters.hh:17
JPHYSICS::gWater
static const JGeaneWater gWater
Function object for energy loss of muon in sea water.
Definition: JGeane.hh:328
JSummaryFileRouter.hh
JAANET::getAxis
JAxis3D getAxis(const Trk &track)
Get axis.
Definition: JAAnetToolkit.hh:244
JFitToolkit.hh
JSUPPORT::JSummaryFileRouter::getSummaryFrame
const JDAQSummaryFrame & getSummaryFrame(const JDAQModuleIdentifier &module) const
Get summary frame.
Definition: JSummaryFileRouter.hh:125
qualitySorter
bool qualitySorter(const JFIT::JFit &first, const JFIT::JFit &second)
Comparison of fit results.
Definition: quality_sorter.cc:10
JFIT::JFit::add
JFit & add(const int type)
Add event to history.
Definition: JEvt.hh:136
JFIT::JStart
Auxiliary class for start or end point evaluation.
Definition: JStart.hh:21
JTimeslice.hh
JENERGY_MUON_RANGE_METRES
static const int JENERGY_MUON_RANGE_METRES
range of a muon with the reconstructed energy [m] from JEnergy.cc
Definition: fitparameters.hh:25
JDETECTOR::load
void load(const JString &file_name, JDetector &detector)
Load detector from input file.
Definition: JDetectorToolkit.hh:476
JComparator.hh
JPDFToolkit.hh
std::vector< JHitL0 >
JTOOLS::JRange
Range of values.
Definition: JRange.hh:34
JFIT::JNPEHit
Auxiliary class for simultaneously handling light yields and response of PMT.
Definition: JNPEHit.hh:19
JEvtToolkit.hh
JTOOLS::j
int j
Definition: JPolint.hh:634
Evt.hh
JPARSER::JParser
Utility class to parse command line options.
Definition: JParser.hh:1493
distance
std::vector< T >::difference_type distance(typename std::vector< T >::const_iterator first, typename PhysicsEvent::const_iterator< T > second)
Specialisation of STL distance.
Definition: PhysicsEvent.hh:434
NOTICE
#define NOTICE(A)
Definition: JMessage.hh:64
JFIT::JEvt
Data structure for set of track fit results.
Definition: JEvt.hh:293
JFIT::JStart::is_valid
bool is_valid() const
Check validity of start or end point conditions.
Definition: JStart.hh:50
JEnergyCorrection.hh
JAANET::copy
void copy(const Head &from, JHead &to)
Copy header from from to to.
Definition: JHead.cc:152
JNPEHit.hh
JGEOMETRY3D::JPosition3D::rotate
JPosition3D & rotate(const JRotation3D &R)
Rotate.
Definition: JPosition3D.hh:185
KM3NETDAQ::JDAQSummaryFrame::getRate
double getRate(const int tdc, const double factor=1.0) const
Get count rate.
Definition: JDAQSummaryFrame.hh:456
JTOOLS::JTimeRange
JRange< double > JTimeRange
Type definition for time range.
Definition: JTools/JTimeRange.hh:19
JSupport.hh
JPP
This name space includes all other name spaces (except KM3NETDAQ, KM3NET and ANTARES).
Definition: JAAnetToolkit.hh:37
JFIT::JRegressor< JEnergy >
Regressor function object for JEnergy fit.
Definition: JEnergyRegressor.hh:49
JEvt.hh
JFunction1D_t.hh
JFIT::JMEstimatorNull
Null M-estimator.
Definition: JMEstimator.hh:53
JStart.hh
JBuildL0.hh
JSUPPORT::JSummaryFileRouter::getRate
double getRate() const
Get default rate.
Definition: JSummaryFileRouter.hh:61
JDAQEventIO.hh
KM3NETDAQ::JDAQSummaryFrame
Data storage class for rate measurements of all PMTs in one module.
Definition: JDAQSummaryFrame.hh:320
JDAQTimesliceIO.hh
debug
int debug
debug level
Definition: JSirene.cc:59
JConstants.hh
JTOOLS::result
return result
Definition: JPolint.hh:695
JFunctionalMap_t.hh
JFIT::JModel< JLine1Z >
Template specialisation of class JModel to match hit with muon trajectory along z-axis.
Definition: JModel.hh:34
JSUPPORT::JLimit::getLimit
const JLimit & getLimit() const
Get limit.
Definition: JLimit.hh:73
std::multiset
Definition: JSTDTypes.hh:14
JHit.hh
JMEstimator_t
JMEstimator_t
Definition of the various M-Estimators available to use.
Definition: JEnergy.cc:113
JENERGY_NDF
static const int JENERGY_NDF
number of degrees of freedom from JEnergy.cc
Definition: fitparameters.hh:27
JModuleRouter.hh
JFIT::JHistory::is_event
Auxiliary class to test history.
Definition: JHistory.hh:101
JNPETable.hh
JParallelFileScanner.hh
main
int main(int argc, char **argv)
Definition: JEnergy.cc:128
JHitR1.hh
JENERGY_NOISE_LIKELIHOOD
static const int JENERGY_NOISE_LIKELIHOOD
log likelihood of every hit being K40 from JEnergy.cc
Definition: fitparameters.hh:26
KM3NETDAQ::JDAQFrameStatus::testFIFOStatus
bool testFIFOStatus() const
Test FIFO status.
Definition: JDAQFrameStatus.hh:245
JMultipleFileScanner.hh
JTimeRange.hh
JLANG::JTypeList
Type list.
Definition: JTypeList.hh:22
STATUS
#define STATUS(A)
Definition: JMessage.hh:63
JFIT::JMEstimatorNormal
Normal M-estimator.
Definition: JMEstimator.hh:66
JParser.hh
JDetectorToolkit.hh
JFIT::JLine1Z
Data structure for fit of straight line paralel to z-axis.
Definition: JLine1Z.hh:27
JFIT::JHistory::is_not_event
Auxiliary class to test history.
Definition: JHistory.hh:149
JDETECTOR::JModuleRouter
Router for direct addressing of module data in detector data structure.
Definition: JModuleRouter.hh:34
JModel.hh
JTRIGGER::JHitR1
Reduced data structure for L1 hit.
Definition: JHitR1.hh:31
JAANET::getDirection
JDirection3D getDirection(const Vec &v)
Get direction.
Definition: JAAnetToolkit.hh:221
make_field
#define make_field(A,...)
macro to convert parameter to JParserTemplateElement object
Definition: JParser.hh:1954
JFitParameters.hh
JSUPPORT::JParallelFileScanner
General purpose class for parallel reading of objects from a single file or multiple files.
Definition: JParallelFileScanner.hh:31
KM3NETDAQ::JDAQPMTIdentifier
PMT identifier.
Definition: JDAQPMTIdentifier.hh:20
JDETECTOR::JDetector
Detector data structure.
Definition: JDetector.hh:80
JAANET::getPosition
JPosition3D getPosition(const Vec &v)
Get position.
Definition: JAAnetToolkit.hh:197
JAANET::detector
Detector file.
Definition: JHead.hh:130
JMEstimator.hh
JSUPPORT::JMeta
Auxiliary class for ROOT I/O of application specific meta data.
Definition: JMeta.hh:71
DEBUG
#define DEBUG(A)
Message macros.
Definition: JMessage.hh:62
std
Definition: jaanetDictionary.h:36
KM3NETDAQ
KM3NeT DAQ data structures and auxiliaries.
Definition: DataQueue.cc:39
JSUPPORT::JSummaryFileRouter
File router for fast addressing of summary data.
Definition: JSummaryFileRouter.hh:37
JEnergy.hh
JDAQSummarysliceIO.hh
JENERGY_NUMBER_OF_HITS
static const int JENERGY_NUMBER_OF_HITS
number of hits from JEnergy.cc
Definition: fitparameters.hh:28
JTRIGGER::JBuildL0< JHitL0 >
Template specialisation of L0 builder for JHitL0 data type.
Definition: JBuildL0.hh:101
JDetector.hh
JLANG::make_comparator
JComparator< JResult_t T::*, JComparison::lt > make_comparator(JResult_t T::*member)
Helper method to create comparator between values of data member.
Definition: JComparator.hh:143
JDetectorSubset.hh
JENERGY_ENERGY
static const int JENERGY_ENERGY
uncorrected energy [GeV] from JEnergy.cc
Definition: fitparameters.hh:16
JHitL0.hh
JFIT::JStart::find
T find(T __begin, T __end) const
Get start or end point of muon trajectory.
Definition: JStart.hh:108
FATAL
#define FATAL(A)
Definition: JMessage.hh:67
outputFile
string outputFile
Definition: JDAQTimesliceSelector.cc:37
JSUPPORT::JFileRecorder
Object writing to file.
Definition: JFileRecorder.hh:41
JLANG::JException
General exception.
Definition: JException.hh:23
JDETECTOR::JDetectorSubset_t
Detector subset without binary search functionality.
Definition: JDetectorSubset.hh:37
JPDFTable.hh
JGEOMETRY3D::JRotation3D
Rotation matrix.
Definition: JRotation3D.hh:111
JSUPPORT::JSingleFileScanner
Object reading from a list of files.
Definition: JSingleFileScanner.hh:75
JFrame.hh
JFIT::JEnergyCorrection
Auxiliary class for correction of energy determined by JEnergy.cc.
Definition: JEnergyCorrection.hh:39
JLine1Z.hh
JFIT::JFit
Data structure for track fit results.
Definition: JEvt.hh:31
Generated by   doxygen 1.8.16