Jpp
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
JHead.hh
Go to the documentation of this file.
1 #ifndef __JAANET__JHEAD__
2 #define __JAANET__JHEAD__
3 
4 #include <string>
5 #include <vector>
6 #include <cmath>
7 #include <ctype.h>
8 
9 #include "TObject.h"
10 
11 #include "evt/Vec.hh"
12 #include "evt/Head.hh"
13 
14 #include "JLang/JException.hh"
15 
16 
17 /**
18  * \author mdejong
19  */
20 
21 namespace JAANET {}
22 namespace JPP { using namespace JAANET; }
23 
24 namespace JAANET {
25 
26  using JLANG::JException;
27 
28  static const char AANET_TAG_SEPARATOR = '_'; //!< Separator for AAnet tag extension for multiple tags ("_<counter>").
29 
30  class JHead; // forward declaration for copy methods
31 
32 
33  /**
34  * Copy header from <tt>from</tt> to <tt>to</tt>.
35  *
36  * \param from header
37  * \param to header
38  */
39  extern void copy(const JHead& from, Head& to);
40 
41 
42  /**
43  * Copy header from <tt>from</tt> to <tt>to</tt>.
44  *
45  * \param from header
46  * \param to header
47  */
48  extern void copy(const Head& from, JHead& to);
49 
50 
51  /**
52  * Get tag without aanet extension "_<counter>" for identical tags.
53  *
54  * \param tag tag
55  * \return tag
56  */
57  inline std::string getTag(const std::string& tag)
58  {
59  using namespace std;
60 
61  const string::size_type pos = tag.find(AANET_TAG_SEPARATOR);
62 
63  if (pos != string::npos) {
64 
65  for (string::size_type i = pos + 1; i != tag.size(); ++i) {
66  if (!isdigit(tag[i])) {
67  return tag;
68  }
69  }
70 
71  return tag.substr(0, pos);
72  }
73 
74  return tag;
75  }
76 
77 
78  /**
79  * Start of run record.
80  */
81  struct start_run {
82  /**
83  * Default constructor.
84  */
85  start_run() :
86  run_id(0)
87  {}
88 
89  int run_id; ///< MC run number
90 
92  };
93 
94 
95  /**
96  * General purpose string class.
97  */
98  struct String {
99  /**
100  * Default constructor.
101  */
102  String() :
103  buffer()
104  {}
105 
106  /**
107  * Equality.
108  *
109  * \param object string
110  * \return true if equals; else false
111  */
112  inline bool equals(const String& object) const
113  {
114  return buffer == object.buffer;
115  }
116 
117  std::string buffer; ///< General purpose name
118 
119  ClassDefNV(String,1);
120  };
121 
122 
123  /**
124  * Detector file.
125  */
126  struct detector :
127  public String
128  {
129  ClassDefNV(detector,1);
130  };
131 
132 
133  /**
134  * Muon descriptor file.
135  */
136  struct muon_desc_file :
137  public String
138  {
140  };
141 
142 
143  /**
144  * Target.
145  */
146  struct target :
147  public String
148  {
149  ClassDefNV(target,1);
150  };
151 
152 
153  /**
154  * Neutrino cross section file.
155  */
156  struct XSecFile :
157  public String
158  {
159  ClassDefNV(XSecFile,1);
160  };
161 
162 
163  /**
164  * General purpose class of phase space generation.
165  */
166  struct cut {
167  /**
168  * Default constructor.
169  */
170  cut() :
171  Emin(0),
172  Emax(0),
173  cosTmin(0),
174  cosTmax(0)
175  {}
176 
177  /**
178  * Comparison.
179  *
180  * \param object cut
181  * \return true if this cut less than given cut; else false
182  */
183  inline bool less(const cut& object) const
184  {
185  if (Emin == object.Emin &&
186  Emax == object.Emax)
187  return cosTmax < object.cosTmin;
188  else
189  return Emax < object.Emin;
190  }
191 
192  /**
193  * Equality.
194  *
195  * \param object cut
196  * \return true if equals; else false
197  */
198  inline bool equals(const cut& object) const
199  {
200  return (Emin == object.Emin &&
201  Emax == object.Emax &&
202  cosTmin == object.cosTmin &&
203  cosTmax == object.cosTmax);
204  }
205 
206  double Emin; ///< Minimal energy [GeV]
207  double Emax; ///< Maximal energy [GeV]
208  double cosTmin; ///< Minimal cosine zenith angle
209  double cosTmax; ///< Maximal cosine zenith angle
210 
211  ClassDefNV(cut,1);
212  };
213 
214 
215  /**
216  * Phase space of primary particle.
217  */
218  struct cut_primary :
219  public cut
220  {
222  };
223 
224 
225  /**
226  * Phase space of atmospheric muon generation.
227  */
228  struct cut_seamuon :
229  public cut
230  {
232  };
233 
234 
235  /**
236  * Phase space of incoming particle
237  */
238  struct cut_in :
239  public cut
240  {
241  ClassDefNV(cut_in,1);
242  };
243 
244 
245  /**
246  * Phase space of incident neutrino.
247  */
248  struct cut_nu :
249  public cut
250  {
251  ClassDefNV(cut_nu,1);
252  };
253 
254 
255  /**
256  * Description of Monte Carlo event generation applications.
257  */
258  struct generator {
259  /**
260  * Default constructor.
261  */
263  program(),
264  version(),
265  date(),
266  time()
267  {}
268 
269  std::string program; ///< program name
270  std::string version; ///< program version
271  std::string date; ///< processing date
272  std::string time; ///< processing time
273 
275  };
276 
277 
278  /**
279  * Generator for neutrino interaction
280  */
281  struct physics :
282  public generator
283  {
284  ClassDefNV(physics,1);
285  };
286 
287 
288  /**
289  * Generator for ?
290  */
291  struct simul :
292  public generator
293  {
294  ClassDefNV(simul,1);
295  };
296 
297 
298  /**
299  * Neutrino energy spectrum.
300  */
301  struct spectrum {
302  /**
303  * Default constructor.
304  */
305  spectrum() :
306  alpha(0)
307  {}
308 
309  /**
310  * Equality.
311  *
312  * \param object spectrum
313  * \return true if equals; else false
314  */
315  inline bool equals(const spectrum& object) const
316  {
317  return (alpha == object.alpha);
318  }
319 
320  double alpha; ///< Energy spectrum: \f$ \Phi \propto E^{-\alpha} \f$
321 
322  ClassDefNV(spectrum,1);
323  };
324 
325 
326  /**
327  * The cylinder used for photon tracking.
328  */
329  struct can {
330  /**
331  * Default constructor.
332  */
333  can() :
334  zmin(0),
335  zmax(0),
336  r(0)
337  {}
338 
339  /**
340  * Equality.
341  *
342  * \param object can
343  * \return true if equals; else false
344  */
345  inline bool equals(const can& object) const
346  {
347  return (zmin == object.zmin &&
348  zmax == object.zmax &&
349  r == object.r);
350  }
351 
352  double zmin; ///< Bottom [m]
353  double zmax; ///< Top [m]
354  double r; ///< Radius [m]
355 
356  ClassDefNV(can,1);
357  };
358 
359 
360  /**
361  * Neutrino vertex volume.
362  */
363  struct genvol {
364  /**
365  * Default constructor.
366  */
367  genvol() :
368  zmin(0),
369  zmax(0),
370  r(0),
371  volume(0),
372  numberOfEvents(0)
373  {}
374 
375  /**
376  * Equality.
377  *
378  * \param object generation volume
379  * \return true if equals; else false
380  */
381  inline bool equals(const genvol& object) const
382  {
383  return (zmin == object.zmin &&
384  zmax == object.zmax &&
385  r == object.r);
386  }
387 
388  /**
389  * Addition.
390  *
391  * \param object generation volume
392  * \return this generation volume
393  */
394  inline genvol& add(const genvol& object)
395  {
396  numberOfEvents += object.numberOfEvents;
397 
398  return *this;
399  }
400 
401  /**
402  * Scale.
403  *
404  * \param factor 1D scale factor
405  * \param z z position
406  * \return this genvol
407  */
408  inline genvol& mul(const double factor,
409  const double z = 0.0)
410  {
411  zmin = (zmin - z) * factor + z;
412  zmax = (zmax - z) * factor + z;
413  r *= factor;
414  volume *= factor * factor * factor;
415 
416  return *this;
417  }
418 
419  double zmin; ///< Bottom [m]
420  double zmax; ///< Top [m]
421  double r; ///< Radius [m]
422  double volume; ///< Volume [m^3]
423  double numberOfEvents; ///< Number of events
424 
425  ClassDefNV(genvol,1);
426  };
427 
428 
429  /**
430  * Coordinate origin.
431  */
432  struct coord_origin :
433  public Vec
434  {
435  /**
436  * Default constructor.
437  */
439  Vec()
440  {}
441 
442  /**
443  * Constructor.
444  *
445  * \param x x position
446  * \param y y position
447  * \param z z position
448  */
449  coord_origin(const double x,
450  const double y,
451  const double z) :
452  Vec(x,y,z)
453  {}
454 
455  /**
456  * Equality.
457  *
458  * \param object coordinate origin
459  * \return true if equals; else false
460  */
461  inline bool equals(const coord_origin& object) const
462  {
463  return (x == object.x &&
464  y == object.y &&
465  z == object.z);
466  }
467 
469  };
470 
471 
472  /**
473  * Phase space for incident neutrino.
474  */
475  struct genhencut {
476  /**
477  * Default constructor.
478  */
480  gDir(0),
481  Emin(0)
482  {}
483 
484  double gDir; ///< Angle
485  double Emin; ///< Minimal energy [GeV]
486 
488  };
489 
490 
491  /**
492  * Normlisation of CORSIKA events.
493  */
494  struct norma {
495  /**
496  * Default constructor.
497  */
498  norma() :
499  primaryFlux(0),
501  {}
502 
503  /**
504  * Equality.
505  *
506  * \param object normalisation
507  * \return true if equals; else false
508  */
509  inline bool equals(const norma& object) const
510  {
511  return (primaryFlux == object.primaryFlux);
512  }
513 
514  /**
515  * Addition.
516  *
517  * \param object normalisation
518  * \return this normalisation
519  */
520  inline norma& add(const norma& object)
521  {
522  numberOfPrimaries += object.numberOfPrimaries;
523 
524  return *this;
525  }
526 
527  double primaryFlux; ///< Primary flux
528  double numberOfPrimaries; ///< Number of primaries
529 
530  ClassDefNV(norma,1);
531  };
532 
533 
534  /**
535  * Normalisation of MUPAGE events.
536  */
537  struct livetime {
538  public:
539  /**
540  * Default constructor.
541  */
543  numberOfSeconds(0),
544  errorOfSeconds(0)
545  {}
546 
547  /**
548  * Equality.
549  *
550  * \param object live time
551  * \return true if equals; else false
552  */
553  inline bool equals(const livetime& object) const
554  {
555  return ((numberOfSeconds == 0.0 && object.numberOfSeconds == 0.0) ||
556  (numberOfSeconds > 0.0 && object.numberOfSeconds > 0.0));
557  }
558 
559  /**
560  * Addition.
561  *
562  * \param object live time
563  * \return this live time
564  */
565  inline livetime& add(const livetime& object)
566  {
567  numberOfSeconds += object.numberOfSeconds;
569  object.errorOfSeconds * object.errorOfSeconds);
570 
571  return *this;
572  }
573 
574  /**
575  * Scale.
576  *
577  * \param factor 1D scale factor
578  * \return this livetime
579  */
580  inline livetime& mul(const double factor)
581  {
582  numberOfSeconds /= (factor * factor);
583  errorOfSeconds /= (factor * factor);
584 
585  return *this;
586  }
587 
588  double numberOfSeconds; ///< Live time [s]
589  double errorOfSeconds; ///< Uncertainty on live time [s]
590 
591  ClassDefNV(livetime,1);
592  };
593 
594 
595  /**
596  * Neutrino flux.
597  */
598  struct flux {
599  public:
600  /**
601  * Default constructor.
602  */
603  flux() :
604  type(0),
605  key(),
606  file_1(),
607  file_2()
608  {}
609 
610  int type; ///< Type
611  std::string key; ///< Key
612  std::string file_1; ///< File name
613  std::string file_2; ///< File name
614 
615  ClassDefNV(flux,1);
616  };
617 
618 
619  /**
620  * The bottom of the sea.
621  */
622  struct seabottom {
623  /**
624  * Default constructor.
625  */
627  z(0)
628  {}
629 
630  /**
631  * Equality.
632  *
633  * \param object can
634  * \return true if equals; else false
635  */
636  inline bool equals(const seabottom& object) const
637  {
638  return (z == object.z);
639  }
640 
641  double z; ///< Sea bottom [m]
642 
644  };
645 
646 
647  /**
648  * Normalisation of DAQ data.
649  */
650  struct DAQ {
651  public:
652  /**
653  * Default constructor.
654  */
655  DAQ() :
656  livetime_s(0.0)
657  {}
658 
659  /**
660  * Equality.
661  *
662  * \param object DAQ
663  * \return true if equals; else false
664  */
665  inline bool equals(const DAQ& object) const
666  {
667  return ((livetime_s == 0.0 && object.livetime_s == 0.0) ||
668  (livetime_s > 0.0 && object.livetime_s > 0.0));
669  }
670 
671  /**
672  * Addition.
673  *
674  * \param object DAQ
675  * \return this DAQ
676  */
677  inline DAQ& add(const DAQ& object)
678  {
679  livetime_s += object.livetime_s;
680 
681  return *this;
682  }
683 
684  double livetime_s; ///< Live time [s]
685 
686  ClassDefNV(DAQ,1);
687  };
688 
689 
690  /**
691  * End of event record.
692  */
693  struct end_event {
694  /**
695  * Default constructor.
696  */
698  {}
699 
701  };
702 
703 
704  /**
705  * Check validity of given value.
706  *
707  * \param value value
708  * \return true if given value not-equal to default value; else false
709  */
710  template<class T>
711  inline bool is_valid(const T& value)
712  {
713  return !value.equals(T());
714  }
715 
716 
717  /**
718  * Monte Carlo run header.
719  *
720  * This class extends the Head class so that the data from specific tags
721  * can be promoted to concrete data types.
722  *
723  * Note that for the copy of 'new' JHead data (i.e. data not obtained via a previous JAANET::copy) to become effective,
724  * the key words in the corresponding map should be set. \n
725  * To this end, method JAANET::push can be used which is available in JHeadToolkit.hh.
726  */
727  struct JHead :
728  public Head
729  {
730  /**
731  * Generators.
732  */
733  static const std::string GENHEN;
734  static const std::string GENIE;
735  static const std::string GSEAGEN;
736  static const std::string MUPAGE;
737  static const std::string JSIRENE;
738  static const std::string KM3;
739 
740 
741  /**
742  * Default constructor.
743  */
745  {}
746 
747 
748  /**
749  * Copy constructor.
750  *
751  * \param header header
752  */
753  JHead(const Head& header)
754  {
755  copy(header, *this);
756  }
757 
758 
759  /**
760  * Virtual destructor.
761  */
762  virtual ~JHead()
763  {}
764 
765 
766  /**
767  * Comparison of headers.
768  *
769  * \param header header
770  * \return true if this header less than given header; else false
771  */
772  inline bool less(const JHead& header) const
773  {
774  return (cut_primary .less(header.cut_primary));
775  }
776 
777 
778  /**
779  * Test compatibility of headers.
780  *
781  * \param header header
782  * \return true if compatible; else false
783  */
784  inline bool equals(const JHead& header) const
785  {
786  return (cut_primary .equals(header.cut_primary) &&
787  cut_seamuon .equals(header.cut_seamuon) &&
788  cut_in .equals(header.cut_in) &&
789  cut_nu .equals(header.cut_nu) &&
790  can .equals(header.can) &&
791  coord_origin.equals(header.coord_origin) &&
792  genvol .equals(header.genvol) &&
793  norma .equals(header.norma) &&
794  seabottom .equals(header.seabottom) &&
795  livetime .equals(header.livetime) &&
796  DAQ .equals(header.DAQ));
797  }
798 
799 
800  /**
801  * Addition of headers.
802  *
803  * \param header header
804  * \return this header
805  */
806  inline JHead& add(const JHead& header)
807  {
808  if (equals(header)) {
809 
810  genvol .add(header.genvol);
811  norma .add(header.norma);
812  livetime.add(header.livetime);
813  DAQ .add(header.DAQ);
814 
815  } else {
816  THROW(JException, "JHead::add() header not compatible.");
817  }
818 
819  return *this;
820  }
821 
822 
823  /**
824  * Equal operator.
825  *
826  * \param first first header
827  * \param second second header
828  * \return true if two headers are equal; else false
829  */
830  friend inline bool operator==(const JHead& first,
831  const JHead& second)
832  {
833  return first.equals(second);
834  }
835 
836 
837  /**
838  * Less than operator.
839  *
840  * \param first first header
841  * \param second second header
842  * \return true if first header is less than second header; else false
843  */
844  friend inline bool operator<(const JHead& first,
845  const JHead& second)
846  {
847  return first.less(second);
848  }
849 
850 
851  JAANET::start_run start_run; // first data member
871  JAANET::end_event end_event; // last data member
872 
873 
874  ClassDef(JHead,1);
875  };
876 
877 
878  /**
879  * Equal operator.
880  *
881  * \param first first header
882  * \param second second header
883  * \return true if two headers are equal; else false
884  */
885  inline bool operator==(const Head& first,
886  const Head& second)
887  {
888  return JHead(first).equals(JHead(second));
889  }
890 
891 
892  /**
893  * Less than operator.
894  *
895  * \param first first header
896  * \param second second header
897  * \return true if first header is less than second header; else false
898  */
899  inline bool operator<(const Head& first,
900  const Head& second)
901  {
902  return JHead(first).less(JHead(second));
903  }
904 }
905 
906 #endif
norma & add(const norma &object)
Addition.
Definition: JHead.hh:520
double zmin
Bottom [m].
Definition: JHead.hh:352
JAANET::genhencut genhencut
Definition: JHead.hh:866
General exception.
Definition: JException.hh:40
Phase space of incident neutrino.
Definition: JHead.hh:248
static const std::string GSEAGEN
Definition: JHead.hh:735
livetime & mul(const double factor)
Scale.
Definition: JHead.hh:580
JAANET::genvol genvol
Definition: JHead.hh:864
Neutrino vertex volume.
Definition: JHead.hh:363
Exceptions.
double r
Radius [m].
Definition: JHead.hh:421
JAANET::norma norma
Definition: JHead.hh:867
Target.
Definition: JHead.hh:146
static const std::string KM3
Definition: JHead.hh:738
genvol & mul(const double factor, const double z=0.0)
Scale.
Definition: JHead.hh:408
double volume
Volume [m^3].
Definition: JHead.hh:422
bool equals(const norma &object) const
Equality.
Definition: JHead.hh:509
ClassDefNV(cut_in, 1)
Normalisation of DAQ data.
Definition: JHead.hh:650
seabottom()
Default constructor.
Definition: JHead.hh:626
livetime & add(const livetime &object)
Addition.
Definition: JHead.hh:565
friend bool operator<(const JHead &first, const JHead &second)
Less than operator.
Definition: JHead.hh:844
Phase space of incoming particle.
Definition: JHead.hh:238
Generator for ?
Definition: JHead.hh:291
bool operator<(const Head &first, const Head &second)
Less than operator.
Definition: JHead.hh:899
double alpha
Energy spectrum: .
Definition: JHead.hh:320
ClassDefNV(target, 1)
Phase space for incident neutrino.
Definition: JHead.hh:475
double numberOfEvents
Number of events.
Definition: JHead.hh:423
ClassDefNV(spectrum, 1)
ClassDefNV(cut, 1)
std::string program
program name
Definition: JHead.hh:269
Neutrino cross section file.
Definition: JHead.hh:156
bool equals(const seabottom &object) const
Equality.
Definition: JHead.hh:636
#define THROW(JException_t, A)
Marco for throwing exception with std::ostream compatible message.
Definition: JException.hh:633
bool equals(const spectrum &object) const
Equality.
Definition: JHead.hh:315
livetime()
Default constructor.
Definition: JHead.hh:542
bool equals(const String &object) const
Equality.
Definition: JHead.hh:112
Normlisation of CORSIKA events.
Definition: JHead.hh:494
JAANET::cut_primary cut_primary
Definition: JHead.hh:858
double errorOfSeconds
Uncertainty on live time [s].
Definition: JHead.hh:589
std::vector< JAANET::physics > physics
Definition: JHead.hh:856
double Emax
Maximal energy [GeV].
Definition: JHead.hh:207
ClassDefNV(coord_origin, 1)
double livetime_s
Live time [s].
Definition: JHead.hh:684
JHead & add(const JHead &header)
Addition of headers.
Definition: JHead.hh:806
genhencut()
Default constructor.
Definition: JHead.hh:479
ClassDefNV(genhencut, 1)
bool equals(const coord_origin &object) const
Equality.
Definition: JHead.hh:461
ClassDefNV(livetime, 1)
General purpose class of phase space generation.
Definition: JHead.hh:166
DAQ & add(const DAQ &object)
Addition.
Definition: JHead.hh:677
ClassDefNV(cut_primary, 1)
Coordinate origin.
Definition: JHead.hh:432
Generator for neutrino interaction.
Definition: JHead.hh:281
ClassDefNV(cut_seamuon, 1)
Description of Monte Carlo event generation applications.
Definition: JHead.hh:258
ClassDefNV(end_event, 1)
genvol & add(const genvol &object)
Addition.
Definition: JHead.hh:394
ClassDefNV(generator, 1)
ClassDef(JHead, 1)
ClassDefNV(start_run, 1)
ClassDefNV(cut_nu, 1)
Start of run record.
Definition: JHead.hh:81
spectrum()
Default constructor.
Definition: JHead.hh:305
JAANET::end_event end_event
Definition: JHead.hh:871
bool less(const JHead &header) const
Comparison of headers.
Definition: JHead.hh:772
double zmax
Top [m].
Definition: JHead.hh:420
JAANET::can can
Definition: JHead.hh:863
std::string buffer
General purpose name.
Definition: JHead.hh:117
bool equals(const genvol &object) const
Equality.
Definition: JHead.hh:381
bool operator==(Packet const &p, ID const &id)
Detector file.
Definition: JHead.hh:126
JNET::JTag getTag(JLANG::JType< KM3NETDAQ::JDAQTimeslice >)
Definition: JDAQTags.hh:80
bool equals(const can &object) const
Equality.
Definition: JHead.hh:345
JAANET::cut_seamuon cut_seamuon
Definition: JHead.hh:859
generator()
Default constructor.
Definition: JHead.hh:262
double numberOfPrimaries
Number of primaries.
Definition: JHead.hh:528
JAANET::livetime livetime
Definition: JHead.hh:868
JHead()
Default constructor.
Definition: JHead.hh:744
flux()
Default constructor.
Definition: JHead.hh:603
static const std::string MUPAGE
Definition: JHead.hh:736
JAANET::seabottom seabottom
Definition: JHead.hh:869
cut()
Default constructor.
Definition: JHead.hh:170
Neutrino flux.
Definition: JHead.hh:598
static const std::string GENIE
Definition: JHead.hh:734
JAANET::start_run start_run
Definition: JHead.hh:851
ClassDefNV(flux, 1)
ClassDefNV(String, 1)
friend bool operator==(const JHead &first, const JHead &second)
Equal operator.
Definition: JHead.hh:830
ClassDefNV(detector, 1)
std::string version
program version
Definition: JHead.hh:270
JAANET::spectrum spectrum
Definition: JHead.hh:862
std::string file_2
File name.
Definition: JHead.hh:613
static const std::string JSIRENE
Definition: JHead.hh:737
std::string key
Key.
Definition: JHead.hh:611
int type
Type.
Definition: JHead.hh:610
DAQ()
Default constructor.
Definition: JHead.hh:655
bool equals(const DAQ &object) const
Equality.
Definition: JHead.hh:665
ClassDefNV(muon_desc_file, 1)
double zmin
Bottom [m].
Definition: JHead.hh:419
Monte Carlo run header.
Definition: JHead.hh:727
genvol()
Default constructor.
Definition: JHead.hh:367
int run_id
MC run number.
Definition: JHead.hh:89
double Emin
Minimal energy [GeV].
Definition: JHead.hh:485
can()
Default constructor.
Definition: JHead.hh:333
ClassDefNV(simul, 1)
JAANET::muon_desc_file muon_desc_file
Definition: JHead.hh:854
norma()
Default constructor.
Definition: JHead.hh:498
virtual ~JHead()
Virtual destructor.
Definition: JHead.hh:762
ClassDefNV(genvol, 1)
double r
Radius [m].
Definition: JHead.hh:354
coord_origin(const double x, const double y, const double z)
Constructor.
Definition: JHead.hh:449
Normalisation of MUPAGE events.
Definition: JHead.hh:537
ClassDefNV(can, 1)
ClassDefNV(norma, 1)
std::string date
processing date
Definition: JHead.hh:271
bool equals(const livetime &object) const
Equality.
Definition: JHead.hh:553
JAANET::cut_in cut_in
Definition: JHead.hh:860
ClassDefNV(seabottom, 1)
bool less(const cut &object) const
Comparison.
Definition: JHead.hh:183
General purpose string class.
Definition: JHead.hh:98
start_run()
Default constructor.
Definition: JHead.hh:85
double gDir
Angle.
Definition: JHead.hh:484
JAANET::simul simul
Definition: JHead.hh:857
double primaryFlux
Primary flux.
Definition: JHead.hh:527
double cosTmax
Maximal cosine zenith angle.
Definition: JHead.hh:209
bool equals(const JHead &header) const
Test compatibility of headers.
Definition: JHead.hh:784
JAANET::target target
Definition: JHead.hh:855
void copy(const Head &from, JHead &to)
Copy header from from to to.
Definition: JHead.cc:40
ClassDefNV(XSecFile, 1)
Muon descriptor file.
Definition: JHead.hh:136
double z
Sea bottom [m].
Definition: JHead.hh:641
static const std::string GENHEN
Generators.
Definition: JHead.hh:733
JAANET::cut_nu cut_nu
Definition: JHead.hh:861
end_event()
Default constructor.
Definition: JHead.hh:697
Phase space of atmospheric muon generation.
Definition: JHead.hh:228
JAANET::detector detector
Definition: JHead.hh:853
std::string time
processing time
Definition: JHead.hh:272
End of event record.
Definition: JHead.hh:693
Phase space of primary particle.
Definition: JHead.hh:218
JAANET::coord_origin coord_origin
Definition: JHead.hh:865
static const char AANET_TAG_SEPARATOR
Separator for AAnet tag extension for multiple tags (&quot;_&lt;counter&gt;&quot;).
Definition: JHead.hh:28
bool equals(const cut &object) const
Equality.
Definition: JHead.hh:198
JAANET::XSecFile XSecFile
Definition: JHead.hh:852
JAANET::DAQ DAQ
Definition: JHead.hh:870
double Emin
Minimal energy [GeV].
Definition: JHead.hh:206
double numberOfSeconds
Live time [s].
Definition: JHead.hh:588
ClassDefNV(physics, 1)
double cosTmin
Minimal cosine zenith angle.
Definition: JHead.hh:208
JHead(const Head &header)
Copy constructor.
Definition: JHead.hh:753
bool is_valid(const T &value)
Check validity of given value.
Definition: JHead.hh:711
Neutrino energy spectrum.
Definition: JHead.hh:301
ClassDefNV(DAQ, 1)
The bottom of the sea.
Definition: JHead.hh:622
String()
Default constructor.
Definition: JHead.hh:102
double zmax
Top [m].
Definition: JHead.hh:353
The cylinder used for photon tracking.
Definition: JHead.hh:329
std::string file_1
File name.
Definition: JHead.hh:612
coord_origin()
Default constructor.
Definition: JHead.hh:438