Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • km3py/jppy
  • hwarnhofer/jppy_hannes
2 results
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 916 additions and 0 deletions
src/jppy/constants.cc 0 → 100644
View file @ 609aee22
#include <pybind11/pybind11.h>
#include "JPhysics/JConstants.hh"
namespace py = pybind11;
PYBIND11_MODULE(constants, m) {
m.doc() = "Jpp constants";
m.def("get_speed_of_light", &JPHYSICS::getSpeedOfLight);
m.def("get_inverse_speed_of_light", &JPHYSICS::getInverseSpeedOfLight);
m.def("get_index_of_refraction", &JPHYSICS::getIndexOfRefraction);
m.def("get_index_of_refraction_phase", &JPHYSICS::getIndexOfRefractionPhase);
m.def("get_tan_theta_c", &JPHYSICS::getTanThetaC);
m.def("get_cos_theta_c", &JPHYSICS::getCosThetaC);
m.def("get_sin_theta_c", &JPHYSICS::getSinThetaC);
m.def("get_kappa_c", &JPHYSICS::getKappaC);
}
src/jppy/geane.cc 0 → 100644
View file @ 609aee22
#include <pybind11/pybind11.h>
#include "JPhysics/JGeane.hh"
namespace py = pybind11;
PYBIND11_MODULE(geane, m) {
m.doc() = "Utilities for muon energy losses";
m.def("geanc", &JPHYSICS::geanc);
py::class_<JPHYSICS::JGeane>(m, "JGeane");
py::class_<JPHYSICS::JGeane_t, JPHYSICS::JGeane>(m, "JGeane_t")
.def(py::init<const double, const double>(),
py::arg("a"),
py::arg("b"))
.def("get_a", &JPHYSICS::JGeane_t::getA)
.def("get_b", &JPHYSICS::JGeane_t::getB)
.def("get_E", &JPHYSICS::JGeane_t::getE,
py::arg("E"),
py::arg("dx"))
.def("get_X", &JPHYSICS::JGeane_t::getX,
py::arg("E0"),
py::arg("E1")
);
py::class_<JPHYSICS::JGeaneWater, JPHYSICS::JGeane>(m, "JGeaneWater")
.def(py::init<>())
.def("get_a", &JPHYSICS::JGeaneWater::getA)
.def("get_b", &JPHYSICS::JGeaneWater::getB)
.def("get_E", &JPHYSICS::JGeaneWater::getE,
py::arg("E"),
py::arg("dx"))
.def("get_X", &JPHYSICS::JGeaneWater::getX,
py::arg("E0"),
py::arg("E1")
);
}
src/jppy/lang.cc 0 → 100644
View file @ 609aee22
#include <iostream>
#include <sstream>
#include <string>
#include <pybind11/pybind11.h>
#include "JLang/JParameter.hh"
#include "utils.hh"
namespace py = pybind11;
namespace {
template<class T>
void declare_jparameter(py::module &m, const std::string& class_name) {
using namespace JPP;
using namespace std;
py::class_<JParameter<T> >(m, class_name.c_str())
.def(py::init<>())
.def(py::init<const T&>(),
py::arg("value"))
.def("get_value", static_cast<const T& (JParameter<T>::*)() const>(&JParameter<T>::getValue))
.def("get_value", static_cast<T& (JParameter<T>::*)()>(&JParameter<T>::getValue))
.def("set_value", &JParameter<T>::setValue,
py::arg("value"),
py::pos_only())
.def("is_defined", &JParameter<T>::isDefined)
.def("less", &JParameter<T>::less,
py::arg("parameter"))
.def("__repr__", &UTILS::get_representation<JParameter<T> >);
}
}
PYBIND11_MODULE(lang, m) {
m.doc() = "Language auxiliary classes, interfaces and methods specific to Jpp";
declare_jparameter<int> (m, "JParameterI");
declare_jparameter<float> (m, "JParameterF");
declare_jparameter<double>(m, "JParameterD");
}
src/jppy/npe.cc 0 → 100644
View file @ 609aee22
#include <pybind11/pybind11.h>
#include "JPhysics/JNPE_t.hh"
namespace py = pybind11;
PYBIND11_MODULE(npe, m) {
m.doc() = "NPE utilities";
py::class_<JMuonNPE_t>(m, "JMuonNPE")
.def(py::init<const std::string &>(),
py::arg("file_descriptor"))
.def("calculate", &JMuonNPE_t::calculate,
py::arg("E"),
py::arg("R"),
py::arg("theta"),
py::arg("phi")
),
py::class_<JShowerNPE_t>(m, "JShowerNPE")
.def(py::init<const std::string &, int>(),
py::arg("file_descriptor"),
py::arg("number_of_points") = 0)
.def("calculate", &JShowerNPE_t::calculate,
py::arg("E"),
py::arg("D"),
py::arg("cd"),
py::arg("theta"),
py::arg("phi")
);
}
src/jppy/oscprob.cc 0 → 100644
View file @ 609aee22
#include <iostream>
#include <sstream>
#include <string>
#include <pybind11/pybind11.h>
#include <pybind11/operators.h>
#include <pybind11/numpy.h>
#include "JOscProb/JOscChannel.hh"
#include "JOscProb/JOscParametersInterface.hh"
#include "JOscProb/JOscParameters.hh"
#include "JOscProb/JOscProbToolkit.hh"
#include "JOscProb/JBaselineCalculator.hh"
#include "JOscProb/JOscProbInterpolator.hh"
#include "JppyOscProbInterpolator.hh"
#include "utils.hh"
namespace py = pybind11;
namespace {
template<class T>
class JppyOscParametersInterface :
public JOSCPROB::JOscParametersInterface<T>
{
using JOSCPROB::JOscParametersInterface<T>::JOscParametersInterface; // Inherit constructors
bool is_valid() const override { // Trampoline (needed for virtual functions)
PYBIND11_OVERRIDE_PURE(
bool,
JOSCPROB::JOscParametersInterface<T>,
is_valid
);
}
};
}
PYBIND11_MODULE(oscprob, m) {
m.doc() = "Oscillation probability interpolation utilities";
py::class_<JOSCPROB::JOscParametersInterface<double>, JppyOscParametersInterface<double> >(m, "JOscParametersInterfaceD")
.def(py::init<>())
.def(py::init<const double, const double, const double, const double, const double, const double>(),
py::arg("dM21sq"),
py::arg("dM31sq"),
py::arg("deltaCP"),
py::arg("sinsqTh12"),
py::arg("sinsqTh13"),
py::arg("sinsqTh23"))
.def(py::init<
const std::string&, const double&>(),
py::arg("name"),
py::arg("value"),
py::pos_only())
.def(py::init<
const std::string&, const double&,
const std::string&, const double&>(),
py::arg("name1"),
py::arg("value1"),
py::arg("name2"),
py::arg("value2"),
py::pos_only())
.def(py::init<
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&>(),
py::arg("name1"),
py::arg("value1"),
py::arg("name2"),
py::arg("value2"),
py::arg("name3"),
py::arg("value3"),
py::pos_only())
.def(py::init<
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&>(),
py::arg("name1"),
py::arg("value1"),
py::arg("name2"),
py::arg("value2"),
py::arg("name3"),
py::arg("value3"),
py::arg("name4"),
py::arg("value4"),
py::pos_only())
.def(py::init<
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&>(),
py::arg("name1"),
py::arg("value1"),
py::arg("name2"),
py::arg("value2"),
py::arg("name3"),
py::arg("value3"),
py::arg("name4"),
py::arg("value4"),
py::arg("name5"),
py::arg("value5"),
py::pos_only())
.def(py::init<
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&>(),
py::arg("name1"),
py::arg("value1"),
py::arg("name2"),
py::arg("value2"),
py::arg("name3"),
py::arg("value3"),
py::arg("name4"),
py::arg("value4"),
py::arg("name5"),
py::arg("value5"),
py::arg("name6"),
py::arg("value6"),
py::pos_only())
.def("set", static_cast<void (JOSCPROB::JOscParametersInterface<double>::*)(const std::string&, const double&)>(&JOSCPROB::JOscParametersInterface<double>::set),
py::arg("name"),
py::arg("value"),
py::pos_only())
.def("set", static_cast<void (JOSCPROB::JOscParametersInterface<double>::*)(const std::string&, const double&,
const std::string&, const double&)>(&JOSCPROB::JOscParametersInterface<double>::set),
py::arg("name1"),
py::arg("value1"),
py::arg("name2"),
py::arg("value2"),
py::pos_only())
.def("set", static_cast<void (JOSCPROB::JOscParametersInterface<double>::*)(const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&)>(&JOSCPROB::JOscParametersInterface<double>::set),
py::arg("name1"),
py::arg("value1"),
py::arg("name2"),
py::arg("value3"),
py::arg("name3"),
py::arg("value3"),
py::pos_only())
.def("set", static_cast<void (JOSCPROB::JOscParametersInterface<double>::*)(const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&)>(&JOSCPROB::JOscParametersInterface<double>::set),
py::arg("name1"),
py::arg("value1"),
py::arg("name2"),
py::arg("value3"),
py::arg("name3"),
py::arg("value3"),
py::arg("name4"),
py::arg("value4"),
py::pos_only())
.def("set", static_cast<void (JOSCPROB::JOscParametersInterface<double>::*)(const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&)>(&JOSCPROB::JOscParametersInterface<double>::set),
py::arg("name1"),
py::arg("value1"),
py::arg("name2"),
py::arg("value3"),
py::arg("name3"),
py::arg("value3"),
py::arg("name4"),
py::arg("value4"),
py::arg("name5"),
py::arg("value5"),
py::pos_only())
.def("set", static_cast<void (JOSCPROB::JOscParametersInterface<double>::*)(const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&)>(&JOSCPROB::JOscParametersInterface<double>::set),
py::arg("name1"),
py::arg("value1"),
py::arg("name2"),
py::arg("value3"),
py::arg("name3"),
py::arg("value3"),
py::arg("name4"),
py::arg("value4"),
py::arg("name5"),
py::arg("value5"),
py::arg("name6"),
py::arg("value6"),
py::pos_only())
.def("join", &JOSCPROB::JOscParametersInterface<double>::join)
.def("is_valid",&JOSCPROB::JOscParametersInterface<double>::is_valid)
.def("size", &JOSCPROB::JOscParametersInterface<double>::size)
.def("contains", &JOSCPROB::JOscParametersInterface<double>::contains,
py::arg("parameters"))
.def("equals", &JOSCPROB::JOscParametersInterface<double>::equals,
py::arg("parameters"))
.def("__eq__", [](const JOSCPROB::JOscParametersInterface<double>& first,
const JOSCPROB::JOscParametersInterface<double>& second) { return first == second; } )
.def("__ne__", [](const JOSCPROB::JOscParametersInterface<double>& first,
const JOSCPROB::JOscParametersInterface<double>& second) { return first != second; } )
.def("__repr__", &UTILS::get_representation<JOSCPROB::JOscParametersInterface<double>>)
.def_readwrite("dM21sq", &JOSCPROB::JOscParametersInterface<double>::dM21sq)
.def_readwrite("dM31sq", &JOSCPROB::JOscParametersInterface<double>::dM31sq)
.def_readwrite("deltaCP", &JOSCPROB::JOscParametersInterface<double>::deltaCP)
.def_readwrite("sinsqTh12", &JOSCPROB::JOscParametersInterface<double>::sinsqTh12)
.def_readwrite("sinsqTh13", &JOSCPROB::JOscParametersInterface<double>::sinsqTh13)
.def_readwrite("sinsqTh23", &JOSCPROB::JOscParametersInterface<double>::sinsqTh23);
py::class_<JOSCPROB::JOscParameters, JOSCPROB::JOscParametersInterface<double> >(m, "JOscParameters")
.def(py::init<const double, const double, const double, const double, const double, const double>(),
py::arg("dM21sq"),
py::arg("dM31sq"),
py::arg("deltaCP"),
py::arg("sinsqTh12"),
py::arg("sinsqTh13"),
py::arg("sinsqTh23"))
.def(py::init<const bool>(),
py::arg("useIO"))
.def(py::init<
const std::string&, const double&>(),
py::arg("name"),
py::arg("value"),
py::pos_only())
.def(py::init<
const std::string&, const double&,
const std::string&, const double&>(),
py::arg("name1"),
py::arg("value1"),
py::arg("name2"),
py::arg("value2"),
py::pos_only())
.def(py::init<
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&>(),
py::arg("name1"),
py::arg("value1"),
py::arg("name2"),
py::arg("value2"),
py::arg("name3"),
py::arg("value3"),
py::pos_only())
.def(py::init<
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&>(),
py::arg("name1"),
py::arg("value1"),
py::arg("name2"),
py::arg("value2"),
py::arg("name3"),
py::arg("value3"),
py::arg("name4"),
py::arg("value4"),
py::pos_only())
.def(py::init<
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&>(),
py::arg("name1"),
py::arg("value1"),
py::arg("name2"),
py::arg("value2"),
py::arg("name3"),
py::arg("value3"),
py::arg("name4"),
py::arg("value4"),
py::arg("name5"),
py::arg("value5"),
py::pos_only())
.def(py::init<
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&,
const std::string&, const double&>(),
py::arg("name1"),
py::arg("value1"),
py::arg("name2"),
py::arg("value2"),
py::arg("name3"),
py::arg("value3"),
py::arg("name4"),
py::arg("value4"),
py::arg("name5"),
py::arg("value5"),
py::arg("name6"),
py::arg("value6"),
py::pos_only())
.def("is_valid",&JOSCPROB::JOscParameters::is_valid);
py::enum_<JOSCPROB::JFlavour_t>(m, "JFlavour_t")
.value("ELECTRON",JOSCPROB::JFlavour_t::ELECTRON)
.value("MUON",JOSCPROB::JFlavour_t::MUON)
.value("TAU",JOSCPROB::JFlavour_t::TAU)
.value("FLAVOUR_UNDEFINED",JOSCPROB::JFlavour_t::FLAVOUR_UNDEFINED);
py::enum_<JOSCPROB::JChargeParity_t>(m, "JChargeParity_t")
.value("ANTIPARTICLE",JOSCPROB::JChargeParity_t::ANTIPARTICLE)
.value("PARTICLE",JOSCPROB::JChargeParity_t::PARTICLE)
.value("CPARITY_UNDEFINED",JOSCPROB::JChargeParity_t::CPARITY_UNDEFINED);
py::enum_<JOSCPROB::OscProbFlavour_t>(m, "OscProbFlavour_t")
.value("ELECTRON",JOSCPROB::OscProbFlavour_t::ELECTRON)
.value("MUON",JOSCPROB::OscProbFlavour_t::MUON)
.value("TAU",JOSCPROB::OscProbFlavour_t::TAU);
m.def("get_flavour", static_cast<JOSCPROB::JFlavour_t (*)(const int)>(&JOSCPROB::getFlavour));
m.def("get_charge_parity", static_cast<JOSCPROB::JChargeParity_t (*)(const int)>(&JOSCPROB::getChargeParity));
m.def("get_oscprob_flavour", static_cast<JOSCPROB::OscProbFlavour_t (*)(const int)>(&JOSCPROB::getOscProbFlavour));
py::class_<JOSCPROB::JOscChannel>(m, "JOscChannel")
.def(py::init<const JOSCPROB::JFlavour_t,
const JOSCPROB::JFlavour_t,
const JOSCPROB::JChargeParity_t>(),
py::arg("in"),
py::arg("out"),
py::arg("Cparity"))
.def(py::init<const int, const int, const int>(),
py::arg("in"),
py::arg("out"),
py::arg("Cparity"))
.def(py::self < py::self)
.def(py::self > py::self)
.def(py::self <= py::self)
.def(py::self >= py::self)
.def(py::self == py::self)
.def(py::self != py::self)
.def("__repr__", &UTILS::get_representation<JOSCPROB::JOscChannel>)
.def_readwrite("in", &JOSCPROB::JOscChannel::in)
.def_readwrite("out", &JOSCPROB::JOscChannel::out)
.def_readwrite("Cparity", &JOSCPROB::JOscChannel::Cparity);
py::class_<JOSCPROB::JBaselineCalculator>(m, "JBaselineCalculator")
.def(py::init<const double, const double>(),
py::arg("Lmin"),
py::arg("Lmax"))
.def("__call__", &JOSCPROB::JBaselineCalculator::operator(),
py::arg("costh"))
.def("__repr__", &UTILS::get_representation<JOSCPROB::JBaselineCalculator>);
py::class_<JOSCPROB::JOscProbInterpolator<>>(m, "JOscProbInterpolator")
.def(py::init<>())
.def(py::init<const char*>(),
py::arg("file_name"))
.def(py::init<const char*, const JOSCPROB::JOscParameters&>(),
py::arg("file_name"),
py::arg("parameters"))
.def("load", &JOSCPROB::JOscProbInterpolator<>::load,
py::arg("file_name"))
.def("get_table_parameters", &JOSCPROB::JOscProbInterpolator<>::getTableParameters)
.def("get_baseline_calculator", &JOSCPROB::JOscProbInterpolator<>::getBaselineCalculator)
.def("__call__", static_cast<double (JOSCPROB::JOscProbInterpolator<>::*)(const JOSCPROB::JOscChannel&,
const double,
const double) const>(&JOSCPROB::JOscProbInterpolator<>::operator()),
py::arg("channel"),
py::arg("E"),
py::arg("costh"))
.def("__call__", static_cast<double (JOSCPROB::JOscProbInterpolator<>::*)(const JOSCPROB::JOscParameters&,
const JOSCPROB::JOscChannel&,
const double,
const double)>(&JOSCPROB::JOscProbInterpolator<>::operator()),
py::arg("parameters"),
py::arg("channel"),
py::arg("E"),
py::arg("costh")
);
py::class_<JOSCPROB::JppyOscProbInterpolator<>, JOSCPROB::JOscProbInterpolator<> >(m, "JppyOscProbInterpolator")
.def(py::init<>())
.def(py::init<const char*>(),
py::arg("file_name"))
.def(py::init<const char*, const JOSCPROB::JOscParameters&>(),
py::arg("file_name"),
py::arg("parameters"))
.def("__call__", static_cast<py::array_t<double> (JOSCPROB::JppyOscProbInterpolator<>::*)(const JOSCPROB::JOscChannel&,
const py::array_t<double>&,
const py::array_t<double>&) const>(&JOSCPROB::JppyOscProbInterpolator<>::operator()),
py::arg("channel"),
py::arg("E"),
py::arg("costh"))
.def("__call__", static_cast<py::array_t<double> (JOSCPROB::JppyOscProbInterpolator<>::*)(const JOSCPROB::JOscParameters&,
const JOSCPROB::JOscChannel&,
const py::array_t<double>&,
const py::array_t<double>&)>(&JOSCPROB::JppyOscProbInterpolator<>::operator()),
py::arg("parameters"),
py::arg("channel"),
py::arg("E"),
py::arg("costh")
);
}
src/jppy/pdf.cc 0 → 100644
View file @ 609aee22
#include <pybind11/pybind11.h>
#include "JPhysics/JPDF_t.hh"
namespace py = pybind11;
PYBIND11_MODULE(pdf, m) {
m.doc() = "PDF utilities";
py::class_<JPDF>(m, "JSinglePDF")
.def(py::init<const std::string &, double, int, double>(),
py::arg("file_descriptor"),
py::arg("TTS"),
py::arg("number_of_points") = 25,
py::arg("epsilon") = 1e-10)
.def("calculate", &JPDF::calculate,
py::arg("E"),
py::arg("R"),
py::arg("theta"),
py::arg("phi"),
py::arg("t1")
),
py::class_<JMuonPDF_t>(m, "JMuonPDF")
.def(py::init<const std::string &, double, int, double>(),
py::arg("file_descriptor"),
py::arg("TTS"),
py::arg("number_of_points") = 25,
py::arg("epsilon") = 1e-10)
.def("calculate", &JMuonPDF_t::calculate,
py::arg("E"),
py::arg("R"),
py::arg("theta"),
py::arg("phi"),
py::arg("t1")
),
py::class_<JShowerPDF_t>(m, "JShowerPDF")
.def(py::init<const std::string &, double, int, double>(),
py::arg("file_descriptor"),
py::arg("TTS"),
py::arg("number_of_points") = 25,
py::arg("epsilon") = 1e-10)
.def("calculate", &JShowerPDF_t::calculate,
py::arg("E"),
py::arg("D"),
py::arg("cd"),
py::arg("theta"),
py::arg("phi"),
py::arg("t1")
),
py::class_<JTOOLS::JResultPDF<double>>(m, "JResultPDF")
.def(py::init<double, double, double, double>(),
py::arg("f"),
py::arg("fp"),
py::arg("v"),
py::arg("V"))
.def_readonly("f", &JTOOLS::JResultPDF<double>::f)
.def_readonly("fp", &JTOOLS::JResultPDF<double>::fp)
.def_readonly("v", &JTOOLS::JResultPDF<double>::v)
.def_readonly("V", &JTOOLS::JResultPDF<double>::V);
}
src/jppy/pdf_evaluator.py 0 → 100644
View file @ 609aee22
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Auxiliary python wrappers for Jpp PDFs.
The wrapper classes provide a common interface to evaluate the muon and shower PDF values\n
on an event-by-event basis.
"""
from math import sqrt
from abc import ABCMeta, abstractmethod
from jppy import constants as const
from jppy.geane import JGeaneWater as JGeaneWater
from jppy.pdf import (
JMuonPDF as JMuonPDF,
JShowerPDF as JShowerPDF,
)
class PDF(object, metaclass=ABCMeta):
"""Abstract base class for event-by-event PDF evaluation"""
def __init__(self, energy=0.0, t0=0.0):
self._energy = energy
self._t0 = t0
@classmethod
def __subclasshook__(cls, subclass):
return (hasattr(subclass, 'energy') and
callable(subclass.energy) and
hasattr(subclass, 't0') and
callable(subclass.t0) and
hasattr(subclass, 'evaluate') and
callable(subclass.evaluate))
@property
def energy(self):
return self._energy
@energy.setter
def energy(self, value):
self._energy = float(value)
@property
def t0(self):
return self._t0
@t0.setter
def t0(self, value):
self._t0 = float(value)
@abstractmethod
def evaluate(self, D, cd, theta, phi, t_obs):
raise NotImplementedError
class MuonPDF(PDF):
"""Muon PDF evaluator"""
def __init__(self, PDFS, energy=0.0, t0=0.0, TTS=0.0):
"""
Constructor.
Parameters
----------
energy : float
muon energy at the simulated vertex
(i.e. interaction vertex in the case of a neutrino interaction\n
or the vertex corresponding to the can interception for atmospheric muons)
t0 : float
time corresponding to the simulated vertex [ns]
(i.e. interaction vertex in the case of a neutrino interaction\n
or the vertex corresponding to the can interception for atmospheric muons)
TTS : float
transit time spread [ns]
"""
super().__init__(energy, t0)
self._geane = JGeaneWater()
self._pdf = JMuonPDF(PDFS, TTS=TTS)
def evaluate(self, D, cd, theta, phi, t_obs):
"""
Muon PDF evaluation method.
Parameters
----------
D : array[float], shape=(n,)
Hit distances with respect to the simulated vertex\n
(i.e. interaction vertex in the case of a neutrino interaction\n
or the vertex corresponding to the can interception for atmospheric muons)
cd : array[float], shape=(n,)
angle between muon direction and PMT position
theta : array[float], shape=(n,)
PMT longitudinal angle [deg]
phi : array[float], shape=(n,)
PMT azimuthal angle [deg]
t_obs : array[float], shape=(n,)
Observed/Simulated hit times
Returns
-------
muon pdf values : array[float], shape=(n,)
"""
dz = D * cd
R = sqrt((D + dz) * (D - dz))
E = self._geane.get_E(self.energy, dz)
t_exp = self.t0 + (dz + R * const.get_kappa_c()) * const.get_inverse_speed_of_light()
dt = t_obs - t_exp
return self._pdf.calculate(E, R, theta, phi, dt)
class ShowerPDF(PDF):
"""Shower PDF evaluator"""
def __init__(self, PDFS, energy=0.0, t0=0.0, TTS=0.0):
"""
Constructor.
Parameters
----------
energy : float
shower energy [GeV]
t0 : float
time corresponding to shower vertex [ns]
TTS : float
transit time spread [ns]
"""
super().__init__(energy, t0)
self._pdf = JShowerPDF(PDFS, TTS=TTS)
def evaluate(self, D, cd, theta, phi, t_obs):
"""
Shower PDF evaluation method.
Parameters
----------
D : array[float], shape=(n,)
Hit distances with respect to the shower vertex
cd : array[float], shape=(n,)
angle between shower direction and PMT position
theta : array[float], shape=(n,)
PMT longitudinal angle [deg]
phi : array[float], shape=(n,)
PMT azimuthal angle [deg]
t_obs : array[float], shape=(n,)
Observed/Simulated hit times
Returns
-------
shower pdf values : array[float], shape=(n,)
"""
t_exp = self.t0 + D * const.get_inverse_speed_of_light() * const.get_index_of_refraction()
dt = t_obs - t_exp
return self._pdf.calculate(self.energy, D, cd, theta, phi, dt)
src/jppy/utils.hh 0 → 100644
View file @ 609aee22
#ifndef __JPPY_UTILS__
#define __JPPY_UTILS__
#include <iostream>
#include <sstream>
#include <string>
namespace UTILS {
/**
* Auxiliary function for defining the representation of a class object.\n
* The stream output operator must be defined for the given class.
*
* \param object class object
*/
template<class T>
std::string get_representation(const T& object) {
using namespace std;
stringstream stream;
stream << object;
return stream.str();
}
}
#endif
tests/test_geane.py 0 → 100644
View file @ 609aee22
import unittest
import jppy
class TestGeaneWater(unittest.TestCase):
def test_geane(self):
gwater = jppy.geane.JGeaneWater()
density_sea_water = 1.038
assert(gwater.get_a() == 2.30e-1 * density_sea_water)
assert(gwater.get_b() == 3.40e-4 * density_sea_water)
self.assertAlmostEqual(gwater.get_E(4e4, 100), 3.857507637293732e+04)
self.assertAlmostEqual(gwater.get_X(4e4, 4e3), 6.069985857980293e+03)
tests/test_joscprob.py 0 → 100644
View file @ 609aee22
import unittest
import jppy
class TestOscParameters(unittest.TestCase):
def test_oscparameters(self):
parameters1 = jppy.oscprob.JOscParameters("sinsqTh12", 0.304,
"deltaCP", 1.544,
"dM21sq", 7.42e-5)
print("parameters1:\n", parameters1)
assert(parameters1.is_valid() and parameters1.size() == 3)
parameters1.set("sinsqTh23", -0.5)
print("parameters1.sinsqTh23 = -0.5 -> parameters1:\n", parameters1)
assert(not parameters1.is_valid() and parameters1.size() == 4)
parameters2 = jppy.oscprob.JOscParameters("dM31sq", -2.49e-3,
"sinsqTh13", 0.02241,
"sinsqTh23", 0.570)
print("parameters2:\n", parameters2)
assert(parameters2.is_valid() and parameters2.size() == 3)
assert(parameters1 != parameters2)
assert(not parameters1.contains(parameters2))
print("Joining parameters2 with parameters1")
parameters1.join(parameters2)
assert(parameters1.is_valid() and parameters1.size() == 6)
assert(parameters1.contains(parameters2))
class TestOscChannel(unittest.TestCase):
def test_oscchannel(self):
# Test comparisons
channel1 = jppy.oscprob.JOscChannel(14,16,1)
print("channel1:\n", channel1)
channel2 = jppy.oscprob.JOscChannel(jppy.oscprob.JFlavour_t.ELECTRON,
jppy.oscprob.JFlavour_t.MUON,
jppy.oscprob.JChargeParity_t.ANTIPARTICLE)
print("channel2:\n", channel2)
channel3 = jppy.oscprob.JOscChannel(jppy.oscprob.JFlavour_t.MUON,
jppy.oscprob.JFlavour_t.TAU,
jppy.oscprob.JChargeParity_t.ANTIPARTICLE)
print("channel3:\n", channel3)
assert(channel1 > channel2)
assert(channel3 > channel2)
# Test auxiliary functions
assert(jppy.oscprob.get_flavour(-12) == jppy.oscprob.JFlavour_t.ELECTRON)
assert(jppy.oscprob.get_flavour(-14) == jppy.oscprob.JFlavour_t.MUON)
assert(jppy.oscprob.get_flavour(-16) == jppy.oscprob.JFlavour_t.TAU)
assert(jppy.oscprob.get_flavour(+12) == jppy.oscprob.JFlavour_t.ELECTRON)
assert(jppy.oscprob.get_flavour(+14) == jppy.oscprob.JFlavour_t.MUON)
assert(jppy.oscprob.get_flavour(+16) == jppy.oscprob.JFlavour_t.TAU)
assert(jppy.oscprob.get_oscprob_flavour(jppy.oscprob.JFlavour_t.ELECTRON) == jppy.oscprob.OscProbFlavour_t.ELECTRON)
assert(jppy.oscprob.get_oscprob_flavour(jppy.oscprob.JFlavour_t.MUON) == jppy.oscprob.OscProbFlavour_t.MUON)
assert(jppy.oscprob.get_oscprob_flavour(jppy.oscprob.JFlavour_t.TAU) == jppy.oscprob.OscProbFlavour_t.TAU)
assert(jppy.oscprob.get_charge_parity(-12) == jppy.oscprob.JChargeParity_t.ANTIPARTICLE)
assert(jppy.oscprob.get_charge_parity(-14) == jppy.oscprob.JChargeParity_t.ANTIPARTICLE)
assert(jppy.oscprob.get_charge_parity(-16) == jppy.oscprob.JChargeParity_t.ANTIPARTICLE)
assert(jppy.oscprob.get_charge_parity(+12) == jppy.oscprob.JChargeParity_t.PARTICLE)
assert(jppy.oscprob.get_charge_parity(+14) == jppy.oscprob.JChargeParity_t.PARTICLE)
assert(jppy.oscprob.get_charge_parity(+16) == jppy.oscprob.JChargeParity_t.PARTICLE)
tests/test_pdf.py 0 → 100644
View file @ 609aee22
import unittest
import jppy
PDFS = "pdfs/J%p.dat"
class TestMuonPDF(unittest.TestCase):
def test_pdf(self):
muon_pdf = jppy.pdf.JMuonPDF(PDFS, 0)
result = muon_pdf.calculate(10, 5, 0, 0, 23)
self.assertAlmostEqual(0.00067762789, result.f)
self.assertAlmostEqual(-1.9661888268460384e-05, result.fp)
self.assertAlmostEqual(0.01374949305, result.v)
self.assertAlmostEqual(0.053314508, result.V)
class TestShowerPDF(unittest.TestCase):
def test_pdf(self):
shower_pdf = jppy.pdf.JShowerPDF(PDFS, 0)
result = shower_pdf.calculate(100, 10, 0.1, 0.2, 0.3, 6)
self.assertAlmostEqual(0.0013937540, result.f)
self.assertAlmostEqual(5.1614638414144165e-05, result.fp)
self.assertAlmostEqual(0.01054815545, result.v)
self.assertAlmostEqual(0.150554603, result.V)
tests/test_pdf_evaluator.py 0 → 100644
View file @ 609aee22
import unittest
import jppy
PDFS = "pdfs/J%p.dat"
class TestMuonPDFEvaluator(unittest.TestCase):
def test_pdf_evaluator(self):
E, t0, t_obs, D, cd, theta, phi = [1e3, 56, 292, 50, 0.7, 1.57, 3.14]
muon_pdf = jppy.pdf_evaluator.MuonPDF(PDFS, E, t0)
result = muon_pdf.evaluate(D, cd, theta, phi, t_obs)
self.assertAlmostEqual( 0.00388579021, result.f)
self.assertAlmostEqual(-0.000739757, result.fp)
self.assertAlmostEqual(0.035047945, result.v)
self.assertAlmostEqual(0.09606971431, result.V)
class TestShowerPDFEvaluator(unittest.TestCase):
def test_pdf_evaluator(self):
E, t0, t_obs, D, cd, theta, phi = [50, 198, 226, 5, 0.6, 0.5, 0.4]
shower_pdf = jppy.pdf_evaluator.ShowerPDF(PDFS, E, t0)
result = shower_pdf.evaluate(D, cd, theta, phi, t_obs)
self.assertAlmostEqual(0.006247665, result.f)
self.assertAlmostEqual(0.0006429129, result.fp)
self.assertAlmostEqual(0.01406847423, result.v)
self.assertAlmostEqual(0.297769976, result.V)