Jpp 20.0.0-27-g39925593c-D
the software that should make you happy
Loading...
Searching...
No Matches
Functions
JShowerPostfit.cc File Reference

Example program to histogram shower fit results: it handles both neutrino and muon productions. More...

#include <string>
#include <iostream>
#include <iomanip>
#include <vector>
#include <set>
#include "TROOT.h"
#include "TFile.h"
#include "TH1D.h"
#include "TH2D.h"
#include "TProfile.h"
#include "TMath.h"
#include "km3net-dataformat/offline/Head.hh"
#include "km3net-dataformat/offline/Evt.hh"
#include "km3net-dataformat/online/JDAQModuleIdentifier.hh"
#include "km3net-dataformat/definitions/reconstruction.hh"
#include "km3net-dataformat/definitions/fitparameters.hh"
#include "km3net-dataformat/tools/time_converter.hh"
#include "JAAnet/JHead.hh"
#include "JAAnet/JHeadToolkit.hh"
#include "JAAnet/JAAnetToolkit.hh"
#include "JAAnet/JVolume.hh"
#include "JDAQ/JDAQEventIO.hh"
#include "JPhysics/JConstants.hh"
#include "JTools/JQuantile.hh"
#include "JSupport/JTriggeredFileScanner.hh"
#include "JSupport/JMonteCarloFileSupportkit.hh"
#include "JSupport/JSupport.hh"
#include "JReconstruction/JEvt.hh"
#include "JReconstruction/JEvtToolkit.hh"
#include "JLang/JPredicate.hh"
#include "JPhysics/JGeanz.hh"
#include "JGeometry3D/JShower3E.hh"
#include "JGeometry3D/JCylinder3D.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"

Go to the source code of this file.

Functions

int main (int argc, char **argv)
 

Detailed Description

Example program to histogram shower fit results: it handles both neutrino and muon productions.

Author
mdejong, adomi

Definition in file JShowerPostfit.cc.

Function Documentation

◆ main()

int main ( int argc,
char ** argv )

Definition at line 79 of file JShowerPostfit.cc.

80{
81 using namespace std;
82 using namespace JPP;
83 using namespace KM3NETDAQ;
84
85 typedef JTriggeredFileScanner<JEvt> JTriggeredFileScanner_t;
86 typedef JTriggeredFileScanner_t::multi_pointer_type multi_pointer_type;
87
88 JTriggeredFileScanner_t inputFile;
89 JLimit_t& numberOfEvents = inputFile.getLimit();
90 string outputFile;
91 size_t numberOfPrefits;
92 JQualitySorter quality_sorter;
93 JAtmosphericMuon atmosphere;
94 double Emin_GeV;
95 double NPE;
96 int application;
97 string option;
98 bool isMuon;
99 bool wrtNeutrino;
100 double radius;
101 JRange<double> height;
102 int debug;
103
104 try {
105
106 JParser<> zap("Example program to histogram fit results.");
107
108 zap['f'] = make_field(inputFile);
109 zap['o'] = make_field(outputFile) = "postfit.root";
110 zap['n'] = make_field(numberOfEvents) = JLimit::max();
111 zap['N'] = make_field(numberOfPrefits) = 1;
112 zap['L'] = make_field(quality_sorter) = JPARSER::initialised();
113 zap['E'] = make_field(Emin_GeV) = 0.0;
114 zap['M'] = make_field(NPE) = 0.0;
115 zap['A'] = make_field(application) = JSHOWERPREFIT, JSHOWERPOINTSIMPLEX, JSHOWERPOSITIONFIT, JSHOWERDIRECTIONPREFIT, JSHOWERCOMPLETEFIT, JSHOWER_BJORKEN_Y;
116 zap['a'] = make_field(atmosphere) = JAtmosphericMuon(90.0, 90.0);
117 zap['O'] = make_field(option) = "E", "N", "LINE", "LOGE";
118 zap['I'] = make_field(isMuon);
119 zap['w'] = make_field(wrtNeutrino);
120 zap['r'] = make_field(radius) = numeric_limits<double>::max(); // no containment
121 zap['z'] = make_field(height) = JRange<double>(); // no containment
122 zap['d'] = make_field(debug) = 2;
123
124 zap(argc, argv);
125 }
126 catch(const exception& error) {
127 FATAL(error.what() << endl);
128 }
129
130 cout << "APPLICATION " << application << endl;
131
132 JHead head;
133
134 try {
135 head = getCommonHeader(inputFile);
136 }
137 catch(const exception& error) {
138 FATAL(error.what() << endl);
139 }
140
141 JVolume volume(head, option != "LINE");
142 JPosition3D offset = getPosition(getOffset(head));
143 JPosition3D origin = getPosition(getOrigin(head));
144 JCylinder3D cylinder = getCylinder(head);
145
146 cylinder.add(offset);
147
148 JCylinder3D containment(JCircle2D(JPosition2D(), radius), height.getLowerLimit(), height.getUpperLimit());
149
150 containment.add(origin);
151
152 NOTICE("Offset: " << offset << endl);
153 NOTICE("Origin: " << origin << endl);
154 NOTICE("Cylinder: " << cylinder << endl);
155 NOTICE("Containment: " << containment << endl);
156
157 const double EMIN_GEV = 10e3; // MUPAGE
158
159 TFile out(outputFile.c_str(), "recreate");
160
161 TH1D job("job", NULL, 100, 0.5, 100.5);
162
163 TH1D hn("hn", "NDF (Number of Degrees of Freedom)", 250, -0.5, 249.5);
164 TH1D hq("hq", "Fit Quality", 300, 0.0, 600.0);
165 TH1D hi("hi", "Fit Index vs Best Resolution", 101, -0.5, 100.5); // to see if the fit with the best quality has also the best resolution
166 TH1D hd("hd", "Distance between Reco and True position", 2000, 0.0, 100.0); // [m]
167 TH1D hz("hz", "Longitudinal Distance between Reco and MC lepton position", 100, -200.0, 200.0); // [m]
168 TH1D ht("ht", "Time difference between Reco and MC lepton", 100, 0, 100.0); // [ns]
169 TH1D h4D("h4D", "4D-distance between reco and true vertex", 2000, 0.0, 100.0); //[m]
170
171 TH1D ha("ha", "Angle between reco direction and true direction", 1000, 0.0, 180.0); // [ns]
172
173 TH1D e0("e0", "True lepton energy", 100, volume.getXmin(), volume.getXmax()); // [log(E)]
174 TH1D e2("e2", "Reconstructed energy", 100, volume.getXmin(), volume.getXmax()); // [log(E)]
175 TH1D er("er", "Ratio of reconstructed energy and true energy", 100, -5.0, +5.0); // [log(E/E)]
176 TH1D ea("ea", "Distribution of Energy error for all the events; E_{reco}-E_{true}", 100, -30, +30);
177 TH1D ed3_5GeV("ed3_5GeV", "Distribution of Energy error for events with MC energy #in [3,5] GeV; E_{reco}-E_{true}", 100, -30, +30);
178 TH1D ed8_11GeV("ed8_11GeV", "Distribution of Energy error for events with MC energy #in [8,11] GeV; E_{reco}-E_{true}", 100, -30, +30);
179 TH1D ed15_21GeV("ed15_21GeV", "Distribution of Energy error for events with MC energy #in [15,21] GeV; E_{reco}-E_{true}", 100, -30, +30);
180 TH2D ee("ee", "; E_{true} [GeV]; E_{reco} [GeV]",
181 100, volume.getXmin(), volume.getXmax(),
182 100, volume.getXmin(), volume.getXmax());
183 const Int_t ny = 28800;
184 const Double_t ymin = 0.0; // [deg]
185 const Double_t ymax = 180.0; // [deg]
186
187 vector<double> X;
188
189 if (option.find('E') != string::npos) {
190
191 for (double x = volume.getXmin(); x <= volume.getXmax(); x += (volume.getXmax() - volume.getXmin()) / 20) {
192 X.push_back(x);
193 }
194
195 } else {
196
197 double x = -0.5;
198
199 for ( ; x <= 15.5; x += 1.0) { X.push_back(x); }
200 for ( ; x <= 25.5; x += 2.0) { X.push_back(x); }
201 for ( ; x <= 50.5; x += 5.0) { X.push_back(x); }
202 for ( ; x <= 100.5; x += 10.0) { X.push_back(x); }
203 for ( ; x <= 250.5; x += 20.0) { X.push_back(x); }
204 }
205
206 TH2D h2("h2", NULL, X.size() - 1, X.data(), ny, ymin, ymax);
207 TH2D h3("h3", NULL, X.size() - 1, X.data(), 2000, 0.0, 100.0);
208 TProfile herrorE("herrorE", "Energy Error", X.size() - 1, X.data());
209 TProfile hfracE( "hfracE", "Fractional Energy Error", X.size() - 1, X.data());
210 TProfile he("he","Reconstruction Efficiency", X.size() - 1, X.data());
211 TProfile htheta_nu_lep("htheta_nu_lep", "Angle between neutrino and primary lepton", X.size() - 1, X.data());
212 TH1D hln1d("hln1d","Angle between neutrino and lepton",40,0,4);
213 TH2D hb("hb", NULL, 100, 0.0, 0.5e6, 100, -100.0, +900.0);
214 TH2S hmca("hmca", NULL, X.size() - 1, X.data(), 1000, 0, 180);
215 TH2D hzenith("hzenith", "Reco Zenith vs MC Energy", 100, 0, 100, ny, ymin, ymax);
216 TH2D hY("hY", "Reco Bjorken Y vs MC Bjorken Y", 40, 0, 1, 40, 0, 1);
217 TH2D hby3_5GeV("hby3_5GeV", "Reco Bjorken Y vs MC Bjorken Y for events with Reco E #in [3, 5] GeV", 40, 0, 1, 40, 0, 1);
218 TH2D hby8_10GeV("hby8_10GeV", "Reco Bjorken Y vs MC Bjorken Y for events with Reco E #in [8, 10] GeV", 40, 0, 1, 40, 0, 1);
219
220 JQuantile Q("Angle");
221 JQuantile O("Omega");
222 JQuantile QE("Energy");
223 JQuantile Qp("Pos");
224 JQuantile Qt("Time");
225 JQuantile Q4d("4D");
226 while (inputFile.hasNext()) {
227
228 STATUS("event: " << setw(10) << inputFile.getCounter() << '\r'); DEBUG(endl);
229
230 multi_pointer_type ps = inputFile.next();
231
232 JDAQEvent* tev = ps;
233 JEvt* evt = ps; // Reco event
234 Evt* event = ps; // MC event
235
236 const time_converter converter(*event, *tev);
237
238 job.Fill(1.0);
239
240 double Enu = 0.0;
241 double Elep = 0.0;
242 double Emax = 0.0;
243
244 Trk neutrino;
245
246 if(has_neutrino(*event)){
247
248 neutrino = get_neutrino(*event);
249 Enu = neutrino.E;
250
251 }
252
253 vector<Trk>::const_iterator lepton = event->mc_trks.end(); // can be electron or muon
254
255 for (vector<Trk>::const_iterator mc_evt = event->mc_trks.begin(); mc_evt != event->mc_trks.end(); ++mc_evt) {
256
257 if (!isMuon && is_electron(*mc_evt)) {
258
259 Elep += mc_evt->E;
260
261 if (mc_evt->E > Emax) {
262 lepton = mc_evt;
263 Emax = mc_evt->E;
264 }
265
266
267 } else if(isMuon && is_muon(*mc_evt)){
268
269 Elep += mc_evt->E;
270 if (mc_evt->E > Emax) {
271 lepton = mc_evt;
272 Emax = mc_evt->E;
273 }
274 }
275 }
276
277 if (lepton == event->mc_trks.end()) {
278 continue;
279 }
280
281 job.Fill(3.0);
282
283 double true_BjY = (Enu - Elep) / Enu;
284
285 // abscissa
286
287 Double_t x = 0.0;
288
289 if (option.find('E') != string::npos){
290
291 if(wrtNeutrino == true && !isMuon) x = volume.getX(neutrino.E);
292 else if(!wrtNeutrino && !isMuon) x = volume.getX(lepton->E);
293
294 } else{
295 x = getCount(tev->begin<JDAQTriggeredHit>(), tev->end<JDAQTriggeredHit>());
296 }
297
298 // weight for efficiency determination
299 Double_t W = 0.0;
300
301 if (!evt->empty()) {
302
303 JEvt::iterator __end = partition(evt->begin(), evt->end(), JHistory::is_application(application));
304
305 if (evt->begin() == __end) {
306 continue;
307 }
308
309 job.Fill(4.0);
310
311 //if (numberOfPrefits > 0 && numberOfPrefits < (size_t) distance(evt->begin(), evt->end())) {
312 if (numberOfPrefits > 0 ) {
313
314 JEvt::iterator __q = __end;
315
316 advance(__end = evt->begin(), min(numberOfPrefits, (size_t) distance(evt->begin(), __q)));
317
318 partial_sort(evt->begin(), __end, __q, quality_sorter);
319
320 } else {
321
322 sort(evt->begin(), __end, quality_sorter);
323 }
324
325 JEvt::iterator best = evt->begin(); // the best shower is the one with the best quality
326
327 JPosition position(getPosition(lepton->pos)); // by default the lepton pos is the interaction vertex
328 JPointing pointing(getDirection(*lepton));
329 JShowerEnergy energy(lepton->E);
330
331 JVector3D showerBrightPoint(getPosition(lepton->pos) + offset + getPosition(lepton->dir) * geanz.getMaximum(lepton->E));
332
333 if(!wrtNeutrino && !isMuon){
334 position = JPosition(showerBrightPoint); // wrt the em shower brightest point
335 } else if(wrtNeutrino == true && !isMuon){
336 position = JPosition(getPosition(neutrino));
337 pointing = JPointing(getDirection(neutrino));
338 energy = JShowerEnergy(Enu);
339 }
340
341 JEvt::iterator fit_with_smallest_error = best;
342
343 if(application == JSHOWERPREFIT || application == JSHOWERPOINTSIMPLEX || application == JSHOWERPOSITIONFIT){
344 fit_with_smallest_error = position(evt->begin(), __end);
345 } else if (application == JSHOWERENERGYPREFIT){
346 fit_with_smallest_error = energy(evt->begin(), __end);
347 } else {
348 fit_with_smallest_error = pointing(evt->begin(), __end);
349 }
350 best = fit_with_smallest_error;
351
352 const Double_t beta = pointing.getAngle(*best);
353 const double Efit = best->getE();
354
355 if (containment.is_inside(getPosition(*best))){
356
357 // selection of fit result
358 bool ok = (Efit >= Emin_GeV);
359
360 if (ok) {
361
362 W = 1.0;
363
364 job.Fill(5.0);
365
366 hn.Fill((Double_t) best->getNDF());
367 hq.Fill(best->getQ());
368 hi.Fill((Double_t) distance(evt->begin(), fit_with_smallest_error));
369 Q.put(beta);
370
371 JShower3E ta;
372
373 if(wrtNeutrino){
374 ta = getShower(neutrino);
375 } else {
376 ta = getShower(*lepton); // MC event
377 }
378
379 JShower3E tb = getShower(*best); // Reco event
380
381 ha.Fill(getAngle(ta.getDirection(), tb.getDirection()));
382
383 double zenith = tb.getDirection().getTheta() * 180 / PI;
384
385 // take into account the difefrent MC/Reco geometry and time
386 ta.add(offset);
387 tb.sub(converter.putTime());
388 double time_true = ta.getT();
389 double time_reco=tb.getT();
390 double distance_m;
391
392 if(!isMuon && !wrtNeutrino){
393 JPosition3D posDif = tb.getPosition() - JPosition3D(showerBrightPoint);
394 distance_m = posDif.getLength();
395 time_true += geanz.getMaximum(lepton->E)*getInverseSpeedOfLight();
396 hd.Fill(fabs(distance_m));
397 ht.Fill(fabs(time_reco - time_true));
398 Qp.put(fabs(distance_m));
399 Qt.put(fabs(time_reco-time_true));
400 double distance4d = sqrt(posDif.getLengthSquared() + pow(getSpeedOfLight()/getIndexOfRefraction()*(time_true-time_reco),2));
401 h4D.Fill(distance4d);
402 Q4d.put(distance4d);
403 h3.Fill(x, fabs(distance_m));
404 } else {
405 JPosition3D posDif = tb.getPosition() - ta.getPosition();
406 distance_m = posDif.getLength();
407 hd.Fill(fabs(distance_m));
408 ht.Fill(fabs(time_reco - time_true));
409 Qp.put(fabs(distance_m));
410 Qt.put(fabs(time_reco-time_true));
411 double distance4d = sqrt(posDif.getLengthSquared() + pow(getSpeedOfLight()/getIndexOfRefraction()*(time_true-time_reco),2));
412 h4D.Fill(distance4d);
413 Q4d.put(distance4d);
414 h3.Fill(x, fabs(distance_m));
415 }
416
417 if (has_neutrino(*event)) {
418
419 job.Fill(6.0);
420
421 JPosition3D mc_vx = getPosition(neutrino); // mc vertex
422
423 mc_vx.add(offset);
424
425 if (cylinder.is_inside(mc_vx)) {
426
427 job.Fill(7.0);
428
429 hz.Fill(tb.getIntersection(mc_vx));
430 }
431 }
432
433 if (best->getE() >= EMIN_GEV) {
434 hb.Fill(JVector2D(best->getX() - origin.getX(), best->getY() - origin.getY()).getLengthSquared(), best->getZ());
435 htheta_nu_lep.Fill(x, getAngle(getDirection(neutrino), getDirection(*lepton)));
436
437 hmca.Fill(x, getAngle(ta.getDirection(), tb.getDirection()));
438 }
439 if(application == JSHOWER_BJORKEN_Y) {
440
441 hY.Fill(true_BjY, best->getW(5));
442
443 if(Efit > 2.5 && Efit < 6) hby3_5GeV.Fill(true_BjY, best->getW(5));
444 else if(Efit > 7.5 && Efit < 11) hby8_10GeV.Fill(true_BjY, best->getW(5));
445
446 }
447 if(wrtNeutrino){
448
449 e0.Fill(volume.getX(Enu, true));
450 er.Fill(volume.getX(Efit) - volume.getX(Enu));
451 ee.Fill(volume.getX(Enu), volume.getX(Efit));
452 ea.Fill(Efit - Enu);
453 hzenith.Fill(Enu, zenith);
454 QE.put(log10(Efit/Enu));
455 herrorE.Fill(x, volume.getX(Efit) - volume.getX(Enu));
456 hfracE.Fill(x, fabs(volume.getX(Efit) - volume.getX(Enu))/volume.getX(Enu));
457
458 if(Enu >= 3 && Enu <= 5) ed3_5GeV.Fill(Efit - Enu);
459 else if(Enu >= 8 && Enu <= 11) ed8_11GeV.Fill(Efit - Enu);
460 else if(Enu >= 15 && Enu <= 21) ed15_21GeV.Fill(Efit - Enu);
461
462 } else {
463
464 e0.Fill(volume.getX(Elep, true));
465 er.Fill(volume.getX(Efit) - volume.getX(Elep));
466 ee.Fill(volume.getX(Elep), volume.getX(Efit));
467 ea.Fill(Efit - Elep);
468 hzenith.Fill(Elep, zenith);
469 QE.put(log10(Efit/Elep));
470 herrorE.Fill(x, volume.getX(Efit) - volume.getX(Elep));
471 hfracE.Fill(x, fabs(volume.getX(Efit) - volume.getX(Elep))/volume.getX(Elep));
472
473 if(Elep >= 3 && Elep <= 5) ed3_5GeV.Fill(Efit - Elep);
474 else if(Elep >= 8 && Elep <= 11) ed8_11GeV.Fill(Efit - Elep);
475 else if(Elep >= 15 && Elep <= 21) ed15_21GeV.Fill(Efit - Elep);
476
477 }
478 e2.Fill(volume.getX(Efit, true));
479 h2.Fill(x, beta);
480 }
481 }
482 }
483 he.Fill(x, W);}
484
485 STATUS(endl);
486
487 NOTICE("Number of events input " << setw(8) << right << job.GetBinContent(1) << endl);
488 if(!isMuon){
489 NOTICE("Number of events with electron " << setw(8) << right << job.GetBinContent(3) << endl);
490 } else{
491 NOTICE("Number of events with muon " << setw(8) << right << job.GetBinContent(3) << endl);
492 }
493 NOTICE("Number of events with fit " << setw(8) << right << job.GetBinContent(4) << endl);
494 NOTICE("Number of events selected " << setw(8) << right << job.GetBinContent(5) << endl);
495 NOTICE("Number of events with neutrino " << setw(8) << right << job.GetBinContent(6) << endl);
496 NOTICE("Number of events contained " << setw(8) << right << job.GetBinContent(7) << endl);
497
498 if (Q.getCount() != 0) {
499 NOTICE("Median, 70, 80 and 90% quantiles of space angle [deg] " << FIXED (6,3) << Q.getQuantile(0.5) << " "<< Q.getQuantile(0.7) << " "<< Q.getQuantile(0.8)<< " "<< Q.getQuantile(0.9)<< endl);
500 }
501 if (QE.getCount() != 0) {
502 NOTICE("Median, 70%, 80% and 90% quantiles of energy ratio log(Ereco/Etrue) " << FIXED (6,3) << QE.getQuantile(0.5) << " "<< QE.getQuantile(0.7) << " "<< QE.getQuantile(0.8)<< " "<< QE.getQuantile(0.9) << endl);
503 }
504 if(Qp.getCount() != 0){
505 NOTICE("Median distance to vertex: " << setw(8) << Qp.getQuantile(0.5) << " "<< Qp.getQuantile(0.7)<<" "<< Qp.getQuantile(0.8)<< " "<<Qp.getQuantile(0.9)<<endl);
506 NOTICE("Median time to vertex: " << setw(8) << Qt.getQuantile(0.5) << " "<< Qt.getQuantile(0.7)<<" "<< Qt.getQuantile(0.8)<< " "<<Qt.getQuantile(0.9)<<endl);
507 NOTICE("Median 4D-distance to vertex: " << setw(8) << Q4d.getQuantile(0.5) << " "<< Q4d.getQuantile(0.7)<<" "<< Q4d.getQuantile(0.8)<< " "<<Q4d.getQuantile(0.9)<<endl);
508 }
509 out.Write();
510 out.Close();
511}
outputFile
string outputFile
Definition JDAQTimesliceSelector.cc:37
DEBUG
#define DEBUG(A)
Message macros.
Definition JMessage.hh:62
STATUS
#define STATUS(A)
Definition JMessage.hh:63
NOTICE
#define NOTICE(A)
Definition JMessage.hh:64
FATAL
#define FATAL(A)
Definition JMessage.hh:67
debug
int debug
debug level
Definition JSirene.cc:72
make_field
#define make_field(A,...)
macro to convert parameter to JParserTemplateElement object
Definition JParser.hh:2142
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 build/antares-dataformat/PhysicsEvent.hh:434
JAANET::JHead
Monte Carlo run header.
Definition JHead.hh:1236
JGEOMETRY2D::JCircle2D
Data structure for circle in two dimensions.
Definition JCircle2D.hh:35
JGEOMETRY2D::JPosition2D
Data structure for position in two dimensions.
Definition JPosition2D.hh:33
JGEOMETRY2D::JVector2D
Data structure for vector in two dimensions.
Definition JVector2D.hh:34
JGEOMETRY2D::JVector2D::getLengthSquared
double getLengthSquared() const
Get length squared.
Definition JVector2D.hh:188
JGEOMETRY3D::JPosition3D
Data structure for position in three dimensions.
Definition JPosition3D.hh:38
JGEOMETRY3D::JShower3E
3D shower with energy.
Definition JShower3E.hh:31
JGEOMETRY3D::JVector3D
Data structure for vector in three dimensions.
Definition JVector3D.hh:36
JOSCPROB::JOscProbInterpolator
Template definition of a multi-dimensional oscillation probability interpolation table.
Definition JOscProbInterpolator.hh:71
JRECONSTRUCTION::JAtmosphericMuon
Auxiliary class to evaluate atmospheric muon hypothesis.
Definition JReconstruction/JEvtToolkit.hh:929
JRECONSTRUCTION::JPointing
Auxiliary class to compare fit results with respect to a reference direction (e.g....
Definition JReconstruction/JEvtToolkit.hh:688
JRECONSTRUCTION::JPosition
Auxiliary class to compare fit results with respect to a reference position.
Definition JReconstruction/JEvtToolkit.hh:785
JRECONSTRUCTION::JShowerEnergy
Auxiliary class to compare fit results with respect to a reference energy.
Definition JReconstruction/JEvtToolkit.hh:832
time_converter
Auxiliary class to convert DAQ hit time to/from Monte Carlo hit time.
Definition time_converter.hh:20
JAANET::getOrigin
Vec getOrigin(const JHead &header)
Get origin.
Definition JHeadToolkit.hh:325
JAANET::getDirection
JDirection3D getDirection(const Vec &dir)
Get direction.
Definition JAAnetToolkit.hh:218
JAANET::is_electron
bool is_electron(const Trk &track)
Test whether given track is a (anti-)electron.
Definition JAAnetToolkit.hh:358
JAANET::getShower
JShower3E getShower(const Trk &shower)
Get shower.
Definition JAAnetToolkit.hh:290
JAANET::getCylinder
JCylinder3D getCylinder(const JHead &header)
Get cylinder corresponding to the positions of generated tracks (i.e.
Definition JHeadToolkit.hh:347
JAANET::has_neutrino
bool has_neutrino(const Evt &evt)
Test whether given event has an incoming neutrino.
Definition JAAnetToolkit.hh:520
JAANET::getPosition
JPosition3D getPosition(const Vec &pos)
Get position.
Definition JAAnetToolkit.hh:182
JAANET::is_muon
bool is_muon(const Trk &track)
Test whether given track is a (anti-)muon.
Definition JAAnetToolkit.hh:366
JAANET::getOffset
Vec getOffset(const JHead &header)
Get offset.
Definition JHeadToolkit.hh:291
JAANET::get_neutrino
const Trk & get_neutrino(const Evt &evt)
Get incoming neutrino.
Definition JAAnetToolkit.hh:542
JGEOMETRY3D::getAngle
double getAngle(const JQuaternion3D &first, const JQuaternion3D &second)
Get space angle between quanternions.
Definition JQuaternion3D.hh:1165
JLANG::getCount
size_t getCount(const array_type< T > &buffer, const JCompare_t &compare)
Count number of unique values.
Definition JVectorize.hh:262
JMATH::pow
T pow(const T &x, const double y)
Power .
Definition JMath.hh:97
JMATH::PI
static const double PI
Mathematical constants.
Definition JMath/JConstants.hh:20
JPHYSICS::geanz
static const JGeanz geanz(1.85, 0.62, 0.54)
Function object for longitudinal EM-shower profile.
JPHYSICS::getIndexOfRefraction
double getIndexOfRefraction()
Get average index of refraction of water corresponding to group velocity.
Definition JPhysics/JConstants.hh:134
JPHYSICS::getInverseSpeedOfLight
const double getInverseSpeedOfLight()
Get inverse speed of light.
Definition JPhysics/JConstants.hh:123
JPHYSICS::getSpeedOfLight
const double getSpeedOfLight()
Get speed of light.
Definition JPhysics/JConstants.hh:112
JPP
This name space includes all other name spaces (except KM3NETDAQ, KM3NET and ANTARES).
Definition JAAnetToolkit.hh:45
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 JROOT/JCounter.hh:35
JSUPPORT::getCommonHeader
Head getCommonHeader(const JMultipleFileScanner_t &file_list)
Get common Monte Carlo header.
Definition JMonteCarloFileSupportkit.hh:559
KM3NETDAQ
KM3NeT DAQ data structures and auxiliaries.
Definition DataQueue.cc:39
create_update_issues.origin
str origin
Definition create_update_issues.py:4
Evt
The Evt class respresent a Monte Carlo (MC) event as well as an offline event.
Definition Evt.hh:21
FIXED
Auxiliary data structure for floating point format specification.
Definition JManip.hh:448
JAANET::JVolume
Auxiliary class for histogramming of effective volume.
Definition JVolume.hh:29
JACOUSTICS::JEvt
Acoustic event fit.
Definition JAcoustics/JEvt.hh:310
JFIT::JHistory::is_application
Auxiliary class to test history.
Definition JHistory.hh:188
JPARSER::initialised
Empty structure for specification of parser element that is initialised (i.e. does not require input)...
Definition JParser.hh:68
JRECONSTRUCTION::JQualitySorter
General purpose sorter of fit results.
Definition JReconstruction/JEvtToolkit.hh:426
JSUPPORT::JLimit
Auxiliary class for defining the range of iterations of objects.
Definition JLimit.hh:45
JSUPPORT::JLimit::max
static counter_type max()
Get maximum counter value.
Definition JLimit.hh:128
JTOOLS::JQuantile
Auxiliary data structure for running average, standard deviation and quantiles.
Definition JQuantile.hh:41
Trk
The Trk class represents a Monte Carlo (MC) particle as well as a reconstructed track/shower.
Definition Trk.hh:15
Trk::E
double E
Energy [GeV] (either MC truth or reconstructed)
Definition Trk.hh:20
quality_sorter
Reconstruction type dependent comparison of track quality.
Definition tools/reconstruction.hh:85
Generated by doxygen 1.10.0