Tutorial 2 - Normalising abundances¶

Like in the previous tutorial we start by importing the simple package and changing the logging level to provide more detailed output.

There are two types of normalisation available within simple; standard normalisation and internal normalisation. These are the normalisations most commonly used for stardust and meteorite data respectively.

We begin by loading the model collection that we created in Tutorial 1.

In [1]:

import simple
simple.set_logging_level('INFO')

models = simple.load_collection('data/CCSNe_FeNi.hdf5')

import simple simple.set_logging_level('INFO') models = simple.load_collection('data/CCSNe_FeNi.hdf5')

Loading existing file: data/CCSNe_FeNi.hdf5
Loading file: data/CCSNe_FeNi.hdf5
Loading model: Ri18_m15 (CCSNe)
Loading model: iniab2.0E-02GN93 (IsoRef)
Loading model: W17 (IsoRef)
Loading model: Ri18_m20 (CCSNe)
Loading model: Ri18_m25 (CCSNe)
Loading model: Pi16_m15 (CCSNe)
Loading model: iniab2.0E-02GN93_Lo03 (IsoRef)
Loading model: Pi16_m20 (CCSNe)
Loading model: Pi16_m25 (CCSNe)
Loading model: La22_m15 (CCSNe)
Loading model: La22_m20 (CCSNe)
Loading model: La22_m25 (CCSNe)
Loading model: Si18_m15 (CCSNe)
Loading model: iniab1.3E-02Lo03_Lo03_merged (IsoRef)
Loading model: Si18_m20 (CCSNe)
Loading model: Si18_m25 (CCSNe)
Loading model: Ra02_m15 (CCSNe)
Loading model: rau_solar_ref (IsoRef)
Loading model: Ra02_m20 (CCSNe)
Loading model: Ra02_m25 (CCSNe)
Loading model: LC18_m15 (CCSNe)
Loading model: iniab1.3E-02As09_As09_merged (IsoRef)
Loading model: LC18_m20 (CCSNe)
Loading model: LC18_m25 (CCSNe)
Time to load file: 0:00:00.238037

Standard Normalisation¶

This is the normalisation commonly used for stardust data. It is simply the ratio of the sample over that of a standard minus 1.

$$ R^{\mathrm{SMP}}_{ij} = {\left(\frac{r^{\mathrm{SMP}}_{ij}}{R^{\mathrm{STD}}_{ij}}\right)} - 1 $$

The standard for nucleosynthetic models should ideally be the starting composition of the model which is typically the solar composition scaled to achieve the desired metallicity. A complication is that there several estimates of the solar composition and using the incorrect one can lead to some erroneous artifacts, see discussion in Pignatare et al. 202X. Fear not however each SIMPLE model contains a reference to the correct standard that is automatically used during the normalisation procedures.

All that is needed to perform this normalisation is the denominator isotope j. By default, all isotopes of the denominator element, Ni* in the example below, will normalised. The normalisation should be done using molar abundances. Therefore, if the abundances are in mass fractions they will be automatically converted to molar abundances, as can be seen in the output below.

In [2]:

models.standard_normalisation('Ni-61*')

models.standard_normalisation('Ni-61*')

Ri18_m15.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Ri18_m15.abundance-ratnorm: Normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-61*.
Ri18_m20.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Ri18_m20.abundance-ratnorm: Normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-61*.
Ri18_m25.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Ri18_m25.abundance-ratnorm: Normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-61*.
Pi16_m15.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93_Lo03.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Pi16_m15.abundance-ratnorm: Normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-61*.
Pi16_m20.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93_Lo03.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Pi16_m20.abundance-ratnorm: Normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-61*.
Pi16_m25.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93_Lo03.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Pi16_m25.abundance-ratnorm: Normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-61*.
La22_m15.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93_Lo03.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
La22_m15.abundance-ratnorm: Normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-61*.
La22_m20.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93_Lo03.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
La22_m20.abundance-ratnorm: Normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-61*.
La22_m25.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93_Lo03.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
La22_m25.abundance-ratnorm: Normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-61*.
Si18_m15.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab1.3E-02Lo03_Lo03_merged.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Si18_m15.abundance-ratnorm: Normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-61*.
Si18_m20.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab1.3E-02Lo03_Lo03_merged.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Si18_m20.abundance-ratnorm: Normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-61*.
Si18_m25.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab1.3E-02Lo03_Lo03_merged.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Si18_m25.abundance-ratnorm: Normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-61*.
Ra02_m15.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
rau_solar_ref.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Ra02_m15.abundance-ratnorm: Normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-61*.
Ra02_m20.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
rau_solar_ref.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Ra02_m20.abundance-ratnorm: Normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-61*.
Ra02_m25.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
rau_solar_ref.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Ra02_m25.abundance-ratnorm: Normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-61*.
LC18_m15.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab1.3E-02As09_As09_merged.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
LC18_m15.abundance-ratnorm: Normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-61*.
LC18_m20.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab1.3E-02As09_As09_merged.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
LC18_m20.abundance-ratnorm: Normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-61*.
LC18_m25.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab1.3E-02As09_As09_merged.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
LC18_m25.abundance-ratnorm: Normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-61*.

The result of the standard normalisation is by default stored in a new model attribute called stdnorm. This contains the normalised values, Ri, plus some additional attributes described here. The Ri attribute contains a key array that maps the numerator isotope (i) to the normalised value. The denominator isotope (j) is always inferred and should therefore not be included when accessing the normalised data.

In [3]:

models[0].stdnorm.keys()

models[0].stdnorm.keys()

Out[3]:

dict_keys(['Ri_values', 'Ri_keys', 'Ri', 'dilution_factor', 'ij_keys', 'Ri_keylabels', 'Ri_keylabels_latex'])

To plot the results of the standard normalisation we can use the stdnorm shortcut on the different plot functions. As mentioned above only the numerator isotope (i) should be specified as the denominator (j) is always implicitly inferred. The denominator isotope is always included in the key label however, so that it is clear what is being plotted.

In [4]:

simple.plot_ccsne.stdnorm(models, 'Ni-58*, Ni-60*, Ni-62*, Ni-64*', 
                            where='.mass==25 & .dataset == Ra02',
                            ax_xlim=(1.5, 12), ax_ylim=(-10, 50));

simple.plot_ccsne.stdnorm(models, 'Ni-58*, Ni-60*, Ni-62*, Ni-64*', where='.mass==25 & .dataset == Ra02', ax_xlim=(1.5, 12), ax_ylim=(-10, 50));

Plotting the slope of two normalised values is as simple as specifying the two isotopes as a ratio

In [5]:

simple.plot_ccsne.stdnorm(models, 'Ni-60*/Ni-58*, Ni-62*/Ni-58*, Ni-64*/Ni-58*', 
                          where='.mass==25 & .dataset == Ra02',
                          ax_xlim=(1.5, 12), ax_ylim=(-50, 25));

simple.plot_ccsne.stdnorm(models, 'Ni-60*/Ni-58*, Ni-62*/Ni-58*, Ni-64*/Ni-58*', where='.mass==25 & .dataset == Ra02', ax_xlim=(1.5, 12), ax_ylim=(-50, 25));

Internal Normalisation¶

Internal normalisation is commonly used to correct for mass-dependent fractionation that may occur naturally or be introduced during isotopic measurement of natural samples. It used an additional normalising step compared to the standard normalisation where the ratio kj of the sample is fixed to the value of the standard. Because the compositional variation in meteorite samples are typically very small they are usually given in epsilon notation which is simply the result of the normalisation multiplied by 10^4.

$$ \epsilon R^{\mathrm{SMP}}_{ij} = {\left[{\left(\frac{r^{\mathrm{SMP}}_{ij}}{R^{\mathrm{STD}}_{ij}}\right)} {\left(\frac{r^{\mathrm{SMP}}_{kj}}{R^{\mathrm{STD}}_{kj}}\right)}^{-Q_i} - 1 \right]} \times 10^4 $$

This internal normalisation can significantly alter the results and therefore internally normalised data cannot be directly compared to nucleosynthetic models that have been normalised using the standard normalisation method, see discussion in Lugaro et al. (2003). It is however not as simple as normalising the nucleosynthetic models using the internal normalisation procedure as they typically contains variations order of magnitudes larger than those found in meteorites. This is because mixing lines spanning order of magnitude may not be linear due to the exponential nature of the internal normalisation procedure.

There are two approached to internally normalising nucleosynthetic models to compare with meteorite data implemented in SIMPLE; largest offset and linear. See Lugaro et al. (2003) for a discussion of these method. Here we will only descrive the largest offset method which is the default method used for the internal normisation method. It works by creating a diluted sample where the largest offset is the same order of magnitude as meteorite data, by default 1 ε-unit.

$$ C_{SMP} = C_{\mathrm{STD}} + \left(\frac{C_{ABU}}{\mathrm{df}}\right) $$

Here the abundance refers to the nucleosynthetic yields and df stands for dilution factor. The starting composition of the model is used as the standard. Even more so than with the standard normalisation it is important that the standard composition used is the starting composition of the model or artifacts are likley to arise (Lugaro et al. (2003)).

All that is needed to perform this normalisation is the kj ratio. Again by default all available isotopes of the denominator isotope j will be included in the normalised array. The largest offset method implements a minumum dilution factor, by default 0.1, that sets all values that would require a dilution factor smaller than this to np.nan. This avoids artifacts due to rounding errors.

In [6]:

models.internal_normalisation('Ni-58*/Ni-61*')

models.internal_normalisation('Ni-58*/Ni-61*')

Ri18_m15.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Ri18_m15.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Ri18_m15.abundance-intnorm-largest_offset: Internally normalising 2158 rows using the largest offset method.
Ri18_m15.abundance-intnorm-largest_offset: 695 rows out of 2158 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
Ri18_m20.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Ri18_m20.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Ri18_m20.abundance-intnorm-largest_offset: Internally normalising 2088 rows using the largest offset method.
Ri18_m20.abundance-intnorm-largest_offset: 773 rows out of 2088 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
Ri18_m25.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Ri18_m25.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Ri18_m25.abundance-intnorm-largest_offset: Internally normalising 1669 rows using the largest offset method.
Ri18_m25.abundance-intnorm-largest_offset: 652 rows out of 1669 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
Pi16_m15.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93_Lo03.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Pi16_m15.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Pi16_m15.abundance-intnorm-largest_offset: Internally normalising 590 rows using the largest offset method.
Pi16_m15.abundance-intnorm-largest_offset: 284 rows out of 590 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
Pi16_m20.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93_Lo03.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Pi16_m20.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Pi16_m20.abundance-intnorm-largest_offset: Internally normalising 474 rows using the largest offset method.
Pi16_m20.abundance-intnorm-largest_offset: 259 rows out of 474 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
Pi16_m25.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93_Lo03.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Pi16_m25.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Pi16_m25.abundance-intnorm-largest_offset: Internally normalising 470 rows using the largest offset method.
Pi16_m25.abundance-intnorm-largest_offset: 103 rows out of 470 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
La22_m15.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93_Lo03.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
La22_m15.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
La22_m15.abundance-intnorm-largest_offset: Internally normalising 949 rows using the largest offset method.
La22_m15.abundance-intnorm-largest_offset: 34 rows out of 949 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
La22_m20.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93_Lo03.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
La22_m20.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
La22_m20.abundance-intnorm-largest_offset: Internally normalising 1298 rows using the largest offset method.
La22_m20.abundance-intnorm-largest_offset: 44 rows out of 1298 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
La22_m25.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93_Lo03.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
La22_m25.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
La22_m25.abundance-intnorm-largest_offset: Internally normalising 1385 rows using the largest offset method.
La22_m25.abundance-intnorm-largest_offset: 1 rows out of 1385 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
Si18_m15.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab1.3E-02Lo03_Lo03_merged.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Si18_m15.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Si18_m15.abundance-intnorm-largest_offset: Internally normalising 365 rows using the largest offset method.
Si18_m20.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab1.3E-02Lo03_Lo03_merged.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Si18_m20.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Si18_m20.abundance-intnorm-largest_offset: Internally normalising 486 rows using the largest offset method.
Si18_m25.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab1.3E-02Lo03_Lo03_merged.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Si18_m25.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Si18_m25.abundance-intnorm-largest_offset: Internally normalising 473 rows using the largest offset method.
Ra02_m15.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
rau_solar_ref.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Ra02_m15.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Ra02_m15.abundance-intnorm-largest_offset: Internally normalising 653 rows using the largest offset method.
Ra02_m15.abundance-intnorm-largest_offset: 266 rows out of 653 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
Ra02_m20.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
rau_solar_ref.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Ra02_m20.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Ra02_m20.abundance-intnorm-largest_offset: Internally normalising 673 rows using the largest offset method.
Ra02_m20.abundance-intnorm-largest_offset: 254 rows out of 673 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
Ra02_m25.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
rau_solar_ref.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Ra02_m25.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Ra02_m25.abundance-intnorm-largest_offset: Internally normalising 722 rows using the largest offset method.
Ra02_m25.abundance-intnorm-largest_offset: 308 rows out of 722 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
LC18_m15.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab1.3E-02As09_As09_merged.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
LC18_m15.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
LC18_m15.abundance-intnorm-largest_offset: Internally normalising 259 rows using the largest offset method.
LC18_m15.abundance-intnorm-largest_offset: 165 rows out of 259 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
LC18_m20.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab1.3E-02As09_As09_merged.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
LC18_m20.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
LC18_m20.abundance-intnorm-largest_offset: Internally normalising 140 rows using the largest offset method.
LC18_m20.abundance-intnorm-largest_offset: 43 rows out of 140 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
LC18_m25.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab1.3E-02As09_As09_merged.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
LC18_m25.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
LC18_m25.abundance-intnorm-largest_offset: Internally normalising 103 rows using the largest offset method.
LC18_m25.abundance-intnorm-largest_offset: 1 rows out of 103 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.

The result of the internal normalisation is by default stored in a new model attribute called intnorm. This contains the normalised values, eRi, plus some additional attributes depending on the method used described here. Like with the standard normalisation the eRi array maps the value to only the numerator isotope i.

In [7]:

models[0].intnorm.keys()

models[0].intnorm.keys()

Out[7]:

dict_keys(['eRi_values', 'dilution_factor', 'largest_offset', 'min_dilution_factor', 'method', 'eRi', 'eRi_keys', 'ij_keys', 'kj_keys', 'eRi_keylabels', 'eRi_keylabels_latex'])

The plotting function have a shortcut called intnorm for plotting internally normalised data. In the example below we can see that there is no data for the H envelope. This is because these data points did not exceed the minimum dilution factor. In the plot we can see that the largest offset at any coordinate is always 1 or -1.

In [8]:

simple.plot_ccsne.intnorm(models, 'Ni-60*, Ni-62*, Ni-64*', 
                            where='.mass==25 & .dataset == Ra02',
                            ax_xlim=(1.5, 12));

simple.plot_ccsne.intnorm(models, 'Ni-60*, Ni-62*, Ni-64*', where='.mass==25 & .dataset == Ra02', ax_xlim=(1.5, 12));

To plot the dilution factor we just have to specify the path to this attribute

In [9]:

simple.plot_ccsne.intnorm(models, '.intnorm.dilution_factor', 
                            where='.mass==25 & .dataset == Ra02',
                            ax_xlim=(1.5, 12), semilog=True);

simple.plot_ccsne.intnorm(models, '.intnorm.dilution_factor', where='.mass==25 & .dataset == Ra02', ax_xlim=(1.5, 12), semilog=True);

Again the slope can be plotted by giving the ratio of the different numerator isotopes i. The key label will include a reference to the last digits of the mass numbers for the internal normalisation ratio kj, in this case (81) for Ni-58*/Ni-61*.

In [10]:

simple.plot_ccsne.intnorm(models, 'Ni-60*/Ni-62*, Ni-64*/Ni-62*', 
                          where='.mass==25 & .dataset == Ra02',
                          ax_xlim=(1.5, 12), ax_ylim=(-20, 20));

simple.plot_ccsne.intnorm(models, 'Ni-60*/Ni-62*, Ni-64*/Ni-62*', where='.mass==25 & .dataset == Ra02', ax_xlim=(1.5, 12), ax_ylim=(-20, 20));

Multiple Elements¶

It is possible to normalise multiple elements at once for both the standard normalisation and internal normalisation procedures. All you need to do is supply a list of the normalising values. The normalisation procedure is performed accross all isotopes for the different normalisations at the same time allowing you to directly compare the result from the different normalisations.

To mimic the effects of chemical fractionation it is possible to set different enrichment factors for isotopes of the different normalisations. In the example below we have doubled the amount of Fe to mimic a process that enriched Fe, or depleted Ni. This enrichment is relative to the orignal model abundances. It is also possible to set the exact abundance of each set of isotopes using the relative_enrichment=False argument. In this scenario the sum off all isotopes for each normalisation will be set to the specified enrichment factor.

You can change the standard abundances the same way using the std_enrichment_factor and std_relative_enrichment arguments.

In [11]:

models.internal_normalisation(['Ni-58*/Ni-61*', 'Fe-57*/Fe-56*'], enrichment_factor=[1,2])

models.internal_normalisation(['Ni-58*/Ni-61*', 'Fe-57*/Fe-56*'], enrichment_factor=[1,2])

Ri18_m15.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Ri18_m15.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Ri18_m15.abundance-intnorm: Internally normalising ('Fe-54*', 'Fe-56*', 'Fe-57*', 'Fe-58*') to Fe-57*/Fe-56*.
Ri18_m15.abundance-intnorm: Applying relative enrichment factor to model abundances. Multiplying all isotopes by 2.
Ri18_m15.abundance-intnorm-largest_offset: Internally normalising 2158 rows using the largest offset method.
Ri18_m15.abundance-intnorm-largest_offset: 695 rows out of 2158 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
Ri18_m20.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Ri18_m20.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Ri18_m20.abundance-intnorm: Internally normalising ('Fe-54*', 'Fe-56*', 'Fe-57*', 'Fe-58*') to Fe-57*/Fe-56*.
Ri18_m20.abundance-intnorm: Applying relative enrichment factor to model abundances. Multiplying all isotopes by 2.
Ri18_m20.abundance-intnorm-largest_offset: Internally normalising 2088 rows using the largest offset method.
Ri18_m20.abundance-intnorm-largest_offset: 773 rows out of 2088 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
Ri18_m25.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Ri18_m25.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Ri18_m25.abundance-intnorm: Internally normalising ('Fe-54*', 'Fe-56*', 'Fe-57*', 'Fe-58*') to Fe-57*/Fe-56*.
Ri18_m25.abundance-intnorm: Applying relative enrichment factor to model abundances. Multiplying all isotopes by 2.
Ri18_m25.abundance-intnorm-largest_offset: Internally normalising 1669 rows using the largest offset method.
Ri18_m25.abundance-intnorm-largest_offset: 652 rows out of 1669 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
Pi16_m15.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93_Lo03.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Pi16_m15.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Pi16_m15.abundance-intnorm: Internally normalising ('Fe-54*', 'Fe-56*', 'Fe-57*', 'Fe-58*') to Fe-57*/Fe-56*.
Pi16_m15.abundance-intnorm: Applying relative enrichment factor to model abundances. Multiplying all isotopes by 2.
Pi16_m15.abundance-intnorm-largest_offset: Internally normalising 590 rows using the largest offset method.
Pi16_m15.abundance-intnorm-largest_offset: 284 rows out of 590 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
Pi16_m20.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93_Lo03.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Pi16_m20.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Pi16_m20.abundance-intnorm: Internally normalising ('Fe-54*', 'Fe-56*', 'Fe-57*', 'Fe-58*') to Fe-57*/Fe-56*.
Pi16_m20.abundance-intnorm: Applying relative enrichment factor to model abundances. Multiplying all isotopes by 2.
Pi16_m20.abundance-intnorm-largest_offset: Internally normalising 474 rows using the largest offset method.
Pi16_m20.abundance-intnorm-largest_offset: 259 rows out of 474 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
Pi16_m25.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93_Lo03.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Pi16_m25.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Pi16_m25.abundance-intnorm: Internally normalising ('Fe-54*', 'Fe-56*', 'Fe-57*', 'Fe-58*') to Fe-57*/Fe-56*.
Pi16_m25.abundance-intnorm: Applying relative enrichment factor to model abundances. Multiplying all isotopes by 2.
Pi16_m25.abundance-intnorm-largest_offset: Internally normalising 470 rows using the largest offset method.
Pi16_m25.abundance-intnorm-largest_offset: 103 rows out of 470 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
La22_m15.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93_Lo03.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
La22_m15.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
La22_m15.abundance-intnorm: Internally normalising ('Fe-54*', 'Fe-56*', 'Fe-57*', 'Fe-58*') to Fe-57*/Fe-56*.
La22_m15.abundance-intnorm: Applying relative enrichment factor to model abundances. Multiplying all isotopes by 2.
La22_m15.abundance-intnorm-largest_offset: Internally normalising 949 rows using the largest offset method.
La22_m15.abundance-intnorm-largest_offset: 34 rows out of 949 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
La22_m20.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93_Lo03.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
La22_m20.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
La22_m20.abundance-intnorm: Internally normalising ('Fe-54*', 'Fe-56*', 'Fe-57*', 'Fe-58*') to Fe-57*/Fe-56*.
La22_m20.abundance-intnorm: Applying relative enrichment factor to model abundances. Multiplying all isotopes by 2.
La22_m20.abundance-intnorm-largest_offset: Internally normalising 1298 rows using the largest offset method.
La22_m20.abundance-intnorm-largest_offset: 44 rows out of 1298 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
La22_m25.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab2.0E-02GN93_Lo03.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
La22_m25.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
La22_m25.abundance-intnorm: Internally normalising ('Fe-54*', 'Fe-56*', 'Fe-57*', 'Fe-58*') to Fe-57*/Fe-56*.
La22_m25.abundance-intnorm: Applying relative enrichment factor to model abundances. Multiplying all isotopes by 2.
La22_m25.abundance-intnorm-largest_offset: Internally normalising 1385 rows using the largest offset method.
La22_m25.abundance-intnorm-largest_offset: 1 rows out of 1385 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
Si18_m15.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab1.3E-02Lo03_Lo03_merged.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Si18_m15.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Si18_m15.abundance-intnorm: Internally normalising ('Fe-54*', 'Fe-56*', 'Fe-57*', 'Fe-58*') to Fe-57*/Fe-56*.
Si18_m15.abundance-intnorm: Applying relative enrichment factor to model abundances. Multiplying all isotopes by 2.
Si18_m15.abundance-intnorm-largest_offset: Internally normalising 365 rows using the largest offset method.
Si18_m20.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab1.3E-02Lo03_Lo03_merged.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Si18_m20.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Si18_m20.abundance-intnorm: Internally normalising ('Fe-54*', 'Fe-56*', 'Fe-57*', 'Fe-58*') to Fe-57*/Fe-56*.
Si18_m20.abundance-intnorm: Applying relative enrichment factor to model abundances. Multiplying all isotopes by 2.
Si18_m20.abundance-intnorm-largest_offset: Internally normalising 486 rows using the largest offset method.
Si18_m25.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab1.3E-02Lo03_Lo03_merged.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Si18_m25.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Si18_m25.abundance-intnorm: Internally normalising ('Fe-54*', 'Fe-56*', 'Fe-57*', 'Fe-58*') to Fe-57*/Fe-56*.
Si18_m25.abundance-intnorm: Applying relative enrichment factor to model abundances. Multiplying all isotopes by 2.
Si18_m25.abundance-intnorm-largest_offset: Internally normalising 473 rows using the largest offset method.
Ra02_m15.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
rau_solar_ref.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Ra02_m15.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Ra02_m15.abundance-intnorm: Internally normalising ('Fe-54*', 'Fe-56*', 'Fe-57*', 'Fe-58*') to Fe-57*/Fe-56*.
Ra02_m15.abundance-intnorm: Applying relative enrichment factor to model abundances. Multiplying all isotopes by 2.
Ra02_m15.abundance-intnorm-largest_offset: Internally normalising 653 rows using the largest offset method.
Ra02_m15.abundance-intnorm-largest_offset: 266 rows out of 653 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
Ra02_m20.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
rau_solar_ref.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Ra02_m20.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Ra02_m20.abundance-intnorm: Internally normalising ('Fe-54*', 'Fe-56*', 'Fe-57*', 'Fe-58*') to Fe-57*/Fe-56*.
Ra02_m20.abundance-intnorm: Applying relative enrichment factor to model abundances. Multiplying all isotopes by 2.
Ra02_m20.abundance-intnorm-largest_offset: Internally normalising 673 rows using the largest offset method.
Ra02_m20.abundance-intnorm-largest_offset: 254 rows out of 673 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
Ra02_m25.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
rau_solar_ref.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
Ra02_m25.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
Ra02_m25.abundance-intnorm: Internally normalising ('Fe-54*', 'Fe-56*', 'Fe-57*', 'Fe-58*') to Fe-57*/Fe-56*.
Ra02_m25.abundance-intnorm: Applying relative enrichment factor to model abundances. Multiplying all isotopes by 2.
Ra02_m25.abundance-intnorm-largest_offset: Internally normalising 722 rows using the largest offset method.
Ra02_m25.abundance-intnorm-largest_offset: 308 rows out of 722 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
LC18_m15.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab1.3E-02As09_As09_merged.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
LC18_m15.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
LC18_m15.abundance-intnorm: Internally normalising ('Fe-54*', 'Fe-56*', 'Fe-57*', 'Fe-58*') to Fe-57*/Fe-56*.
LC18_m15.abundance-intnorm: Applying relative enrichment factor to model abundances. Multiplying all isotopes by 2.
LC18_m15.abundance-intnorm-largest_offset: Internally normalising 259 rows using the largest offset method.
LC18_m15.abundance-intnorm-largest_offset: 165 rows out of 259 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
LC18_m20.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab1.3E-02As09_As09_merged.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
LC18_m20.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
LC18_m20.abundance-intnorm: Internally normalising ('Fe-54*', 'Fe-56*', 'Fe-57*', 'Fe-58*') to Fe-57*/Fe-56*.
LC18_m20.abundance-intnorm: Applying relative enrichment factor to model abundances. Multiplying all isotopes by 2.
LC18_m20.abundance-intnorm-largest_offset: Internally normalising 140 rows using the largest offset method.
LC18_m20.abundance-intnorm-largest_offset: 43 rows out of 140 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.
LC18_m25.abundance: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
iniab1.3E-02As09_As09_merged.data: Converting array from ``mass`` to ``mole`` unit by dividing the data by the mass number
LC18_m25.abundance-intnorm: Internally normalising ('Ni-58*', 'Ni-60*', 'Ni-61*', 'Ni-62*', 'Ni-64*') to Ni-58*/Ni-61*.
LC18_m25.abundance-intnorm: Internally normalising ('Fe-54*', 'Fe-56*', 'Fe-57*', 'Fe-58*') to Fe-57*/Fe-56*.
LC18_m25.abundance-intnorm: Applying relative enrichment factor to model abundances. Multiplying all isotopes by 2.
LC18_m25.abundance-intnorm-largest_offset: Internally normalising 103 rows using the largest offset method.
LC18_m25.abundance-intnorm-largest_offset: 1 rows out of 103 have largest offsets smaller than 1 ε-units at the minimum dilution factor of 0.1. These rows are set to nan.

In [12]:

simple.plot_ccsne.intnorm(models, 'Ni-58*, Ni-60*, Ni-62*, Ni-64*', 
                            where='.mass==25 & .dataset == Ra02',
                            ax_xlim=(1.5, 12));

simple.plot_ccsne.intnorm(models, 'Ni-58*, Ni-60*, Ni-62*, Ni-64*', where='.mass==25 & .dataset == Ra02', ax_xlim=(1.5, 12));

The figure above looks different from the one produced when we only normalised Ni. This is because at some coordinates the largest offset is defined by an Fe isotope which therefore changes the magnitude of the Ni variations. The relative Ni variations though remain the same which can be seen if we plot the slopes

In [13]:

simple.plot_ccsne.intnorm(models, 'Ni-60*/Ni-62*, Ni-64*/Ni-62*', 
                          where='.mass==25 & .dataset == Ra02',
                          ax_xlim=(1.5, 12), ax_ylim=(-20, 20));

simple.plot_ccsne.intnorm(models, 'Ni-60*/Ni-62*, Ni-64*/Ni-62*', where='.mass==25 & .dataset == Ra02', ax_xlim=(1.5, 12), ax_ylim=(-20, 20));

We can plot any isotopes from any normalisation we can plot the slopes of Ni vs Fe isotopes.

In [14]:

simple.plot_ccsne.intnorm(models, 'Ni-60*/Fe-54*, Ni-64*/Fe-54*', 
                          where='.mass==25 & .dataset == Ra02',
                          ax_xlim=(1.5, 12), ax_ylim=(-20, 20));

simple.plot_ccsne.intnorm(models, 'Ni-60*/Fe-54*, Ni-64*/Fe-54*', where='.mass==25 & .dataset == Ra02', ax_xlim=(1.5, 12), ax_ylim=(-20, 20));

Slope Histograms¶

Another way to compare slopes from multiple models at once is to plot a histogram on a rose diagram. This allow us to easily see which slopes are the most dominant for the different models. In the examples below we plot the slope of Ni-62*/Ni-60* for the different models from the Ra02 data set.

In [15]:

simple.mhist.intnorm(models, 'Ni-60*', 'Ni-62*',
                            where='.dataset == Ra02');

simple.mhist.intnorm(models, 'Ni-60*', 'Ni-62*', where='.dataset == Ra02');

In the previous example each coordinate carries the same weight irrespective of the mass of Ni and the overall mass for each coordinate.

We can change the mass of each coordinate to be equal to the sum of all Ni isotopes in that coordinate using the weights argument. We can either pass a list of all the isotopes we wish to add together or we can pass the element symbol from which all isotopes will be automatically summed up. Additionally, the mhist_ccsne function will automatically multiply all weights by the mass of each coordinate.

We can see some differences between the plots. There are some slopes that are present in many coordinates but have low Ni or a low overall mass and therefore are much less prominent in the new plot.

In [16]:

simple.mhist_ccsne.intnorm(models, 'Ni-60*', 'Ni-62*', weights='Ni*',
                            where='.dataset == Ra02');

simple.mhist_ccsne.intnorm(models, 'Ni-60*', 'Ni-62*', weights='Ni*', where='.dataset == Ra02');

Ra02_m15: Calculating weights by adding together: abundance | <w> [mass] <w: Ni-58*, Ni-60*, Ni-61*, Ni-62*, Ni-64*>
Ra02_m20: Calculating weights by adding together: abundance | <w> [mass] <w: Ni-58*, Ni-60*, Ni-61*, Ni-62*, Ni-64*>
Ra02_m25: Calculating weights by adding together: abundance | <w> [mass] <w: Ni-58*, Ni-60*, Ni-61*, Ni-62*, Ni-64*>
Multiplying all weights by the mass coordinate mass

We can plot all the model together in one circle using a contour plot instead.

In [17]:

simple.mcontour_ccsne.intnorm(models, 'Ni-60*', 'Ni-62*', weights='Ni*',
                            where='.dataset == Ra02');

simple.mcontour_ccsne.intnorm(models, 'Ni-60*', 'Ni-62*', weights='Ni*', where='.dataset == Ra02');

Ra02_m15: Calculating weights by adding together: abundance | <w> [mass] <w: Ni-58*, Ni-60*, Ni-61*, Ni-62*, Ni-64*>
Ra02_m20: Calculating weights by adding together: abundance | <w> [mass] <w: Ni-58*, Ni-60*, Ni-61*, Ni-62*, Ni-64*>
Ra02_m25: Calculating weights by adding together: abundance | <w> [mass] <w: Ni-58*, Ni-60*, Ni-61*, Ni-62*, Ni-64*>
Multiplying all weights by the mass coordinate mass