def init(self):
ns = env.ns(self.opts.name)
ns.reqparameter('BackgroundRate', central=0, sigma=0.1)
ns.reqparameter('Mu', central=1, sigma=1)
ns.reqparameter('E0', central=2, sigma=0.05)
ns.reqparameter('Width', central=0.2, sigma=0.005)
edges = np.linspace(self.opts.Emin, self.opts.Emax,
self.opts.nbins + 1)
orders = np.array([self.opts.order] * (len(edges) - 1), dtype=int)
integrator = ROOT.GaussLegendre(edges, orders, len(orders))
hist = ROOT.GaussLegendreHist(integrator)
signal = ROOT.Sum()
n = self.opts.PoissonOrder
model = {}
#ff = np.arange(1,n+1)
#ff = 1/scipy.misc.factorial(ff)*np.exp(-self.opts.PoissionMean)
#ff_points = C.Points(ff)
#print(ff, ff_points)
with ns:
for i in range(1, n + 1):
print(i, n)
model[i] = ROOT.GaussianPeakWithBackground(i)
model[i].rate.E(integrator.points.x)
# print(model[i].rate,model[i].rate.rate,ff_points[i])
prod = ROOT.Product()
prod.multiply(model[i].rate.rate)
poisson_factor = poisson.pmf(i, self.opts.PoissonMean)
poisson_factor_prod = C.Points([poisson_factor])
print(type(model[i].rate), poisson_factor, poisson_factor_prod)
prod.multiply(poisson_factor_prod)
signal.add(prod)
hist.hist.f(signal)
ns.addobservable('spectrum', hist.hist)
def test_req_group():
test_ns = env.ns("test")
covmat = np.array([[1, 0.1, 0.1], [0.1, 1, 0.1], [0.1, 0.1, 1]])
pars = test_ns.reqparameter_group(('par1', {
'central': 1.0,
'relsigma': 0.1
}), ('par2', {
'central': 2.0,
'relsigma': 0.1
}), ('par3', {
'central': 3.0,
'relsigma': 0.1
}), **{
'covmat': covmat,
})
for first, second in itertools.combinations_with_replacement(
range(len(pars)), 2):
cov_from_pars = pars[first].getCovariance(pars[second])
cov_direct = pars[first].sigma() * pars[second].sigma() * covmat[
first, second]
assert np.allclose(cov_from_pars, cov_direct), "Covs doesn't match!"
#Let's check for validity that no covariations if the parameters is already
# present
new_ns = env.ns('new')
new_ns.defparameter("test1", central=1., relsigma=0.1)
new_pars = new_ns.reqparameter_group(('test1', {
'central': 1.0,
'relsigma': 0.1
}), ('test2', {
'central': 2.0,
'relsigma': 0.1
}), ('test3', {
'central': 3.0,
'relsigma': 0.1
}), **{
'covmat': covmat,
})
for first, second in itertools.combinations_with_replacement(
range(len(new_pars)), 2):
if first != second:
assert not new_pars[first].isCorrelated(
new_pars[second]), "Covariance should not be assigned to pars!"
def covariate_ns(ns, cov_storage):
cov_ns = env.ns(ns)
pars_in_ns = [par[1] for par in cov_ns.walknames()]
if len(pars_in_ns) == 0:
raise Exception("Passed namespace {} is empty".format(ns))
pars_in_store = cov_storage.get_pars()
mutual_pars = [par for par in pars_in_store if par in pars_in_ns]
for par1, par2 in itertools.combinations_with_replacement(mutual_pars, 2):
par1.setCovariance(par2, cov_storage.get_cov(par1, par2))
def __init__(self, opts, ns=None, reactors=None, detectors=None):
"""Initialize a reactor experiment
opts -- object with parsed common arguments returned by argparse
ns -- namespace where experiment will create missing parameters, if is not provided ``opts.name`` will be used
reactors -- iterable over Reactor objects, self.makereactors() will be called if None
detectors -- iterable over Detector objects, self.makedetoctrs() will be called if None
"""
super(ReactorExperimentModel, self).__init__(None, opts)
self._oscprobs = {}
self._oscprobcls = self.oscprob_classes[self.opts.oscprob]
self._isotopes = defaultdict(list)
self._Enu_inputs = defaultdict(set)
self.oscprobs_comps = defaultdict(dict)
self._geo_isotopes = defaultdict(list)
self.ns = ns or env.ns(opts.name)
self.reqparameters(self.ns)
self.detectors = list(
detectors if detectors is not None else self.makedetectors())
for binopt in self.opts.binning:
for det in self.detectors:
if det.name == binopt[0]:
break
else:
raise Exception("can't find detector {}".format(binopt[0]))
det.edges = np.linspace(float(binopt[1]), float(binopt[2]),
int(binopt[3]))
for (detname, emin, e0, e1, ne, emax) in self.opts.binning_final:
for det in self.detectors:
if det.name == detname:
break
else:
raise Exception("can't find detector {}".format(detname))
det.edges_final = np.concatenate(
([float(emin)], np.linspace(float(e0), float(e1),
int(ne)), [float(emax)]))
for det in self.detectors:
det.assign(self.ns)
if det.orders is None:
det.orders = np.full(
len(det.edges) - 1, self.opts.integration_order, int)
self.reactors = list(
reactors if reactors is not None else self.makereactors())
for reactor in self.reactors:
reactor.assign(self.ns)
self.linkpairs(self.reactors, self.detectors)
for detector in self.detectors:
self.make_backgrounds(detector, opts.backgrounds)
self.setibd(detector, opts.ibd)
self.setupobservations(detector)
def make_anue_energy_bins(self):
bin_centers = (self.cfg.edges[1:] + self.cfg.edges[:-1])/2
edges = C.Points(bin_centers)
try:
self.ns = env.get("ibd")
except KeyError:
from gna.parameters.ibd import reqparameters
self.ns = env.ns("_offeq_ibd")
reqparameters(self.ns)
with self.ns:
self.ibd = R.IbdZeroOrder()
self.ibd.Enu.inputs(edges)
def observable(path):
#
# Future spectra location
#
try:
return env.future['spectra'][path]
except KeyError:
pass
# To be deprecated spectra location
try:
return env.ns('').getobservable(path)
except KeyError:
raise PartNotFoundError("observable", path)
def observable(path):
#
# Future spectra location
#
try:
return env.future['spectra'][path]
except KeyError:
pass
# To be deprecated spectra location
nspath, name = path.split('/')
try:
return env.ns(nspath).observables[name]
except KeyError:
raise PartNotFoundError("observable", path)
def init(self):
ns = env.ns(self.opts.name)
ns.reqparameter('BackgroundRate', central=1, sigma=0.1)
ns.reqparameter('Mu', central=0, sigma=1)
ns.reqparameter('E0', central=1, sigma=0.05)
ns.reqparameter('Width', central=0.2, sigma=0.005)
with ns:
model = ROOT.GaussianPeakWithBackground()
edges = np.linspace(self.opts.Emin, self.opts.Emax,
self.opts.nbins + 1)
orders = np.array([self.opts.order] * (len(edges) - 1), dtype=int)
integrator = ROOT.GaussLegendre(edges, orders, len(orders))
model.rate.E(integrator.points.x)
hist = ROOT.GaussLegendreHist(integrator)
hist.hist.f(model.rate.rate)
ns.addobservable('spectrum', hist.hist)
def get_parameters(params,
drop_fixed=True,
drop_free=True,
drop_constrained=False):
special_chars = list('*?[]!')
pars = []
for candidate in params:
if __is_independent(candidate):
pars.append(candidate)
continue
if any(char in candidate for char in special_chars):
import fnmatch as fn
matched_names = fn.filter((_[0] for _ in env.globalns.walknames()),
candidate)
matched_pars = list(map(env.get, matched_names))
pars.extend(matched_pars)
continue
try:
par = env.pars[candidate]
pars.append(par)
except KeyError:
par_namespace = env.ns(candidate)
if par_namespace is not env.globalns:
independent_pars = [
par for _, par in par_namespace.walknames()
if __is_independent(par)
]
else:
independent_pars = [env.globalns.get(candidate)]
pars.extend(independent_pars)
if drop_fixed:
pars = [par for par in pars if not par.isFixed()]
if drop_free:
pars = [par for par in pars if not par.isFree()]
if drop_constrained:
pars = [par for par in pars if par.isFree()]
return pars
def test_defpar_group():
test_ns = env.ns("test")
covmat = np.array([[1, 0.1, 0.1], [0.1, 1, 0.1], [0.1, 0.1, 1]])
pars = test_ns.defparameter_group(('par1', {
'central': 1.0,
'relsigma': 0.1
}), ('par2', {
'central': 2.0,
'relsigma': 0.1
}), ('par3', {
'central': 3.0,
'relsigma': 0.1
}), **{
'covmat': covmat,
})
for first, second in itertools.combinations_with_replacement(
range(len(pars)), 2):
cov_from_pars = pars[first].getCovariance(pars[second])
cov_direct = pars[first].sigma() * pars[second].sigma() * covmat[
first, second]
assert np.allclose(cov_from_pars, cov_direct), "Covs doesn't match!"
def test_parmatrix():
test_ns = env.ns("test")
p1 = test_ns.defparameter("par1", central=1.0, relsigma=0.1)
p2 = test_ns.defparameter("par2", central=2.0, relsigma=0.1)
p3 = test_ns.defparameter("par3", central=3.0, relsigma=0.1)
# Not real covariance matrix. Just to check that covariances propagates
# correctly into composite parameter covariance matrix
p1.setCovariance(p2, 0.1)
p1.setCovariance(p3, 0.2)
p2.setCovariance(p3, 0.5)
python_covmat = np.array([[(1 * 0.1)**2, 0.1,
0.2], [0.1, (2 * 0.1)**2, 0.5],
[0.2, 0.5, (3 * 0.1)**2]])
pars_covmat = ROOT.ParCovMatrix()
pars_covmat.append(p1)
pars_covmat.append(p2)
pars_covmat.append(p3)
pars_covmat.materialize()
print(pars_covmat.unc_matrix.data())
msg = "Covmatrices from python and C++ doesn't match"
assert np.allclose(python_covmat, pars_covmat.unc_matrix.data()), msg
def init(self):
if self.opts.npeaks == 1:
names = [self.opts.name]
peak_sum = None
else:
names = [self.opts.name + str(i) for i in range(self.opts.npeaks)]
peak_sum = ROOT.Sum(labels='Sum of\nsignals')
common_ns = env.ns(self.opts.name)
futurens = env.future.child(('spectra', self.opts.name))
if self.opts.with_eres:
common_ns.reqparameter("Eres_a", central=0.0, sigma=0)
common_ns.reqparameter("Eres_b", central=0.03, sigma=0)
common_ns.reqparameter("Eres_c", central=0.0, sigma=0)
edges = np.linspace(self.opts.Emin,
self.opts.Emax,
self.opts.nbins + 1,
dtype='d')
integrator = C.IntegratorGL(edges,
self.opts.order,
labels=('GL sampler', 'GL integrator'))
for i, name in enumerate(names):
locns = env.ns(name)
locns.reqparameter('BackgroundRate',
central=50,
relsigma=0.1,
label='Flat background rate %i' % i)
locns.reqparameter('Mu',
central=100,
relsigma=0.1,
label='Peak %i amplitude' % i)
locns.reqparameter('E0',
central=2,
sigma=0.05,
label='Peak %i position' % i)
locns.reqparameter('Width',
central=0.2,
sigma=0.005,
label='Peak %i width' % i)
with locns:
model = ROOT.GaussianPeakWithBackground(labels='Peak %i' % i)
model.rate.E(integrator.points.x)
if i:
integrator.add_transformation()
out = integrator.add_input(model.rate.rate)
if peak_sum:
peak_sum.add(out)
locns.addobservable('spectrum', out)
futurens[(name, 'spectrum')] = peak_sum.single()
else:
peak_sum = out
common_ns.addobservable('spectrum', peak_sum)
futurens['spectrum'] = peak_sum.single()
futurens[('fcn', 'x')] = integrator.points.x
futurens[('fcn', 'y')] = model.rate.rate
if self.opts.with_eres:
with common_ns:
eres = ROOT.EnergyResolution(True, labels='Energy\nresolution')
peak_sum.sum >> eres.matrix.Edges
peak_sum.sum >> eres.smear.Ntrue
common_ns.addobservable("spectrum_with_eres", eres.smear.Nrec)
if self.opts.print:
common_ns.printparameters(labels='True')
from gna import context, bindings
import ROOT
import time
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument( '--graph' )
parser.add_argument( '-p', '--precision', default='double', choices=['float', 'double'] )
args = parser.parse_args()
print('Precision:', args.precision)
ROOT.GNAObject
labels = [ 'comp0', 'item12', 'item13','item23' ]
weights = [ 'weight0', 'weight12', 'weight13', 'weight23' ]
ns = env.ns("")
from_nu = ROOT.Neutrino.ae()
to_nu = ROOT.Neutrino.ae()
ndata=950
modecos = False # default
clabels = [ 'P | ∆m12', 'P | ∆m13', 'P | ∆m23' ]
E_arr = N.arange(1.0, 10.0, 0.001) #array energy (МеV)
with context.set_context(manager=ndata, precision=args.precision) as manager:
ns.defparameter("L", central=52,sigma=0) #kilometre
gna.parameters.oscillation.reqparameters_reactor(ns, dm='23')
pmnsexpr = C.OscProbPMNSExpressions(from_nu, to_nu, modecos, ns=ns)
ns.materializeexpressions()
def main(opts):
global savefig
cfg = NestedDict(
bundle=dict(
name='energy_nonlinearity_birks_cherenkov',
version='v01',
nidx=[('r', 'reference', ['R1', 'R2'])],
major=[],
),
stopping_power='stoppingpower.txt',
annihilation_electrons=dict(
file='input/hgamma2e.root',
histogram='hgamma2e_1KeV',
scale=1.0 / 50000 # event simulated
),
pars=uncertaindict(
[
('birks.Kb0', (1.0, 'fixed')),
('birks.Kb1', (15.2e-3, 0.1776)),
# ('birks.Kb2', (0.0, 'fixed')),
("cherenkov.E_0", (0.165, 'fixed')),
("cherenkov.p0", (-7.26624e+00, 'fixed')),
("cherenkov.p1", (1.72463e+01, 'fixed')),
("cherenkov.p2", (-2.18044e+01, 'fixed')),
("cherenkov.p3", (1.44731e+01, 'fixed')),
("cherenkov.p4", (3.22121e-02, 'fixed')),
("Npescint", (1341.38, 0.0059)),
("kC", (0.5, 0.4737)),
("normalizationEnergy", (12.0, 'fixed'))
],
mode='relative'),
integration_order=2,
correlations_pars=['birks.Kb1', 'Npescint', 'kC'],
correlations=[1.0, 0.94, -0.97, 0.94, 1.0, -0.985, -0.97, -0.985, 1.0],
fill_matrix=True,
labels=dict(normalizationEnergy='Pessimistic'),
)
ns = env.globalns('energy')
quench = execute_bundle(cfg, namespace=ns)
ns.printparameters(labels=True)
print()
normE = ns['normalizationEnergy'].value()
#
# Input bins
#
evis_edges_full_input = N.arange(0.0, 15.0 + 1.e-6, 0.025)
evis_edges_full_hist = C.Histogram(evis_edges_full_input,
labels='Evis bin edges')
evis_edges_full_hist >> quench.context.inputs.evis_edges_hist['00']
#
# Python energy model interpolation function
#
from scipy.interpolate import interp1d
lsnl_x = quench.histoffset.histedges.points_truncated.data()
lsnl_y = quench.positron_model_relative.single().data()
lsnl_fcn = interp1d(lsnl_x, lsnl_y, kind='quadratic')
#
# Energy resolution
#
def eres_sigma_rel(edep):
return 0.03 / edep**0.5
def eres_sigma_abs(edep):
return 0.03 * edep**0.5
#
# Energy offset
#
from physlib import pc
edep_offset = pc.DeltaNP - pc.ElectronMass
#
# Oscprob
#
baselinename = 'L'
ns = env.ns("oscprob")
import gna.parameters.oscillation
gna.parameters.oscillation.reqparameters(ns)
ns.defparameter(baselinename,
central=52.0,
fixed=True,
label='Baseline, km')
#
# Define energy range
#
enu_input = N.arange(1.8, 15.0, 0.001)
edep_input = enu_input - edep_offset
edep_lsnl = edep_input * lsnl_fcn(edep_input)
# Initialize oscillation variables
enu = C.Points(enu_input, labels='Neutrino energy, MeV')
component_names = C.stdvector(['comp0', 'comp12', 'comp13', 'comp23'])
with ns:
R.OscProbPMNSExpressions(R.Neutrino.ae(),
R.Neutrino.ae(),
component_names,
ns=ns)
labels = [
'Oscillation probability|%s' % s
for s in ('component 12', 'component 13', 'component 23', 'full',
'probsum')
]
oscprob = R.OscProbPMNS(R.Neutrino.ae(),
R.Neutrino.ae(),
baselinename,
labels=labels)
enu >> oscprob.full_osc_prob.Enu
enu >> (oscprob.comp12.Enu, oscprob.comp13.Enu, oscprob.comp23.Enu)
unity = C.FillLike(1, labels='Unity')
enu >> unity.fill.inputs[0]
with ns:
op_sum = C.WeightedSum(component_names, [
unity.fill.outputs[0], oscprob.comp12.comp12,
oscprob.comp13.comp13, oscprob.comp23.comp23
],
labels='Oscillation probability sum')
psur = op_sum.single().data()
from scipy.signal import argrelmin, argrelmax
psur_minima, = argrelmin(psur)
psur_maxima, = argrelmax(psur)
def build_extrema(x):
data_min_x = (x[psur_minima][:-1] + x[psur_minima][1:]) * 0.5
data_min_y = (x[psur_minima][1:] - x[psur_minima][:-1])
data_max_x = (x[psur_maxima][:-1] + x[psur_maxima][1:]) * 0.5
data_max_y = (x[psur_maxima][1:] - x[psur_maxima][:-1])
data_ext_x = N.vstack([data_max_x, data_min_x]).T.ravel()
data_ext_y = N.vstack([data_max_y, data_min_y]).T.ravel()
return data_ext_x, data_ext_y
psur_ext_x_enu, psur_ext_y_enu = build_extrema(enu_input)
psur_ext_x_edep, psur_ext_y_edep = build_extrema(edep_input)
psur_ext_x_edep_lsnl, psur_ext_y_edep_lsnl = build_extrema(edep_lsnl)
#
# Plots and tests
#
if opts.output and opts.output.endswith('.pdf'):
pdfpages = PdfPages(opts.output)
pdfpagesfilename = opts.output
savefig_old = savefig
pdf = pdfpages.__enter__()
def savefig(*args, **kwargs):
if opts.individual and args and args[0]:
savefig_old(*args, **kwargs)
pdf.savefig()
else:
pdf = None
pdfpagesfilename = ''
pdfpages = None
fig = P.figure()
ax = P.subplot(111)
ax.minorticks_on()
ax.grid()
ax.set_xlabel('Edep, MeV')
ax.set_ylabel('Evis/Edep')
ax.set_title('Positron energy nonlineairty')
quench.positron_model_relative.single().plot_vs(
quench.histoffset.histedges.points_truncated, label='definition range')
quench.positron_model_relative_full.plot_vs(
quench.histoffset.histedges.points,
'--',
linewidth=1.,
label='full range',
zorder=0.5)
ax.vlines(normE, 0.0, 1.0, linestyle=':')
ax.legend(loc='lower right')
ax.set_ylim(0.8, 1.05)
savefig(opts.output, suffix='_total_relative')
fig = P.figure()
ax = P.subplot(111)
ax.minorticks_on()
ax.grid()
ax.set_xlabel('Edep, MeV')
ax.set_ylabel(r'$\sigma/E$')
ax.set_title('Energy resolution')
ax.plot(edep_input, eres_sigma_rel(edep_input), '-')
savefig(opts.output, suffix='_eres_rel')
fig = P.figure()
ax = P.subplot(111)
ax.minorticks_on()
ax.grid()
ax.set_xlabel('Edep, MeV')
ax.set_ylabel(r'$\sigma$')
ax.set_title('Energy resolution')
ax.plot(edep_input, eres_sigma_abs(edep_input), '-')
savefig(opts.output, suffix='_eres_abs')
fig = P.figure()
ax = P.subplot(111)
ax.minorticks_on()
ax.grid()
ax.set_xlabel('Enu, MeV')
ax.set_ylabel('Psur')
ax.set_title('Survival probability')
op_sum.single().plot_vs(enu.single(), label='full')
ax.plot(enu_input[psur_minima],
psur[psur_minima],
'o',
markerfacecolor='none',
label='minima')
ax.plot(enu_input[psur_maxima],
psur[psur_maxima],
'o',
markerfacecolor='none',
label='maxima')
savefig(opts.output, suffix='_psur_enu')
fig = P.figure()
ax = P.subplot(111)
ax.minorticks_on()
ax.grid()
ax.set_xlabel('Edep, MeV')
ax.set_ylabel('Psur')
ax.set_title('Survival probability')
op_sum.single().plot_vs(edep_input, label='true')
op_sum.single().plot_vs(edep_lsnl, label='with LSNL')
ax.legend()
savefig(opts.output, suffix='_psur_edep')
fig = P.figure()
ax = P.subplot(111)
ax.minorticks_on()
ax.grid()
ax.set_xlabel('Enu, MeV')
ax.set_ylabel('Dist, MeV')
ax.set_title('Nearest peaks distance')
ax.plot(psur_ext_x_enu, psur_ext_y_enu, 'o-', markerfacecolor='none')
savefig(opts.output, suffix='_dist_enu')
fig = P.figure()
ax = P.subplot(111)
ax.minorticks_on()
ax.grid()
ax.set_xlabel('Edep, MeV')
ax.set_ylabel('Dist, MeV')
ax.set_title('Nearest peaks distance')
ax.plot(psur_ext_x_edep,
psur_ext_y_edep,
'-',
markerfacecolor='none',
label='true')
ax.plot(psur_ext_x_edep_lsnl,
psur_ext_y_edep_lsnl,
'-',
markerfacecolor='none',
label='with LSNL')
ax.plot(edep_input,
eres_sigma_abs(edep_input),
'-',
markerfacecolor='none',
label=r'$\sigma$')
ax.legend(loc='upper left')
savefig(opts.output, suffix='_dist')
fig = P.figure()
ax = P.subplot(111)
ax.minorticks_on()
ax.grid()
ax.set_xlabel('Edep, MeV')
ax.set_ylabel(r'Dist/$\sigma$')
ax.set_title('Resolution ability')
x1, y1 = psur_ext_x_edep, psur_ext_y_edep / eres_sigma_abs(psur_ext_x_edep)
x2, y2 = psur_ext_x_edep_lsnl, psur_ext_y_edep_lsnl / eres_sigma_abs(
psur_ext_x_edep_lsnl)
ax.plot(x1, y1, '-', markerfacecolor='none', label='true')
ax.plot(x2, y2, '-', markerfacecolor='none', label='with LSNL')
ax.legend(loc='upper left')
savefig(opts.output, suffix='_ability')
ax.set_xlim(3, 4)
ax.set_ylim(5, 8)
savefig(opts.output, suffix='_ability_zoom')
fig = P.figure()
ax = P.subplot(111)
ax.minorticks_on()
ax.grid()
ax.set_xlabel('Edep, MeV')
ax.set_ylabel(r'Dist/$\sigma$')
ax.set_title('Resolution ability difference (quenching-true)')
y2fcn = interp1d(x2, y2)
y2_on_x1 = y2fcn(x1)
diff = y2_on_x1 - y1
from scipy.signal import savgol_filter
diff = savgol_filter(diff, 21, 3)
ax.plot(x1, diff)
savefig(opts.output, suffix='_ability_diff')
if pdfpages:
pdfpages.__exit__(None, None, None)
print('Write output figure to', pdfpagesfilename)
savegraph(quench.histoffset.histedges.points_truncated,
opts.graph,
namespace=ns)
if opts.show:
P.show()
def example():
parser = argparse.ArgumentParser()
parser.add_argument("-e",
"--energy",
metavar=('Start', 'Final', 'Step'),
default=[700., 2000., 10],
nargs=3,
type=float,
help='Set neutrino energy range and step in MeV')
parser.add_argument(
'-f',
'--flavors',
metavar=('Initial_flavor', 'Final_flavor'),
default=['mu', 'mu'],
nargs=2,
help='Set initital and final flavors for oscillation probability')
parser.add_argument('-r',
'--density',
default=2.75,
type=float,
help='Set density of matter in g/cm^3')
parser.add_argument('-L',
'--distance',
default=810.,
type=float,
help='Set distance of propagation in kilometers')
parser.add_argument('--mass-ordering',
default='normal',
choices=['normal', 'inverted'],
help='Set neutrino mass ordering (hierarchy)')
parser.add_argument('--print-pars',
action='store_true',
help='Print all parameters in namespace')
parser.add_argument('--savefig', help='Path to save figure')
parser.add_argument('--graph',
help='Path to save computational graph scheme')
opts = parser.parse_args()
# For fast usage printing load GNA specific modules only after argument
# parsing
import ROOT
ROOT.PyConfig.IgnoreCommandLineOptions = True #prevents ROOT from hijacking sys.argv
from gna.env import env
from gna.parameters.oscillation import reqparameters
from gna.bindings import common
import gna.constructors as C
_flavors = {
"e": ROOT.Neutrino.e(),
"mu": ROOT.Neutrino.mu(),
"tau": ROOT.Neutrino.tau(),
"ae": ROOT.Neutrino.ae(),
"amu": ROOT.Neutrino.amu(),
"atau": ROOT.Neutrino.atau()
}
# Parsed arguments are put into opts object (of type argparse.Namespace) as attributes and can be accessed with a '.'
# like in examples below.
# Note that argparse translate dashes '-' into underscores '_' for attribute names.
#initialize energy range
Enu = np.arange(opts.energy[0], opts.energy[1], step=opts.energy[2])
E_MeV = C.Points(Enu, labels='Neutrino energy')
# initialize initial and final flavors for neutrino after propagating in media
try:
initial_flavor, final_flavor = tuple(_flavors[flav]
for flav in opts.flavors)
except KeyError:
raise KeyError(
"Invalid flavor is requested: try something from e, mu, tau")
ns = env.ns("matter_osc")
reqparameters(
ns) # initialize oscillation parameters in namespace 'matter_osc'
ns['Delta'].set(0) # set CP-violating phase to zero
ns['SinSq23'].set(
0.6
) # change value of sin²θ₂₃, it will cause recomputation of PMNS matrix elements that depend of it
ns['Alpha'].set(opts.mass_ordering) # Choose mass ordering
ns.defparameter("L", central=opts.distance, fixed=True) # kilometres
ns.defparameter("rho", central=opts.density, fixed=True) # g/cm^3
# Print values of all parameters in namespace if asked
if opts.print_pars:
ns.printparameters()
#initialize neutrino oscillation probability in matter and in vacuum for comparison.
# All neccessary parameters such as values of mixing angles, mass splittings,
# propagation distance and density of matter are looked up in namespace ns
# upon creation of ROOT.OscProbMatter.
with ns:
oscprob_matter = ROOT.OscProbMatter(
initial_flavor,
final_flavor,
labels='Oscillation probability in matter')
oscprob_vacuum = ROOT.OscProbPMNS(
initial_flavor,
final_flavor,
labels='Oscillation probability in vacuum')
# Add output of plain array of energies as input "Enu" to oscillation
# probabilities. It means that oscillation probabilities would be computed
# for each energy in array and array of it would be
# provided as output
E_MeV.points >> oscprob_matter.oscprob.Enu
E_MeV.points >> oscprob_vacuum.full_osc_prob
oscprob_vacuum.full_osc_prob.setLabel(
'Oscillation probability in vacuum')
# Accessing the outputs of oscillation probability for plotting
matter = oscprob_matter.oscprob.oscprob.data()
vacuum = oscprob_vacuum.full_osc_prob.oscprob.data()
# Make a pair of plots for both probabilities and their ratio
# Plot probabilities
fig, (ax, ax_ratio) = plt.subplots(nrows=2, ncols=1, sharex=True)
ax.plot(Enu,
matter,
label='Matter, density={} gm/cm^3'.format(opts.density))
ax.plot(Enu, vacuum, label='Vacuum')
ax.set_title("Oscillation probabilities, {0} -> {1}".format(
opts.flavors[0], opts.flavors[1]),
fontsize=16)
ax.set_ylabel("Oscprob", fontsize=14)
ax.legend(loc='best')
ax.grid(alpha=0.5)
# Plot ratio
ax_ratio.plot(Enu, matter / vacuum, label='matter / vacuum')
ax_ratio.set_xlabel("Neutrino energy, MeV", fontsize=14)
ax_ratio.set_ylabel("Ratio", fontsize=14)
ax_ratio.legend(loc='best')
ax_ratio.grid(alpha=0.5)
# Convert path to absolute path and save figure or show
if opts.savefig:
plt.savefig(os.path.abspath(opts.savefig))
else:
plt.show()
# Save a plot of computational graph scheme
if opts.graph:
from gna.graphviz import savegraph
savegraph(oscprob_matter.oscprob.oscprob, opts.graph, namespace=ns)
def observable(path):
try:
return env.ns('').getobservable(path)
except KeyError:
raise PartNotFoundError("observable", path)
def test_oscprob():
baselinename = 'L'
ns = env.ns("testoscprob")
gna.parameters.oscillation.reqparameters(ns)
ns.defparameter(baselinename,
central=2.0,
fixed=True,
label='Baseline, km')
# Define energy range
enu_input = np.arange(1.0, 10.0, 0.01)
enu = C.Points(enu_input, labels='Neutrino energy, MeV')
# Initialize oscillation variables
component_names = C.stdvector(['comp0', 'comp12', 'comp13', 'comp23'])
with ns:
R.OscProbPMNSExpressions(R.Neutrino.ae(),
R.Neutrino.ae(),
component_names,
ns=ns)
# Initialize neutrino oscillations
with ns:
labels = [
'Oscillation probability|%s' % s
for s in ('component 12', 'component 13', 'component 23', 'full',
'probsum')
]
oscprob = C.OscProbPMNS(R.Neutrino.ae(),
R.Neutrino.ae(),
baselinename,
labels=labels)
enu >> oscprob.full_osc_prob.Enu
enu >> (oscprob.comp12.Enu, oscprob.comp13.Enu, oscprob.comp23.Enu)
# Oscillation probability as single transformation
op_full = oscprob.full_osc_prob.oscprob
# Oscillation probability as weighted sum
unity = C.FillLike(1, labels='Unity')
enu >> unity.fill.inputs[0]
with ns:
op_sum = C.WeightedSum(component_names, [
unity.fill.outputs[0], oscprob.comp12.comp12,
oscprob.comp13.comp13, oscprob.comp23.comp23
],
labels='Oscillation probability sum')
# Print some information
oscprob.print()
print()
ns.printparameters(labels=True)
# Print extended information
oscprob.print(data=True, slice=slice(None, 5))
assert np.allclose(op_full.data(), op_sum.data())
if "pytest" not in sys.modules:
fig = plt.figure()
ax = plt.subplot(111)
ax.minorticks_on()
ax.grid()
ax.set_xlabel('E nu, MeV')
ax.set_ylabel('P')
ax.set_title('Oscillation probability')
op_full.plot_vs(enu.single(), '-', label='full oscprob')
op_sum.plot_vs(enu.single(), '--', label='oscprob (sum)')
ax.legend(loc='lower right')
savefig('output/test_oscprob.pdf')
savegraph(enu, 'output/test_oscprob_graph.dot', namespace=ns)
savegraph(enu, 'output/test_oscprob_graph.pdf', namespace=ns)
plt.show()
def test_par_cov():
probe_1 = env.defparameter('probe1', central=0., sigma=1.)
probe_2 = env.defparameter('probe2', central=0., sigma=1.)
probe_3 = env.defparameter('probe3', central=0., sigma=1.)
test_ns = env.ns('test_ns')
test_ns.defparameter('test0', central=1., sigma=0.1)
test_ns.defparameter('test1', central=1., sigma=0.1)
test_ns.defparameter('test2', central=1., sigma=0.1)
test_ns.defparameter('test3', central=1., sigma=0.1)
extra_test_ns = env.ns('extra_test_ns')
extra1 = extra_test_ns.defparameter('extra1', central=1., sigma=0.1)
extra2 = extra_test_ns.defparameter('extra2', central=1., sigma=0.1)
extra3 = extra_test_ns.defparameter('extra3', central=1., sigma=0.1)
extra4 = extra_test_ns.defparameter('extra4', central=1., sigma=0.1)
cov1 = 0.1
print("Setting covariance of probe_1 with probe_2 to {0}".format(cov1))
probe_1.setCovariance(probe_2, cov1)
print("Check that they are mutually correlated now.")
assert probe_1.isCorrelated(probe_2) and probe_2.isCorrelated(probe_1)
print("Success")
print("Get covariance from both -- {0} and {1}\n".format(
probe_1.getCovariance(probe_2), probe_2.getCovariance(probe_1)))
print("Checks that change of one propagates to another")
cov2 = 0.2
probe_1.setCovariance(probe_2, cov2)
assert (probe_1.getCovariance(probe_2) == cov2
and probe_2.getCovariance(probe_1) == cov2)
print("Success\n")
test_pars = get_parameters(
['test_ns.test0', 'test_ns.test1', 'test_ns.test2', 'test_ns.test3'])
print("Test pars sequence is {}".format([_.name() for _ in test_pars]))
cov_matrix1 = make_fake_covmat(4)
print("Test covariance matrix is \n", cov_matrix1)
ch.covariate_pars(test_pars, cov_matrix1)
for first, second in itertools.combinations_with_replacement(
range(len(test_pars)), 2):
try:
if first != second:
assert test_pars[first].getCovariance(
test_pars[second]) == cov_matrix1[first, second]
else:
assert test_pars[first].sigma() == np.sqrt(cov_matrix1[first,
second])
except AssertionError:
print((first, second),
test_pars[first].getCovariance(test_pars[second])**2,
cov_matrix1[first, second])
raise
extra_pars = [extra1, extra2, extra3]
cov_mat_extra = make_fake_covmat(3)
cov_storage = ch.CovarianceStorage("extra_store", extra_pars,
cov_mat_extra)
ch.covariate_ns('extra_test_ns', cov_storage)
for first, second in itertools.combinations_with_replacement(
range(len(extra_pars)), 2):
try:
if first != second:
assert test_pars[first].getCovariance(
test_pars[second]) == cov_matrix1[first, second]
else:
assert test_pars[first].sigma() == np.sqrt(cov_matrix1[first,
second])
except AssertionError:
print((first, second),
test_pars[first].getCovariance(test_pars[second])**2,
cov_matrix1[first, second])
raise
def test_par_loader():
probe1 = env.defparameter('probe1', central=0., sigma=1.)
probe2 = env.defparameter('probe2', central=0., sigma=1.)
probe3 = env.defparameter('probe3', central=0., sigma=1.)
test_ns = env.ns('test_ns')
test1 = test_ns.defparameter('test1', central=1., sigma=0.1)
test2 = test_ns.defparameter('test2', central=1., sigma=0.1)
test3 = test_ns.defparameter('test3', central=1., sigma=0.1)
test4 = test_ns.defparameter('test4', central=1., sigma=0.1)
extra_test_ns = env.ns('extra_test_ns')
extra1 = extra_test_ns.defparameter('extra1', central=1., sigma=0.1)
for name, par in test_ns.walknames():
print("Par in namespace", name)
print()
print("Quering pars with get_parameters() ")
par1 = get_parameters(['probe1'])
assert (par1[0] == probe1)
print('Got global parameter {}'.format(par1[0].name()))
print()
par2 = get_parameters(['test_ns.test1'])
assert (par2[0] == test1)
print('Got parameter {0} from namespace {1}'.format(
par2[0].name(), test_ns.name))
print()
par_in_namespace = get_parameters(['test_ns'])
assert (par_in_namespace == [test1, test2, test3, test4])
print()
print('Got parameters {0} from ns {ns}'.format(
[_.name() for _ in par_in_namespace], ns=test_ns.name))
print()
par_two_namespaces = get_parameters(['test_ns', 'extra_test_ns'])
assert (par_two_namespaces == [test1, test2, test3, test4, extra1])
print()
print('Got parameters {0} from nses {ns}'.format(
[_.name() for _ in par_two_namespaces],
ns=[test_ns.name, extra_test_ns.name]))
print()
par_mixed_ns_and_global = get_parameters(['test_ns', 'probe1'])
print('Got parameters {0} from nses {ns} and global'.format(
[_.name() for _ in par_mixed_ns_and_global], ns=test_ns.name))
assert (par_mixed_ns_and_global == [test1, test2, test3, test4, probe1])
print()
wildcard = get_parameters(['test_ns*'])
assert (wildcard == [test1, test2, test3, test4])
print('Got parameters {0} from by wildcard '.format(
[_.name() for _ in wildcard]))
print()
#Asking for missing parameters, raise KeyError
try:
get_parameters(['missing'])
except KeyError:
print("KeyError for missing parameter is raised correctly")
def main(opts):
global savefig
if opts.output and opts.output.endswith('.pdf'):
pdfpages = PdfPages(opts.output)
pdfpagesfilename=opts.output
savefig_old=savefig
pdf=pdfpages.__enter__()
def savefig(*args, **kwargs):
close = kwargs.pop('close', False)
if opts.individual and args and args[0]:
savefig_old(*args, **kwargs)
pdf.savefig()
if close:
P.close()
else:
pdf = None
pdfpagesfilename = ''
pdfpages = None
cfg = NestedDict(
bundle = dict(
name='energy_nonlinearity_birks_cherenkov',
version='v01',
nidx=[ ('r', 'reference', ['R1', 'R2']) ],
major=[],
),
stopping_power='data/data_juno/energy_model/2019_birks_cherenkov_v01/stoppingpower.txt',
annihilation_electrons=dict(
file='data/data_juno/energy_model/2019_birks_cherenkov_v01/hgamma2e.root',
histogram='hgamma2e_1KeV',
scale=1.0/50000 # events simulated
),
pars = uncertaindict(
[
('birks.Kb0', (1.0, 'fixed')),
('birks.Kb1', (15.2e-3, 0.1776)),
# ('birks.Kb2', (0.0, 'fixed')),
("cherenkov.E_0", (0.165, 'fixed')),
("cherenkov.p0", ( -7.26624e+00, 'fixed')),
("cherenkov.p1", ( 1.72463e+01, 'fixed')),
("cherenkov.p2", ( -2.18044e+01, 'fixed')),
("cherenkov.p3", ( 1.44731e+01, 'fixed')),
("cherenkov.p4", ( 3.22121e-02, 'fixed')),
("Npescint", (1341.38, 0.0059)),
("kC", (0.5, 0.4737)),
("normalizationEnergy", (11.9999999, 'fixed'))
],
mode='relative'
),
integration_order = 2,
correlations_pars = [ 'birks.Kb1', 'Npescint', 'kC' ],
correlations = [ 1.0, 0.94, -0.97,
0.94, 1.0, -0.985,
-0.97, -0.985, 1.0 ],
fill_matrix=True,
labels = dict(
normalizationEnergy = 'Pessimistic'
),
)
ns = env.globalns('energy')
quench = execute_bundle(cfg, namespace=ns)
print()
normE = ns['normalizationEnergy'].value()
#
# Input bins
#
evis_edges_full_input = N.arange(0.0, 15.0+1.e-6, 0.001)
evis_edges_full_hist = C.Histogram(evis_edges_full_input, labels='Evis bin edges')
evis_edges_full_hist >> quench.context.inputs.evis_edges_hist['00']
#
# Python energy model interpolation function
#
lsnl_x = quench.histoffset.histedges.points_truncated.data()
lsnl_y = quench.positron_model_relative.single().data()
lsnl_fcn = interp1d(lsnl_x, lsnl_y, kind='quadratic', bounds_error=False, fill_value='extrapolate')
#
# Energy resolution
#
def eres_sigma_rel(edep):
return 0.03/edep**0.5
def eres_sigma_abs(edep):
return 0.03*edep**0.5
#
# Oscprob
#
baselinename='L'
ns = env.ns("oscprob")
import gna.parameters.oscillation
gna.parameters.oscillation.reqparameters(ns)
ns.defparameter(baselinename, central=52.0, fixed=True, label='Baseline, km')
#
# Define energy range
#
data = Data(N.arange(1.8, 15.0, 0.001), lsnl_fcn=lsnl_fcn, eres_fcn=eres_sigma_abs)
# Initialize oscillation variables
enu = C.Points(data.enu, labels='Neutrino energy, MeV')
component_names = C.stdvector(['comp0', 'comp12', 'comp13', 'comp23'])
with ns:
R.OscProbPMNSExpressions(R.Neutrino.ae(), R.Neutrino.ae(), component_names, ns=ns)
labels=['Oscillation probability|%s'%s for s in ('component 12', 'component 13', 'component 23', 'full', 'probsum')]
oscprob = R.OscProbPMNS(R.Neutrino.ae(), R.Neutrino.ae(), baselinename, labels=labels)
enu >> oscprob.full_osc_prob.Enu
enu >> (oscprob.comp12.Enu, oscprob.comp13.Enu, oscprob.comp23.Enu)
unity = C.FillLike(1, labels='Unity')
enu >> unity.fill.inputs[0]
with ns:
op_sum = C.WeightedSum(component_names, [unity.fill.outputs[0], oscprob.comp12.comp12, oscprob.comp13.comp13, oscprob.comp23.comp23], labels='Oscillation probability sum')
oscprob.printtransformations()
env.globalns.printparameters(labels=True)
ns = env.globalns('oscprob')
data.set_dm_par(ns['DeltaMSqEE'])
data.set_nmo_par(ns['Alpha'])
data.set_psur_fcn(op_sum.single().data)
data.build()
#
# Plotting
#
xmax = 12.0
#
# Positron non-linearity
#
fig = P.figure()
ax = P.subplot(111, xlabel='Edep, MeV', ylabel='Evis/Edep', title='Positron energy nonlineairty')
ax.minorticks_on(); ax.grid()
quench.positron_model_relative.single().plot_vs(quench.histoffset.histedges.points_truncated, label='definition range')
quench.positron_model_relative_full.plot_vs(quench.histoffset.histedges.points, '--', linewidth=1., label='full range', zorder=0.5)
ax.vlines(normE, 0.0, 1.0, linestyle=':')
ax.legend(loc='lower right')
ax.set_ylim(0.8, 1.05)
ax.set_xlim(0.0, xmax)
savefig(opts.output, suffix='_total_relative', close=not opts.show_all)
#
# Positron non-linearity derivative
#
fig = P.figure()
ax = P.subplot(111, xlabel='Edep, MeV', ylabel='dEvis/dEdep', title='Positron energy nonlineairty derivative')
ax.minorticks_on(); ax.grid()
e = quench.histoffset.histedges.points_truncated.single().data()
f = quench.positron_model_relative.single().data()*e
ec = (e[1:] + e[:-1])*0.5
df = (f[1:] - f[:-1])
dedf = (e[1:] - e[:-1])/df
ax.plot(ec, dedf)
ax.legend(loc='lower right')
ax.set_ylim(0.975, 1.01)
ax.set_xlim(0.0, xmax)
savefig(opts.output, suffix='_total_derivative', close=not opts.show_all)
#
# Positron non-linearity effect
#
fig = P.figure()
ax = P.subplot(111, xlabel='Edep, MeV', ylabel='Evis/Edep', title='Positron energy nonlineairty')
ax.minorticks_on(); ax.grid()
es = N.arange(1.0, 3.1, 0.5)
esmod = es*lsnl_fcn(es)
esmod_shifted = esmod*(es[-1]/esmod[-1])
ax.vlines(es, 0.0, 1.0, linestyle='--', linewidth=2, alpha=0.5, color='green', label='Edep')
ax.vlines(esmod, 0.0, 1.0, linestyle='-', color='red', label='Edep quenched')
ax.legend()
savefig(opts.output, suffix='_quenching_effect_0')
ax.vlines(esmod_shifted, 0.0, 1.0, linestyle=':', color='blue', label='Edep quenched, scaled')
ax.legend()
savefig(opts.output, suffix='_quenching_effect_1', close=not opts.show_all)
#
# Energy resolution
#
fig = P.figure()
ax = P.subplot(111, xlabel='Edep, MeV', ylabel=r'$\sigma/E$', title='Energy resolution')
ax.minorticks_on(); ax.grid()
ax.plot(data.edep, eres_sigma_rel(data.edep), '-')
ax.set_xlim(0.0, xmax)
savefig(opts.output, suffix='_eres_rel', close=not opts.show_all)
#
# Energy resolution
#
fig = P.figure()
ax = P.subplot(111, xlabel= 'Edep, MeV', ylabel= r'$\sigma$', title='Energy resolution')
ax.minorticks_on(); ax.grid()
ax.plot(data.edep, eres_sigma_abs(data.edep), '-')
ax.set_xlim(0.0, xmax)
savefig(opts.output, suffix='_eres_abs', close=not opts.show_all)
#
# Survival probability vs Enu
#
fig = P.figure()
ax = P.subplot(111, xlabel='Enu, MeV', ylabel='Psur', title='Survival probability')
ax.minorticks_on(); ax.grid()
ax.plot(data.enu, data.data_no.psur[data.dmmid_idx], label=r'full NO')
ax.plot(data.enu, data.data_io.psur[data.dmmid_idx], label=r'full IO')
ax.plot(data.data_no.data_enu.psur_e[data.dmmid_idx], data.data_no.data_enu.psur[data.dmmid_idx], '^', markerfacecolor='none')
ax.legend()
ax.set_xlim(0.0, xmax)
savefig(opts.output, suffix='_psur_enu')
ax.set_xlim(2.0, 4.5)
savefig(opts.output, suffix='_psur_enu_zoom', close=not opts.show_all)
#
# Survival probability vs Edep
#
fig = P.figure()
ax = P.subplot(111, xlabel='Edep, MeV', ylabel='Psur', title='Survival probability')
ax.minorticks_on(); ax.grid()
ax.plot(data.edep, data.data_no.psur[data.dmmid_idx], label=r'full NO')
ax.plot(data.edep, data.data_io.psur[data.dmmid_idx], label=r'full IO')
ax.plot(data.data_no.data_edep.psur_e[data.dmmid_idx], data.data_no.data_edep.psur[data.dmmid_idx], '^', markerfacecolor='none')
ax.legend()
ax.set_xlim(0.0, xmax)
savefig(opts.output, suffix='_psur_edep')
ax.set_xlim(1.2, 3.7)
savefig(opts.output, suffix='_psur_edep_zoom', close=not opts.show_all)
#
# Survival probability vs Edep_lsnl
#
fig = P.figure()
ax = P.subplot(111, xlabel='Edep quenched, MeV', ylabel='Psur', title='Survival probability')
ax.minorticks_on(); ax.grid()
ax.plot(data.edep_lsnl, data.data_no.psur[data.dmmid_idx], label=r'full NO')
ax.plot(data.edep_lsnl, data.data_io.psur[data.dmmid_idx], label=r'full IO')
ax.plot(data.data_no.data_edep_lsnl.psur_e[data.dmmid_idx], data.data_no.data_edep_lsnl.psur[data.dmmid_idx], '^', markerfacecolor='none')
ax.legend()
ax.set_xlim(0.0, xmax)
savefig(opts.output, suffix='_psur_edep_lsnl')
ax.set_xlim(1.2, 3.7)
savefig(opts.output, suffix='_psur_edep_lsnl_zoom', close=not opts.show_all)
#
# Distance between nearest peaks vs Enu, single
#
fig = P.figure()
ax = P.subplot(111, xlabel='Enu, MeV', ylabel='Dist, MeV', title='Nearest peaks distance')
ax.minorticks_on(); ax.grid()
ax.plot(data.data_no.data_enu.diff_x[data.dmmid_idx], data.data_no.data_enu.diff[data.dmmid_idx], label=r'NO')
ax.plot(data.data_io.data_enu.diff_x[data.dmmid_idx], data.data_io.data_enu.diff[data.dmmid_idx], label=r'IO')
ax.legend()
ax.set_xlim(0.0, xmax)
ax.set_ylim(bottom=0.0)
savefig(opts.output, suffix='_dist_enu')
ax.set_xlim(2.0, 5.0)
ax.set_ylim(top=0.5)
savefig(opts.output, suffix='_dist_enu_zoom', close=not opts.show_all)
#
# Distance between nearest peaks vs Edep, single
#
fig = P.figure()
ax = P.subplot(111, xlabel='Edep, MeV', ylabel='Dist, MeV', title='Nearest peaks distance')
ax.minorticks_on(); ax.grid()
ax.plot(data.data_no.data_edep.diff_x[data.dmmid_idx], data.data_no.data_edep.diff[data.dmmid_idx], label=r'NO')
ax.plot(data.data_io.data_edep.diff_x[data.dmmid_idx], data.data_io.data_edep.diff[data.dmmid_idx], label=r'IO')
ax.legend()
ax.set_xlim(0.0, xmax)
ax.set_ylim(bottom=0.0)
savefig(opts.output, suffix='_dist_edep')
ax.set_xlim(1.2, 4.2)
ax.set_ylim(top=0.5)
savefig(opts.output, suffix='_dist_edep_zoom', close=not opts.show_all)
#
# Distance between nearest peaks vs Edep, single
#
fig = P.figure()
ax = P.subplot(111, xlabel='Edep quenched, MeV', ylabel='Dist, MeV', title='Nearest peaks distance')
ax.minorticks_on(); ax.grid()
ax.plot(data.data_no.data_edep_lsnl.diff_x[data.dmmid_idx], data.data_no.data_edep_lsnl.diff[data.dmmid_idx], label=r'NO')
ax.plot(data.data_io.data_edep_lsnl.diff_x[data.dmmid_idx], data.data_io.data_edep_lsnl.diff[data.dmmid_idx], label=r'IO')
ax.legend()
ax.set_xlim(0.0, xmax)
ax.set_ylim(bottom=0.0)
savefig(opts.output, suffix='_dist_edep_lsnl')
ax.set_xlim(1.2, 4.2)
ax.set_ylim(top=0.5)
savefig(opts.output, suffix='_dist_edep_lsnl_zoom')
poly = N.polynomial.polynomial.Polynomial([0, 1, 0])
x = data.data_no.data_edep_lsnl.diff_x[data.dmmid_idx]
pf = poly.fit(x, data.data_no.data_edep_lsnl.diff[data.dmmid_idx], 2)
print(pf)
ax.plot(x, pf(x), label=r'NO fit')
ax.legend()
savefig(opts.output, suffix='_dist_edep_lsnl_fit', close=not opts.show_all)
#
# Distance between nearest peaks vs Edep, multiple
#
fig = P.figure()
ax = P.subplot(111, xlabel='Edep quenched, MeV', ylabel='Dist, MeV', title='Nearest peaks distance')
ax.minorticks_on(); ax.grid()
ax.plot(data.data_no.data_edep_lsnl.diff_x[data.dmmid_idx], data.data_no.data_edep_lsnl.diff[data.dmmid_idx], label=r'NO')
ax.plot(data.data_io.data_edep_lsnl.diff_x[data.dmmid_idx], data.data_io.data_edep_lsnl.diff[data.dmmid_idx], '--', label=r'IO')
for idx in (0, 5, 15, 20):
ax.plot(data.data_io.data_edep_lsnl.diff_x[idx], data.data_io.data_edep_lsnl.diff[idx], '--')
ax.legend()
ax.set_xlim(0.0, xmax)
savefig(opts.output, suffix='_dist_edep_lsnl_multi', close=not opts.show_all)
#
# Distance between nearest peaks difference
#
fig = P.figure()
ax = P.subplot(111, xlabel='Edep, MeV', ylabel='Dist(IO) - Dist(NO), MeV', title='Nearest peaks distance diff: IO-NO')
ax.minorticks_on(); ax.grid()
ax.plot(data.e, data.diffs.edep[data.dmmid_idx], '-', markerfacecolor='none', label='Edep')
ax.plot(data.e, data.diffs.edep_lsnl[data.dmmid_idx], '-', markerfacecolor='none', label='Edep quenched')
ax.plot(data.e, data.diffs.enu[data.dmmid_idx], '-', markerfacecolor='none', label='Enu')
ax.legend()
savefig(opts.output, suffix='_dist_diff')
ax.plot(data.e, data.eres, '-', markerfacecolor='none', label='Resolution $\\sigma$')
ax.legend()
savefig(opts.output, suffix='_dist_diff_1')
#
# Distance between nearest peaks difference relative to sigma
#
fig = P.figure()
ax = P.subplot(111, xlabel='Edep, MeV', ylabel='(Dist(IO) - Dist(NO))/$\\sigma$', title='Nearest peaks distance diff: IO-NO')
ax.minorticks_on(); ax.grid()
ax.plot(data.e, data.diffs_rel.edep[data.dmmid_idx], '-', markerfacecolor='none', label='Edep')
ax.plot(data.e, data.diffs_rel.edep_lsnl[data.dmmid_idx], '-', markerfacecolor='none', label='Edep quenched')
i_edep=N.argmax(data.diffs_rel.edep[data.dmmid_idx])
i_edep_lsnl=N.argmax(data.diffs_rel.edep_lsnl[data.dmmid_idx])
ediff = data.e[i_edep] - data.e[i_edep_lsnl]
ax.axvline(data.e[i_edep], linestyle='dashed', label='Max location: %.3f MeV'%(data.e[i_edep]))
ax.axvline(data.e[i_edep_lsnl], linestyle='dashed', label='Max location: %.3f MeV'%(data.e[i_edep_lsnl]))
ax.axvspan(data.e[i_edep], data.e[i_edep_lsnl], alpha=0.2, label='Max location diff: %.3f MeV'%(ediff))
ax.legend()
savefig(opts.output, suffix='_dist_diff_rel')
#
# Distance between nearest peaks difference relative to sigma
#
fig = P.figure()
ax = P.subplot(111, xlabel='Edep, MeV', ylabel='(Dist(IO) - Dist(NO))/$\\sigma$', title='Nearest peaks distance diff: IO-NO')
ax.minorticks_on(); ax.grid()
ledep = ax.plot(data.e, data.diffs_rel.edep[data.dmmid_idx], '--', markerfacecolor='none', label='Edep')[0]
lquench = ax.plot(data.e, data.diffs_rel.edep_lsnl[data.dmmid_idx], '-', color=ledep.get_color(), markerfacecolor='none', label='Edep quenched')[0]
kwargs=dict(alpha=0.8, linewidth=1.5, markerfacecolor='none')
for idx in (0, 5, 15, 20):
l = ax.plot(data.e, data.diffs_rel.edep[idx], '--', **kwargs)[0]
ax.plot(data.e, data.diffs_rel.edep_lsnl[idx], '-', color=l.get_color(), **kwargs)
ax.legend()
savefig(opts.output, suffix='_dist_diff_rel_multi', close=not opts.show_all)
#
# Distance between nearest peaks difference relative to sigma
#
fig = P.figure()
ax = P.subplot(111, ylabel=r'$\Delta m^2_\mathrm{ee}$', xlabel='Edep quenched, MeV',
title='Nearest peaks distance diff: IO-NO/$\\sigma$')
ax.minorticks_on(); ax.grid()
formatter = ax.yaxis.get_major_formatter()
formatter.set_useOffset(False)
formatter.set_powerlimits((-2,2))
formatter.useMathText=True
c = ax.pcolormesh(data.mesh_e.T, data.mesh_dm.T, data.diffs_rel.edep_lsnl.T)
from mpl_tools.helpers import add_colorbar
add_colorbar(c, rasterized=True)
c.set_rasterized(True)
savefig(opts.output, suffix='_dist_diff_rel_heatmap')
if pdfpages:
pdfpages.__exit__(None,None,None)
print('Write output figure to', pdfpagesfilename)
# savegraph(quench.histoffset.histedges.points_truncated, opts.graph, namespace=ns)
if opts.show or opts.show_all:
P.show()
parser.add_argument('-i', '--dyboscar-input', help='Path to inputs from dyboscar')
args = parser.parse_args()
input_dyboscar = None
input_dtype=[('enu', 'd'), ('xsec0', 'd'), ('xsec1', 'd'), ('xsec1_c0', 'd'), ('xsec1_c1', 'd'), ('jac_c0', 'd'), ('jac_c1', 'd')]
if args.dyboscar_input:
input_dyboscar = np.loadtxt(args.dyboscar_input, dtype=input_dtype)
dyboscar_ctheta = [0., 1.]
__enu = np.linspace(0.0, 12.0, 1201, dtype='d')
Enue = C.Points(__enu)
Enue_first = C.Points(np.stack((__enu, __enu), axis=-1))
ctheta = C.Points(np.array([0.0, 1.]))
ns = env.ns('ibd')
ns.printparameters()
from gna.parameters.ibd import reqparameters
reqparameters(ns, pdg_year='dyboscar')
with ns:
econv = R.EvisToEe()
ibd = R.IbdZeroOrder(True)
ibd_first = R.IbdFirstOrder()
Enue.points.points >> ibd.xsec.Ee
Enue.points.points >> econv.Ee.Evis
