Getting started¶

[1]:

%load_ext autoreload
%autoreload 2
%matplotlib notebook

[2]:

import matplotlib.pyplot as plt
import numpy as np
import ompy as om
import logging

[3]:

om.__full_version__

[3]:

'0.8.0.dev0+97cd212'

[4]:

# For reproducability we seed the random generator.
# Note that by default several other classes in ompy, such as all
# classes with multinest calculations have a default seed, too
np.random.seed(1382398)

[5]:

# get smaller files for the online version
plt.rcParams["figure.dpi"] = 70

Loading and example raw spectra¶

The \(^{164}\mathrm{Dy}\) data used below has been gathered from following experiment: Nyhus, H. T. et al. (2010). DOI: 10.1103/physrevc.81.024325 and is reanalyzed in Renstrøm, T. et al. (2018). DOI: 10.1103/physrevc.98.054310

[6]:

# Import raw matrix into instance of om.Matrix() and plot it
raw = om.example_raw('Dy164')
# To use you own data, uncomment/adapt the line below instead
# raw = om.Matrix(path="/path/to/matrix.ending")

# Plot the entire matrix
raw_org = raw.copy() # workaround due to execution order in jupyter notebook
                     # (calculations are performed before plotting, but we make a cut to raw further down)
raw_org.plot();


# Note: We use the semi-colon `;` at the end of the line to silence the output
# in jupyter notebook. This is not necessary, but otherwise you get something like
# this below printed every time:
#(<matplotlib.collections.QuadMesh at 0x7fafbc422eb8>,
# <matplotlib.axes._subplots.AxesSubplot at 0x7fafc0944a20>,
# <Figure size 640x480 with 2 Axes>)

Matrix manipulation¶

The core of the Oslo method involves working with two dimensional spectra. Starting with a raw matrix of \(E_x\)-\(E_\gamma\) coincidences, you typically want to unfold the counts along the gamma-energy axis and then apply the first-generation method to obtain the matrix of first-generation, or primary, gamma rays from the decaying nucleus.

The two most important utility classes in the package are Matrix() and Vector(). They are used to store matrices (2D) or vectors (1D) of numbers, typically spectra of counts, along with energy calibration information.

As these underpin the entire package, they contain many useful functions to make life easier. Loading and saving to several formats, plotting, projections, rebinning and cutting, to mention a few. See the documentation for an exhaustive list.

Their basic structure is:

[7]:

# mat = ompy.Matrix()
mat = raw
mat.values  # A 2D numpy array
mat.Ex      # Array of mid-bin energy values for axis 0 (i.e. the row axis, or y axis)
mat.Eg      # Array of mid-bin energy values for axis 1 (i.e. the column axis, or x axis)

print("The first gamma-ray energies:\n", mat.Eg[0:10])

The first gamma-ray energies:
 [  0.     19.364  38.728  58.092  77.456  96.82  116.184 135.548 154.912
 174.276]

[8]:

# We can also create a vector, which is useful to store the NLD and gSF.
values = np.arange(11)
E = np.linspace(0, 10, num=11)

fig, ax = plt.subplots(figsize=(2,2), constrained_layout=True)
vec = om.Vector(values=values, E=E)
vec.values  # A 1D numpy array
vec.E       # Array of lower-bin-edge energy values for the single axis
vec.plot(ax=ax);

[9]:

# Cut away counts above the diagonal
# Remember: Think about what you do here. If you cut them away, they will not
# be used in unfolding etc. This may or may not be what you want.
# Note that the raw matrix we read in above has been cut already, so the difference here is not so large.
raw.cut_diagonal(E1=(800, 0), E2=(7500, 7300))
raw.cut('Ex', 0, 8400)
raw.plot();

Note that Matrix, Vector and several other classes contain mutable objects. If you work on them, you might want to create a deepcopy. For Matrix, Vector this can be archived by the convince method X.copy, otherwise use copy.deepcopy.

[10]:

# The "right" way if you don't want to change the original matrix
raw_big_cut = raw.copy()
raw_big_cut.cut('Ex', 0, 4000)
print(raw.Ex.max(), raw_big_cut.Ex.max())

8300.0 3980.0

[11]:

# The "wrong" way if you don't want to change the original matrix
raw_big_cut2 = raw_big_cut
raw_big_cut2.cut('Ex', 0, 2000)
print(raw_big_cut.Ex.max(), raw_big_cut2.Ex.max())
# oups!: suddenly also `raw_big_cut` was cut, not only raw_big_cut2

1940.0 1940.0

[12]:

# Plot projections
raw.plot_projection('Ex', Emin=1800, Emax=2600, kind="step");

Note that you can IPython’s has tools to quickly access information on a function, namely the ? character to explore documentation, the ?? characters to explore source code, and the Tab key (or double-tab) for auto-completion. Try it out uncommenting the function below.

[13]:

## Uncomment these lines to query a function
# ?raw.plot_projection

Unfolding¶

Get a response matrix¶

[14]:

logger = om.introspection.get_logger('response', 'INFO')
# Then do the same using OMpy functionality:
# You may need to adpot this to whereever you response matrixes are stored
folderpath = "../OCL_response_functions/oscar2017_scale1.15"

# Energy calibration of resulting response matrix:
Eg = raw.Eg

# Experimental relative FWHM at 1.33 MeV of resulting array
fwhm_abs = 30 # (30/1330 = 2.25% )

# Magne recommends 1/10 of the actual resolution for unfolding purposes
response = om.Response(folderpath)
R_ompy_view, R_tab_view = response.interpolate(Eg, fwhm_abs=fwhm_abs, return_table=True)
R_ompy_unf, R_tab_unf = response.interpolate(Eg, fwhm_abs=fwhm_abs/10, return_table=True)
R_ompy_view.plot(title="Response matrix", vmin=5e-5, vmax=5e-1,
                 scale="log");

2020-01-16 19:35:48,459 - ompy.response - INFO - Note: Spectra outside of 200.0 and 20000.0 are extrapolation only.
2020-01-16 19:35:52,808 - ompy.response - INFO - Note: Spectra outside of 200.0 and 20000.0 are extrapolation only.

[15]:

### Perform the unfolding

[16]:

# You can decide to log information and set the logging level (info/debug)
logger = om.introspection.get_logger('unfolder', 'INFO')

# We need to remove negative counts (unphysical) in the raw matrix before unfolding:
raw_positive = raw.copy()
raw_positive.fill_and_remove_negative(window_size=2)

# With compton subtraction and all tweaks
unfolder= om.Unfolder(response=R_ompy_unf)
unfolder.use_compton_subtraction = True # default
unfolder.response_tab = R_tab_unf
# Magne suggests some "tweaks" for a better unfolding performance. Default is 1 for all.
unfolder.FWHM_tweak_multiplier = {"fe": 1., "se": 1.1,
                                     "de": 1.3, "511": 0.9}
unfolded = unfolder(raw_positive)
unfolded.plot();

[17]:

### Generate the first generation matrix

[18]:

firstgen = om.FirstGeneration()
primary = firstgen(unfolded)
primary.plot();

Propagating statistical uncertainties¶

In order to propagate the statistical uncertainties from the raw matrix, we use an ensemble based method. We start of my generating en enseble of raw-like matrixes. The raw counts are poisson distributed. If we had counted one another time, we would get slightly different results.

More precisely, the counts of the matrix containing prompt+bg events and the background events bg are each poisson distributed, where we have raw = (prompt+bg) - bg_ratio * bg. The ratio bg_ratio is determined by the ratio of the time gate lengths taken to obtain the prompt+bg and bg spectra. If a bg spectrum is provided to the Ensemble class, it will calculate the raw spectrum according to the equaltion above. Otherwise, the provided raw spectrum itself is assumed to be poisson distributed.

We take the number of counts \(k_i\) in bin \(i\) of the raw matrix \(R\) as an estimate for the Poisson parameter (“the mean”) \(λ_i\) . Note that it is an unbiased estimator for \(λ_i\), since \(E(k) = λ\). To generate a member matrix \(R_l\) of the MC ensemble, we replace the counts in each bin \(i\) by a random draw from the distribution \(\operatorname{Poisson}(k_i)\).

The class Ensemble() provides this feature. Its basic usage is:

[19]:

logger = om.introspection.get_logger('ensemble', 'INFO')

# Tell the `Ensemble` class which raw spectrum, what kind of undolfer and first
# generations method to use.
# Note: This will have the same setting as above. We could for example have
# set the first generations method to use a different "valley_collection", or a
# differnt type of "multiplicity_estimation"
ensemble = om.Ensemble(raw=raw_positive)
ensemble.unfolder = unfolder
ensemble.first_generation_method = firstgen
# Generates N perturbated members; here just 10 to speed it up
# the `regernerate` flag ensures, that we don't load from disk; which might result in expected results
# if we have changed something in the input `raw` matrix.
ensemble.generate(10, regenerate=True)

2020-01-16 19:35:59,183 - ompy.ensemble - INFO - Start normalization with 3 cpus
2020-01-16 19:35:59,277 - ompy.ensemble - INFO - Generating 0

2020-01-16 19:35:59,343 - ompy.ensemble - INFO - Generating 1
2020-01-16 19:35:59,379 - ompy.ensemble - INFO - Generating 2
2020-01-16 19:36:01,739 - ompy.ensemble - INFO - Generating 3
2020-01-16 19:36:01,965 - ompy.ensemble - INFO - Generating 4
2020-01-16 19:36:02,085 - ompy.ensemble - INFO - Generating 5
2020-01-16 19:36:04,192 - ompy.ensemble - INFO - Generating 6
2020-01-16 19:36:04,553 - ompy.ensemble - INFO - Generating 7
2020-01-16 19:36:04,655 - ompy.ensemble - INFO - Generating 8
2020-01-16 19:36:06,858 - ompy.ensemble - INFO - Generating 9

The generated members are saved to disk and can be retrieved. Unfolded members can be retrieved as ensemble.get_unfolded(i), for example. Their standard deviation is ensemble.std_unfolded for the unfolded matrixes, etc.

We can now plot the standard deviation of all ensemble members for the raw, unfolded and first generation spectrum

[20]:

i_unfolded = 9
matrix = ensemble.get_unfolded(i_unfolded)
matrix.plot(title=f"Unfolded matrix #{i_unfolded}")

# Following commands plots all std. deviations
ensemble.plot();

Extract Nuclear level density and gamma strength function¶

After matrix has been cut, unfolded and firstgen’d, perhaps ensembled, its nuclear level density (nld) and gamma strength function (\(\gamma\)SF) can be extracted using the Extractor() class.

The method relies on the relation

\begin{align} P(E_x, E_\gamma) \propto NLD(E_x - E_\gamma) \mathcal{T}(E_\gamma),\label{eq:Oslo_method_eq} \end{align}

where \(P(E_x, E_\gamma)\) is the first-generation spectrum normalized to unity for each \(E_x\) bin. Furthermore, if we assume that the \(\gamma\) decay at high \(E_x\) is dominated by dipole radiation the transmission coefficient \(\mathcal{T}\) is related to the dipole \(\gamma\)-ray strength function \(f(E_\gamma)\) by the relation

\begin{align} \mathcal{T}(E_\gamma) = 2\pi E_\gamma^3 f(E_\gamma).\label{eq:gammaSF} \end{align}

If you have reasons to assume a different multipose decomposition, you may of course calculate the transmission coefficient \(\mathcal{T}\) from the \(\gamma\)-ray strength function produced here and apply the decomposition you prefer.

For a single matrix, its usage is:

(well, think about what you want to set in as the std. deviation)

[21]:

# cutout = primary.trapezoid(Ex_min=4000, Ex_max=8000, Eg_min=1000, inplace=False)
# cutout_std = ensemble.std_firstgen.trapezoid(Ex_min=4000, Ex_max=8000, Eg_min=1000, inplace=False)
# extractor = om.Extractor()
# nld, gsf = extractor.decompose(cutout, std=cutout_std)

When extracting NLD and GSF from an ensemble, a trapezoidal cutout must be performed on each ensemble member. This is achieved by Action() which allows for delayed function calls on matrices and vectors. This way we don’t cut the raw matrix at Ex_min, but this will only happen before the extraction.

[22]:

trapezoid_cut = om.Action('matrix')
trapezoid_cut.trapezoid(Ex_min=4000, Ex_max=7000, Eg_min=1000, inplace=True)
extractor = om.Extractor()
extractor.trapezoid = trapezoid_cut
# Running the lines below directy, would most probably
# result in a error like
# The AssertionError: Ex and Eg must have the same step size
#
# Why? The extraction assumes that Ex and Eg have the same binning. Thus we
# need to rebin the ensemble. This works will work inplace.
# Note: As always, be careful will mid-bin vs lower bin calibration.
# E_rebinned = ensemble.get_firstgen(0).Ex
#
E_rebinned = np.arange(100., 8500, 200)
ensemble.rebin(E_rebinned, member="firstgen")
ensemble.plot();

Now we can extract the NLD and \(\gamma SF\) for \(N\) of the samples of the ensemble.

Note: The old software extended the decomposition beyond the Ex=Eg line by a resolution dE. This is now optional and we changed the default to not do this any longer, but rather assume that the rebinning above has been performed with a binsize of approx. the FWHM of the bin with the worst resolution (usually (Ex_max, Eg_max)).

[23]:

extractor.extract_from(ensemble, regenerate=True)

The resulting nld and gsf are saved to disk and exposed as extractor.nld and extractor.gsf

[24]:

mat = ensemble.get_firstgen(0).copy()
std = ensemble.std_firstgen.copy()
trapezoid_cut.act_on(mat)
trapezoid_cut.act_on(std)
_, _, product = extractor.decompose(mat, std, product=True)
fig, ax = plt.subplots(2,1)
om.normalize_rows(mat.values)
mat.plot(ax=ax[0], scale="log", vmin=1e-3, vmax=1e-1)
product.plot(ax=ax[1], scale="log", vmin=1e-3, vmax=1e-1)

[24]:

(<matplotlib.collections.QuadMesh at 0x7f6c946104e0>,
 <matplotlib.axes._subplots.AxesSubplot at 0x7f6c94a30828>,
 <Figure size 448x336 with 4 Axes>)

Plotting the results before normalization¶

[25]:

extractor.plot(plot_mean=False)

[25]:

(<Figure size 448x336 with 2 Axes>,
 array([<matplotlib.axes._subplots.AxesSubplot object at 0x7f6c9449ca20>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x7f6c9462d710>],
       dtype=object))

Or maybe you are more used to displaying the results with std. deviations?

Note: This may be erroneous, as the nld and gsf are not normalized yet!
Thus, in principal, we might evaluate std. devs. of the same solution with different
transformations. Before we normalize, we don’t know. And they have the same \(\chi^2\).
That was the reason for the trouble with normalization.

[26]:

extractor.plot(plot_mean=True)

[26]:

(<Figure size 448x336 with 2 Axes>,
 array([<matplotlib.axes._subplots.AxesSubplot object at 0x7f6c943fb940>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x7f6c94d5e7f0>],
       dtype=object))

[27]:

# let's remove the nan-valued elements (unconstrained elements) for the further analysis
for nld in extractor.nld:
    nld.cut_nan()

for gsf in extractor.gsf:
    gsf.cut_nan()

# the "mean" nld at this stage; we'll use it later, but it's not a good estimate at this
# stage (see article)
nld_mean = extractor.ensemble_nld()

Normalization¶

Does it still look strange? probably because you are only used to see the normalized results.

1) Manual normalization¶

[28]:

from ipywidgets import interact, interactive, fixed, interact_manual
import ipywidgets as widgets

def plot_transformed(alpha, A=1, B=1):
    fig, ax = plt.subplots(1, 2, constrained_layout=True)
    for nld, gsf in zip(extractor.nld, extractor.gsf):
        nld.transform(const=A, alpha=alpha, inplace=False).plot(ax=ax[0], scale="log", color='k', alpha=1/10)
        gsf.transform(const=B, alpha=alpha, inplace=False).plot(ax=ax[1], scale="log", color='k', alpha=1/10)
    ax[0].set_title("Level density")
    ax[1].set_title("γSF")

plot_transformed(alpha=0.0015)

2) Normalization through external data for one (nld, gsf) set¶

The normalization ensures that we find the physical solution, so we remove the degeneracy that is in principal inherent to decomposition of NLD and \(\gamma\)SF:

\begin{align} NLD' = NLD(E_x) * A exp(\alpha E_x) \\ \gamma SF' = \gamma SF(E_\gamma) * B exp(\alpha E_\gamma) \end{align}

Note: This is the transformation eq (3), Schiller2000.

As external data for the normalization we commonly use: 1. the discrete leves, binned with the resolution of our data (and potentially also smoothed) 2. The NLD at Sn, derived from D0 and a spin distribution 3. The average total radiative width \(\Gamma_\gamma\).

1. Sequentially:¶

Traditionally we have choosen a sequential normalization, where the NLD is normalized first to receive a set \(\alpha\). Then we obtain the scaling parameter \(B\) of the \(\gamma\)SF from a normalization to the experimental \(\Gamma_\gamma\).

nld normalization¶

Let’s first normalize the mean nld from the extractor.

The normalization will take some time (≲ 30 seconds). The essential output of multinest is saved to disk, and some output is redirected to disk.

[29]:

normlog = om.introspection.get_logger('normalizer_nld', 'INFO')
nldnorm = om.NormalizerNLD(nld=nld_mean, discrete='../example_data/discrete_levels_Dy164.txt')

[30]:

norm_pars = om.NormalizationParameters(name="164Dy")
norm_pars.D0 = [6.8, 0.6]  # eV
norm_pars.Sn = [7.658, 0.001] # MeV
norm_pars.spincutModel = 'Disc_and_EB05'  # see eg. Guttormsen et al., 2017, PRC 96, 024313
norm_pars.spincutPars = {"mass":164, "NLDa":18.12, "Eshift":0.31,
                         "Sn": norm_pars.Sn[0], "sigma2_disc":[1.5,3.6]}
norm_pars.Jtarget = 0 # A-1 nucleus

nldnorm.normalize(limit_low=[0, 1.5], limit_high=[3, 5.5], norm_pars=norm_pars)

2020-01-16 19:36:13,431 - ompy.normalizer_nld - INFO -

---------
Normalizing nld #0
2020-01-16 19:36:14,086 - ompy.normalizer_nld - INFO - DE results:
┌───────────────────┬────────────────────┬────────────────────┬─────────────────────┐
│ A                 │ α [MeV⁻¹]          │ T [MeV]            │ Eshift [MeV]        │
╞═══════════════════╪════════════════════╪════════════════════╪═════════════════════╡
│ 5.310336107841815 │ 1.5908471110306468 │ 0.6128836080973475 │ -0.6436785028696971 │
└───────────────────┴────────────────────┴────────────────────┴─────────────────────┘
2020-01-16 19:36:14,087 - ompy.normalizer_nld - INFO - Starting multinest
  analysing data from multinest/nld_norm_0_.txt
2020-01-16 19:36:31,149 - ompy.normalizer_nld - INFO - Multinest results:
┌───────────────┬─────────────────┬─────────────────┬────────────────┐
│ A             │ α [MeV⁻¹]       │ T [MeV]         │ Eshift [MeV]   │
╞═══════════════╪═════════════════╪═════════════════╪════════════════╡
│ 5.312 ± 0.038 │ 1.5907 ± 0.0098 │ 0.6130 ± 0.0059 │ -0.646 ± 0.040 │
└───────────────┴─────────────────┴─────────────────┴────────────────┘

[31]:

nldnorm.plot();

Observe that you might get strange results, i.e. unexpected results here, as you use the (potentially erroneous determinated) uncertainties of nld_mean in the normalzation, instead of the proper normalization below.

\(\gamma\)-SF Normalization¶

[32]:

normlog = om.introspection.get_logger('normalizer_gsf', 'INFO')
gsfnorm = om.NormalizerGSF(normalizer_nld=nldnorm, gsf=extractor.gsf[0])

# to be use for gsf normalization
norm_pars.Gg = [112., 20.]  #meV

gsfnorm.norm_pars = norm_pars
gsfnorm.model_high.Efit = [4.5, 6.]

[33]:

gsfnorm.normalize()
gsfnorm.plot()

2020-01-16 19:36:31,290 - ompy.normalizer_gsf - INFO - Normalizing #0

[33]:

(<Figure size 448x336 with 1 Axes>,
 <matplotlib.axes._subplots.AxesSubplot at 0x7f6c9469a048>)

It’s often instructive to plot the extrapolation of the \(\gamma\)SF; with the interactive code below, we can check the influence of choosing different fit regions. The latest choice is kept for the simultaneous normalization below.

[34]:

gsfnorm.plot_interactive()

2020-01-16 19:36:31,419 - ompy.normalizer_gsf - INFO - Normalizing #0

2. Simultaneous:¶

We now propose to normalize the NLD and \(\gamma\)SF simultaneously instead. This way, we are guaranteed to get matching combinations of the normalization parameters \(A\), \(B\) and \(\alpha\) for a given ensemble member.

[35]:

simnorm = om.introspection.get_logger('normalizer_simultan', 'INFO')
simnorm = om.NormalizerSimultan(normalizer_nld=nldnorm,
                                      normalizer_gsf=gsfnorm)
simnorm.multinest_kwargs["n_live_points"] = 300 # running faster than the default 400 but less precise(!)
simnorm.normalize(gsf=extractor.gsf[0], nld=extractor.nld[0])

2020-01-16 19:36:32,466 - ompy.normalizer_nld - INFO - DE results:
┌────────────────────┬────────────────────┬─────────────────────┬─────────────────────┐
│ A                  │ α [MeV⁻¹]          │ T [MeV]             │ Eshift [MeV]        │
╞════════════════════╪════════════════════╪═════════════════════╪═════════════════════╡
│ 3.7643483546390715 │ 1.9401560826886584 │ 0.49746926163445127 │ -0.1827625935820638 │
└────────────────────┴────────────────────┴─────────────────────┴─────────────────────┘
2020-01-16 19:36:32,508 - ompy.normalizer_gsf - INFO - Normalizing #0
2020-01-16 19:36:32,514 - ompy.normalizer_simultan - INFO - DE results/initial guess:
┌────────────────────┬────────────────────┬─────────────────────┬─────────────────────┬───────────────────┐
│ A                  │ α [MeV⁻¹]          │ T [MeV]             │ Eshift [MeV]        │ B                 │
╞════════════════════╪════════════════════╪═════════════════════╪═════════════════════╪═══════════════════╡
│ 3.7643483546390715 │ 1.9401560826886584 │ 0.49746926163445127 │ -0.1827625935820638 │ 128.4130378428177 │
└────────────────────┴────────────────────┴─────────────────────┴─────────────────────┴───────────────────┘
2020-01-16 19:36:32,515 - ompy.normalizer_simultan - INFO - Starting multinest:
  analysing data from multinest/sim_norm_0_.txt
2020-01-16 19:38:02,641 - ompy.normalizer_simultan - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┬─────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │ B       │
╞═════════════╪═══════════════╪═══════════════╪══════════════╪═════════╡
│ 3.93 ± 0.52 │ 1.921 ± 0.050 │ 0.495 ± 0.014 │ -0.14 ± 0.23 │ 40 ± 14 │
└─────────────┴───────────────┴───────────────┴──────────────┴─────────┘

[36]:

simnorm.plot();

3. Normalization the whole ensemble¶

We have now also developed the toolset to normalize each member of the extractor ensemble separatly. This should provide a statistically more sound and robust normalization.

Why so? As the \(\chi^2\) error function is degenerate, a good minimizer should return sets of (nld, gsf) that need to be normalized with different coefficients \(A\), \(B\) and \(\alpha\). Thus we should normalize each of these sets independently, and build up an uncertainty band only after the normalization. (Instead of the traditional approach of normalizing the mean of the sets)

Again, you decide whether you normalize sequencially, or, as we recommend, to normalize simultaneously.

Note that this will this may take several minutes!

Sequential normalization¶

[37]:

normlog = om.introspection.get_logger('ensembleNormalizer', 'INFO')
ensemblenorm_seq = om.EnsembleNormalizer(extractor=extractor, normalizer_nld=nldnorm,
                                     normalizer_gsf=gsfnorm)
ensemblenorm_seq.normalize()

2020-01-16 19:38:02,737 - ompy.ensembleNormalizer - INFO - Start normalization with 3 cpus

2020-01-16 19:38:02,858 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #0
2020-01-16 19:38:02,909 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #1
2020-01-16 19:38:02,954 - ompy.normalizer_nld - INFO -

---------
Normalizing nld #0
2020-01-16 19:38:02,961 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #2
2020-01-16 19:38:02,982 - ompy.normalizer_nld - INFO -

---------
Normalizing nld #1
2020-01-16 19:38:03,050 - ompy.normalizer_nld - INFO -

---------
Normalizing nld #2
2020-01-16 19:38:04,031 - ompy.normalizer_nld - INFO - DE results:
┌────────────────────┬────────────────────┬────────────────────┬─────────────────────┐
│ A                  │ α [MeV⁻¹]          │ T [MeV]            │ Eshift [MeV]        │
╞════════════════════╪════════════════════╪════════════════════╪═════════════════════╡
│ 3.8305851675914617 │ 1.9171967932850047 │ 0.4929099075787158 │ -0.1065935057988842 │
└────────────────────┴────────────────────┴────────────────────┴─────────────────────┘
2020-01-16 19:38:04,033 - ompy.normalizer_nld - INFO - Starting multinest
2020-01-16 19:38:04,195 - ompy.normalizer_nld - INFO - DE results:
┌────────────────────┬────────────────────┬────────────────────┬──────────────────────┐
│ A                  │ α [MeV⁻¹]          │ T [MeV]            │ Eshift [MeV]         │
╞════════════════════╪════════════════════╪════════════════════╪══════════════════════╡
│ 3.8331327880501833 │ 1.9181229729650628 │ 0.4929191206039593 │ -0.10690422886975122 │
└────────────────────┴────────────────────┴────────────────────┴──────────────────────┘
2020-01-16 19:38:04,198 - ompy.normalizer_nld - INFO - Starting multinest
2020-01-16 19:38:04,421 - ompy.normalizer_nld - INFO - DE results:
┌───────────────────┬───────────────────┬─────────────────────┬─────────────────────┐
│ A                 │ α [MeV⁻¹]         │ T [MeV]             │ Eshift [MeV]        │
╞═══════════════════╪═══════════════════╪═════════════════════╪═════════════════════╡
│ 3.764351801902385 │ 1.940155820648791 │ 0.49746926521790297 │ -0.1827629879224515 │
└───────────────────┴───────────────────┴─────────────────────┴─────────────────────┘
2020-01-16 19:38:04,423 - ompy.normalizer_nld - INFO - Starting multinest
  analysing data from multinest/nld_norm_0_.txt
2020-01-16 19:38:25,755 - ompy.normalizer_nld - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │
╞═════════════╪═══════════════╪═══════════════╪══════════════╡
│ 3.88 ± 0.51 │ 1.934 ± 0.051 │ 0.499 ± 0.015 │ -0.19 ± 0.24 │
└─────────────┴───────────────┴───────────────┴──────────────┘
2020-01-16 19:38:25,810 - ompy.normalizer_gsf - INFO - Normalizing #0
2020-01-16 19:38:25,868 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #3
2020-01-16 19:38:25,958 - ompy.normalizer_nld - INFO -

---------
Normalizing nld #3
  analysing data from multinest/nld_norm_1_.txt
2020-01-16 19:38:27,616 - ompy.normalizer_nld - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │
╞═════════════╪═══════════════╪═══════════════╪══════════════╡
│ 3.98 ± 0.55 │ 1.909 ± 0.052 │ 0.495 ± 0.014 │ -0.12 ± 0.23 │
└─────────────┴───────────────┴───────────────┴──────────────┘
2020-01-16 19:38:27,676 - ompy.normalizer_gsf - INFO - Normalizing #1
2020-01-16 19:38:27,742 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #4
2020-01-16 19:38:27,812 - ompy.normalizer_nld - INFO -

---------
Normalizing nld #4
2020-01-16 19:38:27,814 - ompy.normalizer_nld - INFO - DE results:
┌───────────────────┬────────────────────┬─────────────────────┬──────────────────────┐
│ A                 │ α [MeV⁻¹]          │ T [MeV]             │ Eshift [MeV]         │
╞═══════════════════╪════════════════════╪═════════════════════╪══════════════════════╡
│ 3.851698375780031 │ 1.9153803821693023 │ 0.49272814463223574 │ -0.10388822618931262 │
└───────────────────┴────────────────────┴─────────────────────┴──────────────────────┘
2020-01-16 19:38:27,816 - ompy.normalizer_nld - INFO - Starting multinest
  analysing data from multinest/nld_norm_2_.txt
2020-01-16 19:38:29,211 - ompy.normalizer_nld - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │
╞═════════════╪═══════════════╪═══════════════╪══════════════╡
│ 3.99 ± 0.52 │ 1.910 ± 0.056 │ 0.494 ± 0.015 │ -0.12 ± 0.25 │
└─────────────┴───────────────┴───────────────┴──────────────┘
2020-01-16 19:38:29,250 - ompy.normalizer_gsf - INFO - Normalizing #2
2020-01-16 19:38:29,293 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #5
2020-01-16 19:38:29,359 - ompy.normalizer_nld - INFO -

---------
Normalizing nld #5
2020-01-16 19:38:29,387 - ompy.normalizer_nld - INFO - DE results:
┌───────────────────┬────────────────────┬────────────────────┬─────────────────────┐
│ A                 │ α [MeV⁻¹]          │ T [MeV]            │ Eshift [MeV]        │
╞═══════════════════╪════════════════════╪════════════════════╪═════════════════════╡
│ 3.861726013691395 │ 1.9124678737912915 │ 0.4923146887074925 │ -0.0970846112341923 │
└───────────────────┴────────────────────┴────────────────────┴─────────────────────┘
2020-01-16 19:38:29,388 - ompy.normalizer_nld - INFO - Starting multinest
2020-01-16 19:38:30,983 - ompy.normalizer_nld - INFO - DE results:
┌────────────────────┬────────────────────┬─────────────────────┬──────────────────────┐
│ A                  │ α [MeV⁻¹]          │ T [MeV]             │ Eshift [MeV]         │
╞════════════════════╪════════════════════╪═════════════════════╪══════════════════════╡
│ 3.8209946450179575 │ 1.9345616190068577 │ 0.49702253831327836 │ -0.17508789720810342 │
└────────────────────┴────────────────────┴─────────────────────┴──────────────────────┘
2020-01-16 19:38:30,986 - ompy.normalizer_nld - INFO - Starting multinest
  analysing data from multinest/nld_norm_3_.txt
  analysing data from multinest/nld_norm_5_.txt
2020-01-16 19:38:54,978 - ompy.normalizer_nld - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │
╞═════════════╪═══════════════╪═══════════════╪══════════════╡
│ 4.01 ± 0.55 │ 1.926 ± 0.053 │ 0.498 ± 0.014 │ -0.19 ± 0.24 │
└─────────────┴───────────────┴───────────────┴──────────────┘
2020-01-16 19:38:55,012 - ompy.normalizer_gsf - INFO - Normalizing #5
2020-01-16 19:38:55,038 - ompy.normalizer_nld - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │
╞═════════════╪═══════════════╪═══════════════╪══════════════╡
│ 4.08 ± 0.58 │ 1.909 ± 0.060 │ 0.499 ± 0.016 │ -0.21 ± 0.27 │
└─────────────┴───────────────┴───────────────┴──────────────┘
2020-01-16 19:38:55,043 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #6
2020-01-16 19:38:55,105 - ompy.normalizer_gsf - INFO - Normalizing #3
2020-01-16 19:38:55,136 - ompy.normalizer_nld - INFO -

---------
Normalizing nld #6
2020-01-16 19:38:55,154 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #7
2020-01-16 19:38:55,265 - ompy.normalizer_nld - INFO -

---------
Normalizing nld #7
  analysing data from multinest/nld_norm_4_.txt
2020-01-16 19:38:56,046 - ompy.normalizer_nld - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │
╞═════════════╪═══════════════╪═══════════════╪══════════════╡
│ 3.99 ± 0.55 │ 1.905 ± 0.055 │ 0.494 ± 0.015 │ -0.12 ± 0.25 │
└─────────────┴───────────────┴───────────────┴──────────────┘
2020-01-16 19:38:56,078 - ompy.normalizer_gsf - INFO - Normalizing #4
2020-01-16 19:38:56,114 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #8
2020-01-16 19:38:56,191 - ompy.normalizer_nld - INFO -

---------
Normalizing nld #8
2020-01-16 19:38:56,454 - ompy.normalizer_nld - INFO - DE results:
┌───────────────────┬──────────────────┬─────────────────────┬──────────────────────┐
│ A                 │ α [MeV⁻¹]        │ T [MeV]             │ Eshift [MeV]         │
╞═══════════════════╪══════════════════╪═════════════════════╪══════════════════════╡
│ 3.816876317779932 │ 1.93248997944277 │ 0.49686632872678804 │ -0.17282867508789476 │
└───────────────────┴──────────────────┴─────────────────────┴──────────────────────┘
2020-01-16 19:38:56,455 - ompy.normalizer_nld - INFO - Starting multinest
2020-01-16 19:38:56,755 - ompy.normalizer_nld - INFO - DE results:
┌────────────────────┬────────────────────┬────────────────────┬──────────────────────┐
│ A                  │ α [MeV⁻¹]          │ T [MeV]            │ Eshift [MeV]         │
╞════════════════════╪════════════════════╪════════════════════╪══════════════════════╡
│ 3.8342138822465777 │ 1.9246051146476373 │ 0.4942497918442618 │ -0.12906340629514734 │
└────────────────────┴────────────────────┴────────────────────┴──────────────────────┘
2020-01-16 19:38:56,756 - ompy.normalizer_nld - INFO - Starting multinest
2020-01-16 19:38:58,154 - ompy.normalizer_nld - INFO - DE results:
┌────────────────────┬────────────────────┬─────────────────────┬─────────────────────┐
│ A                  │ α [MeV⁻¹]          │ T [MeV]             │ Eshift [MeV]        │
╞════════════════════╪════════════════════╪═════════════════════╪═════════════════════╡
│ 3.8389528052436397 │ 1.9332832928904529 │ 0.49678014364651946 │ -0.1712521677556156 │
└────────────────────┴────────────────────┴─────────────────────┴─────────────────────┘
2020-01-16 19:38:58,157 - ompy.normalizer_nld - INFO - Starting multinest
  analysing data from multinest/nld_norm_7_.txt
2020-01-16 19:39:20,905 - ompy.normalizer_nld - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │
╞═════════════╪═══════════════╪═══════════════╪══════════════╡
│ 3.94 ± 0.53 │ 1.926 ± 0.051 │ 0.498 ± 0.014 │ -0.18 ± 0.24 │
└─────────────┴───────────────┴───────────────┴──────────────┘
2020-01-16 19:39:20,960 - ompy.normalizer_gsf - INFO - Normalizing #7
2020-01-16 19:39:21,006 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #9
2020-01-16 19:39:21,117 - ompy.normalizer_nld - INFO -

---------
Normalizing nld #9
  analysing data from multinest/nld_norm_6_.txt
2020-01-16 19:39:21,521 - ompy.normalizer_nld - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │
╞═════════════╪═══════════════╪═══════════════╪══════════════╡
│ 3.98 ± 0.54 │ 1.919 ± 0.054 │ 0.495 ± 0.015 │ -0.15 ± 0.24 │
└─────────────┴───────────────┴───────────────┴──────────────┘
2020-01-16 19:39:21,577 - ompy.normalizer_gsf - INFO - Normalizing #6
  analysing data from multinest/nld_norm_8_.txt
2020-01-16 19:39:22,065 - ompy.normalizer_nld - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │
╞═════════════╪═══════════════╪═══════════════╪══════════════╡
│ 3.99 ± 0.55 │ 1.930 ± 0.053 │ 0.499 ± 0.015 │ -0.20 ± 0.23 │
└─────────────┴───────────────┴───────────────┴──────────────┘
2020-01-16 19:39:22,105 - ompy.normalizer_gsf - INFO - Normalizing #8
2020-01-16 19:39:22,422 - ompy.normalizer_nld - INFO - DE results:
┌───────────────────┬────────────────────┬────────────────────┬─────────────────────┐
│ A                 │ α [MeV⁻¹]          │ T [MeV]            │ Eshift [MeV]        │
╞═══════════════════╪════════════════════╪════════════════════╪═════════════════════╡
│ 3.813899493723705 │ 1.9151868170121205 │ 0.4919696522624897 │ -0.0908778980073907 │
└───────────────────┴────────────────────┴────────────────────┴─────────────────────┘
2020-01-16 19:39:22,423 - ompy.normalizer_nld - INFO - Starting multinest
  analysing data from multinest/nld_norm_9_.txt
2020-01-16 19:39:38,144 - ompy.normalizer_nld - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │
╞═════════════╪═══════════════╪═══════════════╪══════════════╡
│ 3.96 ± 0.53 │ 1.909 ± 0.053 │ 0.493 ± 0.014 │ -0.11 ± 0.24 │
└─────────────┴───────────────┴───────────────┴──────────────┘
2020-01-16 19:39:38,180 - ompy.normalizer_gsf - INFO - Normalizing #9

[38]:

ensemblenorm_seq.plot();

Simultaneous normalization¶

[39]:

ensemblenorm_sim = om.EnsembleNormalizer(extractor=extractor, normalizer_simultan=simnorm)

ensemblenorm_sim.normalize()

2020-01-16 19:39:38,555 - ompy.ensembleNormalizer - INFO - Start normalization with 3 cpus
2020-01-16 19:39:38,658 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #0

2020-01-16 19:39:38,727 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #1
2020-01-16 19:39:38,816 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #2
2020-01-16 19:39:40,039 - ompy.normalizer_nld - INFO - DE results:
┌────────────────────┬────────────────────┬────────────────────┬─────────────────────┐
│ A                  │ α [MeV⁻¹]          │ T [MeV]            │ Eshift [MeV]        │
╞════════════════════╪════════════════════╪════════════════════╪═════════════════════╡
│ 3.8305851675914617 │ 1.9171967932850047 │ 0.4929099075787158 │ -0.1065935057988842 │
└────────────────────┴────────────────────┴────────────────────┴─────────────────────┘
2020-01-16 19:39:40,081 - ompy.normalizer_gsf - INFO - Normalizing #0
2020-01-16 19:39:40,092 - ompy.normalizer_simultan - INFO - DE results/initial guess:
┌────────────────────┬────────────────────┬────────────────────┬─────────────────────┬────────────────────┐
│ A                  │ α [MeV⁻¹]          │ T [MeV]            │ Eshift [MeV]        │ B                  │
╞════════════════════╪════════════════════╪════════════════════╪═════════════════════╪════════════════════╡
│ 3.8305851675914617 │ 1.9171967932850047 │ 0.4929099075787158 │ -0.1065935057988842 │ 135.19226239542235 │
└────────────────────┴────────────────────┴────────────────────┴─────────────────────┴────────────────────┘
2020-01-16 19:39:40,094 - ompy.normalizer_simultan - INFO - Starting multinest:
2020-01-16 19:39:40,292 - ompy.normalizer_nld - INFO - DE results:
┌───────────────────┬───────────────────┬─────────────────────┬─────────────────────┐
│ A                 │ α [MeV⁻¹]         │ T [MeV]             │ Eshift [MeV]        │
╞═══════════════════╪═══════════════════╪═════════════════════╪═════════════════════╡
│ 3.764351801902385 │ 1.940155820648791 │ 0.49746926521790297 │ -0.1827629879224515 │
└───────────────────┴───────────────────┴─────────────────────┴─────────────────────┘
2020-01-16 19:39:40,353 - ompy.normalizer_gsf - INFO - Normalizing #0
2020-01-16 19:39:40,368 - ompy.normalizer_simultan - INFO - DE results/initial guess:
┌───────────────────┬───────────────────┬─────────────────────┬─────────────────────┬────────────────────┐
│ A                 │ α [MeV⁻¹]         │ T [MeV]             │ Eshift [MeV]        │ B                  │
╞═══════════════════╪═══════════════════╪═════════════════════╪═════════════════════╪════════════════════╡
│ 3.764351801902385 │ 1.940155820648791 │ 0.49746926521790297 │ -0.1827629879224515 │ 128.41303318714756 │
└───────────────────┴───────────────────┴─────────────────────┴─────────────────────┴────────────────────┘
2020-01-16 19:39:40,373 - ompy.normalizer_simultan - INFO - Starting multinest:
2020-01-16 19:39:40,576 - ompy.normalizer_nld - INFO - DE results:
┌────────────────────┬────────────────────┬────────────────────┬──────────────────────┐
│ A                  │ α [MeV⁻¹]          │ T [MeV]            │ Eshift [MeV]         │
╞════════════════════╪════════════════════╪════════════════════╪══════════════════════╡
│ 3.8331327880501833 │ 1.9181229729650628 │ 0.4929191206039593 │ -0.10690422886975122 │
└────────────────────┴────────────────────┴────────────────────┴──────────────────────┘
2020-01-16 19:39:40,656 - ompy.normalizer_gsf - INFO - Normalizing #0
2020-01-16 19:39:40,670 - ompy.normalizer_simultan - INFO - DE results/initial guess:
┌────────────────────┬────────────────────┬────────────────────┬──────────────────────┬────────────────────┐
│ A                  │ α [MeV⁻¹]          │ T [MeV]            │ Eshift [MeV]         │ B                  │
╞════════════════════╪════════════════════╪════════════════════╪══════════════════════╪════════════════════╡
│ 3.8331327880501833 │ 1.9181229729650628 │ 0.4929191206039593 │ -0.10690422886975122 │ 135.15049686492915 │
└────────────────────┴────────────────────┴────────────────────┴──────────────────────┴────────────────────┘
2020-01-16 19:39:40,679 - ompy.normalizer_simultan - INFO - Starting multinest:
  analysing data from multinest/sim_norm_0_.txt
  analysing data from multinest/sim_norm_2_.txt
2020-01-16 19:42:19,781 - ompy.normalizer_simultan - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┬─────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │ B       │
╞═════════════╪═══════════════╪═══════════════╪══════════════╪═════════╡
│ 3.93 ± 0.52 │ 1.914 ± 0.048 │ 0.493 ± 0.014 │ -0.11 ± 0.22 │ 41 ± 14 │
└─────────────┴───────────────┴───────────────┴──────────────┴─────────┘
2020-01-16 19:42:19,802 - ompy.normalizer_simultan - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┬─────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │ B       │
╞═════════════╪═══════════════╪═══════════════╪══════════════╪═════════╡
│ 4.01 ± 0.54 │ 1.897 ± 0.053 │ 0.491 ± 0.015 │ -0.07 ± 0.24 │ 46 ± 17 │
└─────────────┴───────────────┴───────────────┴──────────────┴─────────┘
2020-01-16 19:42:19,824 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #3
2020-01-16 19:42:19,895 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #4
2020-01-16 19:42:21,498 - ompy.normalizer_nld - INFO - DE results:
┌───────────────────┬────────────────────┬─────────────────────┬──────────────────────┐
│ A                 │ α [MeV⁻¹]          │ T [MeV]             │ Eshift [MeV]         │
╞═══════════════════╪════════════════════╪═════════════════════╪══════════════════════╡
│ 3.850434233941345 │ 1.9154521123913895 │ 0.49272521499152494 │ -0.10384574748379792 │
└───────────────────┴────────────────────┴─────────────────────┴──────────────────────┘
2020-01-16 19:42:21,561 - ompy.normalizer_gsf - INFO - Normalizing #0
2020-01-16 19:42:21,568 - ompy.normalizer_simultan - INFO - DE results/initial guess:
┌───────────────────┬────────────────────┬─────────────────────┬──────────────────────┬───────────────────┐
│ A                 │ α [MeV⁻¹]          │ T [MeV]             │ Eshift [MeV]         │ B                 │
╞═══════════════════╪════════════════════╪═════════════════════╪══════════════════════╪═══════════════════╡
│ 3.850434233941345 │ 1.9154521123913895 │ 0.49272521499152494 │ -0.10384574748379792 │ 135.0757286910683 │
└───────────────────┴────────────────────┴─────────────────────┴──────────────────────┴───────────────────┘
2020-01-16 19:42:21,569 - ompy.normalizer_simultan - INFO - Starting multinest:
2020-01-16 19:42:21,940 - ompy.normalizer_nld - INFO - DE results:
┌────────────────────┬────────────────────┬─────────────────────┬─────────────────────┐
│ A                  │ α [MeV⁻¹]          │ T [MeV]             │ Eshift [MeV]        │
╞════════════════════╪════════════════════╪═════════════════════╪═════════════════════╡
│ 3.8617254176401214 │ 1.9124678611857717 │ 0.49231466923050293 │ -0.0970842619920328 │
└────────────────────┴────────────────────┴─────────────────────┴─────────────────────┘
2020-01-16 19:42:22,008 - ompy.normalizer_gsf - INFO - Normalizing #0
2020-01-16 19:42:22,018 - ompy.normalizer_simultan - INFO - DE results/initial guess:
┌────────────────────┬────────────────────┬─────────────────────┬─────────────────────┬────────────────────┐
│ A                  │ α [MeV⁻¹]          │ T [MeV]             │ Eshift [MeV]        │ B                  │
╞════════════════════╪════════════════════╪═════════════════════╪═════════════════════╪════════════════════╡
│ 3.8617254176401214 │ 1.9124678611857717 │ 0.49231466923050293 │ -0.0970842619920328 │ 135.12843284147127 │
└────────────────────┴────────────────────┴─────────────────────┴─────────────────────┴────────────────────┘
2020-01-16 19:42:22,020 - ompy.normalizer_simultan - INFO - Starting multinest:
  analysing data from multinest/sim_norm_1_.txt
2020-01-16 19:42:36,115 - ompy.normalizer_simultan - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┬─────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │ B       │
╞═════════════╪═══════════════╪═══════════════╪══════════════╪═════════╡
│ 4.01 ± 0.54 │ 1.895 ± 0.054 │ 0.491 ± 0.014 │ -0.07 ± 0.24 │ 45 ± 17 │
└─────────────┴───────────────┴───────────────┴──────────────┴─────────┘
2020-01-16 19:42:36,176 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #5
2020-01-16 19:42:38,520 - ompy.normalizer_nld - INFO - DE results:
┌────────────────────┬────────────────────┬─────────────────────┬──────────────────────┐
│ A                  │ α [MeV⁻¹]          │ T [MeV]             │ Eshift [MeV]         │
╞════════════════════╪════════════════════╪═════════════════════╪══════════════════════╡
│ 3.8209927129682133 │ 1.9345615767350426 │ 0.49702248718576447 │ -0.17508704894901925 │
└────────────────────┴────────────────────┴─────────────────────┴──────────────────────┘
2020-01-16 19:42:38,629 - ompy.normalizer_gsf - INFO - Normalizing #0
2020-01-16 19:42:38,645 - ompy.normalizer_simultan - INFO - DE results/initial guess:
┌────────────────────┬────────────────────┬─────────────────────┬──────────────────────┬────────────────────┐
│ A                  │ α [MeV⁻¹]          │ T [MeV]             │ Eshift [MeV]         │ B                  │
╞════════════════════╪════════════════════╪═════════════════════╪══════════════════════╪════════════════════╡
│ 3.8209927129682133 │ 1.9345615767350426 │ 0.49702248718576447 │ -0.17508704894901925 │ 130.63736461267186 │
└────────────────────┴────────────────────┴─────────────────────┴──────────────────────┴────────────────────┘
2020-01-16 19:42:38,651 - ompy.normalizer_simultan - INFO - Starting multinest:
  analysing data from multinest/sim_norm_4_.txt
2020-01-16 19:44:54,804 - ompy.normalizer_simultan - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┬─────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │ B       │
╞═════════════╪═══════════════╪═══════════════╪══════════════╪═════════╡
│ 4.05 ± 0.55 │ 1.889 ± 0.050 │ 0.490 ± 0.014 │ -0.05 ± 0.23 │ 46 ± 17 │
└─────────────┴───────────────┴───────────────┴──────────────┴─────────┘
2020-01-16 19:44:54,832 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #6
  analysing data from multinest/sim_norm_3_.txt
2020-01-16 19:44:55,897 - ompy.normalizer_simultan - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┬─────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │ B       │
╞═════════════╪═══════════════╪═══════════════╪══════════════╪═════════╡
│ 4.04 ± 0.59 │ 1.892 ± 0.054 │ 0.491 ± 0.015 │ -0.07 ± 0.24 │ 46 ± 17 │
└─────────────┴───────────────┴───────────────┴──────────────┴─────────┘
2020-01-16 19:44:55,942 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #7
2020-01-16 19:44:56,075 - ompy.normalizer_nld - INFO - DE results:
┌───────────────────┬───────────────────┬─────────────────────┬────────────────────┐
│ A                 │ α [MeV⁻¹]         │ T [MeV]             │ Eshift [MeV]       │
╞═══════════════════╪═══════════════════╪═════════════════════╪════════════════════╡
│ 3.834208424380257 │ 1.924604953778852 │ 0.49424962094826996 │ -0.129060582690383 │
└───────────────────┴───────────────────┴─────────────────────┴────────────────────┘
2020-01-16 19:44:56,135 - ompy.normalizer_gsf - INFO - Normalizing #0
2020-01-16 19:44:56,146 - ompy.normalizer_simultan - INFO - DE results/initial guess:
┌───────────────────┬───────────────────┬─────────────────────┬────────────────────┬───────────────────┐
│ A                 │ α [MeV⁻¹]         │ T [MeV]             │ Eshift [MeV]       │ B                 │
╞═══════════════════╪═══════════════════╪═════════════════════╪════════════════════╪═══════════════════╡
│ 3.834208424380257 │ 1.924604953778852 │ 0.49424962094826996 │ -0.129060582690383 │ 133.0983751631022 │
└───────────────────┴───────────────────┴─────────────────────┴────────────────────┴───────────────────┘
2020-01-16 19:44:56,150 - ompy.normalizer_simultan - INFO - Starting multinest:
2020-01-16 19:44:58,053 - ompy.normalizer_nld - INFO - DE results:
┌────────────────────┬────────────────────┬────────────────────┬──────────────────────┐
│ A                  │ α [MeV⁻¹]          │ T [MeV]            │ Eshift [MeV]         │
╞════════════════════╪════════════════════╪════════════════════╪══════════════════════╡
│ 3.8168754218457948 │ 1.9324896717965918 │ 0.4968662318696611 │ -0.17282660034378833 │
└────────────────────┴────────────────────┴────────────────────┴──────────────────────┘
2020-01-16 19:44:58,119 - ompy.normalizer_gsf - INFO - Normalizing #0
2020-01-16 19:44:58,130 - ompy.normalizer_simultan - INFO - DE results/initial guess:
┌────────────────────┬────────────────────┬────────────────────┬──────────────────────┬───────────────────┐
│ A                  │ α [MeV⁻¹]          │ T [MeV]            │ Eshift [MeV]         │ B                 │
╞════════════════════╪════════════════════╪════════════════════╪══════════════════════╪═══════════════════╡
│ 3.8168754218457948 │ 1.9324896717965918 │ 0.4968662318696611 │ -0.17282660034378833 │ 130.0321818713367 │
└────────────────────┴────────────────────┴────────────────────┴──────────────────────┴───────────────────┘
2020-01-16 19:44:58,132 - ompy.normalizer_simultan - INFO - Starting multinest:
  analysing data from multinest/sim_norm_5_.txt
2020-01-16 19:45:04,811 - ompy.normalizer_simultan - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┬─────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │ B       │
╞═════════════╪═══════════════╪═══════════════╪══════════════╪═════════╡
│ 4.29 ± 0.55 │ 1.847 ± 0.030 │ 0.480 ± 0.012 │ 0.11 ± 0.18  │ 62 ± 15 │
└─────────────┴───────────────┴───────────────┴──────────────┴─────────┘
2020-01-16 19:45:04,862 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #8
2020-01-16 19:45:06,215 - ompy.normalizer_nld - INFO - DE results:
┌────────────────────┬────────────────────┬────────────────────┬─────────────────────┐
│ A                  │ α [MeV⁻¹]          │ T [MeV]            │ Eshift [MeV]        │
╞════════════════════╪════════════════════╪════════════════════╪═════════════════════╡
│ 3.8389546886110604 │ 1.9332829078254432 │ 0.4967800553244072 │ -0.1712507117950638 │
└────────────────────┴────────────────────┴────────────────────┴─────────────────────┘
2020-01-16 19:45:06,264 - ompy.normalizer_gsf - INFO - Normalizing #0
2020-01-16 19:45:06,272 - ompy.normalizer_simultan - INFO - DE results/initial guess:
┌────────────────────┬────────────────────┬────────────────────┬─────────────────────┬────────────────────┐
│ A                  │ α [MeV⁻¹]          │ T [MeV]            │ Eshift [MeV]        │ B                  │
╞════════════════════╪════════════════════╪════════════════════╪═════════════════════╪════════════════════╡
│ 3.8389546886110604 │ 1.9332829078254432 │ 0.4967800553244072 │ -0.1712507117950638 │ 130.43172956085178 │
└────────────────────┴────────────────────┴────────────────────┴─────────────────────┴────────────────────┘
2020-01-16 19:45:06,273 - ompy.normalizer_simultan - INFO - Starting multinest:
  analysing data from multinest/sim_norm_6_.txt
2020-01-16 19:47:10,117 - ompy.normalizer_simultan - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┬─────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │ B       │
╞═════════════╪═══════════════╪═══════════════╪══════════════╪═════════╡
│ 4.04 ± 0.55 │ 1.894 ± 0.048 │ 0.490 ± 0.014 │ -0.05 ± 0.22 │ 47 ± 16 │
└─────────────┴───────────────┴───────────────┴──────────────┴─────────┘
2020-01-16 19:47:10,146 - ompy.ensembleNormalizer - INFO -

---------
Normalizing #9
2020-01-16 19:47:11,498 - ompy.normalizer_nld - INFO - DE results:
┌───────────────────┬────────────────────┬─────────────────────┬─────────────────────┐
│ A                 │ α [MeV⁻¹]          │ T [MeV]             │ Eshift [MeV]        │
╞═══════════════════╪════════════════════╪═════════════════════╪═════════════════════╡
│ 3.813920399920752 │ 1.9152761088992238 │ 0.49200211289130746 │ -0.0914150195585414 │
└───────────────────┴────────────────────┴─────────────────────┴─────────────────────┘
2020-01-16 19:47:11,563 - ompy.normalizer_gsf - INFO - Normalizing #0
2020-01-16 19:47:11,572 - ompy.normalizer_simultan - INFO - DE results/initial guess:
┌───────────────────┬────────────────────┬─────────────────────┬─────────────────────┬────────────────────┐
│ A                 │ α [MeV⁻¹]          │ T [MeV]             │ Eshift [MeV]        │ B                  │
╞═══════════════════╪════════════════════╪═════════════════════╪═════════════════════╪════════════════════╡
│ 3.813920399920752 │ 1.9152761088992238 │ 0.49200211289130746 │ -0.0914150195585414 │ 137.86627267647992 │
└───────────────────┴────────────────────┴─────────────────────┴─────────────────────┴────────────────────┘
2020-01-16 19:47:11,574 - ompy.normalizer_simultan - INFO - Starting multinest:
  analysing data from multinest/sim_norm_7_.txt
2020-01-16 19:47:24,830 - ompy.normalizer_simultan - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┬─────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │ B       │
╞═════════════╪═══════════════╪═══════════════╪══════════════╪═════════╡
│ 3.99 ± 0.54 │ 1.912 ± 0.053 │ 0.494 ± 0.015 │ -0.13 ± 0.24 │ 42 ± 15 │
└─────────────┴───────────────┴───────────────┴──────────────┴─────────┘
  analysing data from multinest/sim_norm_8_.txt
2020-01-16 19:47:52,077 - ompy.normalizer_simultan - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┬─────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │ B       │
╞═════════════╪═══════════════╪═══════════════╪══════════════╪═════════╡
│ 3.99 ± 0.53 │ 1.913 ± 0.050 │ 0.495 ± 0.015 │ -0.13 ± 0.23 │ 41 ± 16 │
└─────────────┴───────────────┴───────────────┴──────────────┴─────────┘
  analysing data from multinest/sim_norm_9_.txt
2020-01-16 19:48:48,510 - ompy.normalizer_simultan - INFO - Multinest results:
┌─────────────┬───────────────┬───────────────┬──────────────┬─────────┐
│ A           │ α [MeV⁻¹]     │ T [MeV]       │ Eshift [MeV] │ B       │
╞═════════════╪═══════════════╪═══════════════╪══════════════╪═════════╡
│ 4.01 ± 0.54 │ 1.894 ± 0.056 │ 0.490 ± 0.015 │ -0.05 ± 0.24 │ 48 ± 18 │
└─────────────┴───────────────┴───────────────┴──────────────┴─────────┘

[40]:

ensemblenorm_sim.plot();