{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This notebook shows a general example of mass balance calculation, we currently support two algorithms:\n",
"\n",
"1. [Non-negative algorithm](https://epubs.siam.org/doi/pdf/10.1137/1.9781611971217.bm), it solves KKT (Karush-Kuhn-Tucker) conditions for the non-negative least squares problem\n",
" \n",
"2. Matrix decomposition, following [Li et al. (2020)](https://www.sciencedirect.com/science/article/pii/S0009281920300301?casa_token=sT59EIzD3QkAAAAA:bQSW0-dssOb6YRtOMb-69ctkXC0BzW5_zlalxk4EV2GFwhm4apnk73tsq4TKVc4vipPyIImq8Twg) and [Ghiorso 1983](https://www.sciencedirect.com/science/article/pii/0098300483900080). The compositional matrix will be broken down by singular value decomposition, the coefficients will then calculated."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"# import python modules\n",
"import pandas as pd\n",
"import matplotlib.pyplot as plt\n",
"from massbalance.mb_tools import MassBalance "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 1. Define elements for calculation"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We first need to define element list for mass balance calculation, special attention goes to `FeO` term, which we use `FeO`, not ``FeOt`` nor ``FeOtot``, this is consistent with the input excel files. Feel free to change the order of the elements"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"cmpnts = ['SiO2','Al2O3', 'TiO2', 'MgO', 'FeO', 'MnO', 'CaO', 'Na2O', 'K2O', 'P2O5', 'Cr2O3'] # change your desired elements for mass balance calculation"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"if you also want to integrate standard deviation on elements, this can be done manually or by the following line"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['SiO2_std',\n",
" 'Al2O3_std',\n",
" 'TiO2_std',\n",
" 'MgO_std',\n",
" 'FeO_std',\n",
" 'MnO_std',\n",
" 'CaO_std',\n",
" 'Na2O_std',\n",
" 'K2O_std',\n",
" 'P2O5_std',\n",
" 'Cr2O3_std']"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"cmpnts_std =[x + '_std' for x in cmpnts] # save columns for std\n",
"cmpnts_std"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2. Load data"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The easist way is to copy paste data in the input excel file, please also check README file for details of data prepration"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"nat_comp = pd.ExcelFile(\"input_comp.xlsx\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We load the whole excel spreadsheet to a pandas ExcelFile, to access data in your spreadsheet, you can do so by looping through ExcelFile to a dictionary:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"nat_dict = {} # create dictionary to collect compositions of different phases\n",
"nat_phases = [] # create list to save all phases in the calculation. Note bulk will be the bulk compsition, run_index will be your sample number, or rock id . etc\n",
"for sheet_name in nat_comp.sheet_names:\n",
" nat_phases.append(sheet_name)\n",
" nat_dict[sheet_name] = nat_comp.parse(sheet_name)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"``nat_phases`` stores the sheet names, ``nat_dict`` stores the data of each sheet. "
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['gl', 'ol', 'sp', 'py', 'pureFe', 'pureNa', 'bulk', 'run_index']"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"nat_phases"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Use the sheet name to access data, let's what we have in the ``gl`` phase\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
"
],
"text/plain": [
" Run_no T_C fO2\n",
"0 02As1 1320 QFM\n",
"1 01As1 1302 QFM\n",
"2 04As1 1280 QFM\n",
"3 03As1 1260 QFM\n",
"4 05As1 1240 QFM\n",
"5 06As1 1200 QFM\n",
"6 15As1 1180 QFM\n",
"7 17As1 1170 QFM\n",
"8 14As1 1160 QFM"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"nat_dict['run_index']"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3. Mass balance calculation with MCMC progagting errors"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"``MassBalance`` class does the core calculation.\n",
"To start the calculation, we need to define the ``MassBalance`` class by passing all necessary infos for calculations:\n",
"1. `input_comp` -- load the ExcelFile variable\n",
"2. `comp_col` -- load element list\n",
"3. `comp_std_col` -- load element std list (if avaiable), default is ``None``\n",
"4. `match_column` -- this is the column name that saves your expts run no., sample no., or rock id. in each spreadsheet\n",
"5. `bulk_sheet` -- sheet name of which saves bulk composition(s)\n",
"6. `index_sheet` -- sheet name stores entire infos about expts run numbers ± condition, sample numbers or rock id.\n",
"7. `normalize` -- normalize your data to 100 during calculation, default is ``True``"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"mb_cal = MassBalance(\n",
" input_comp=nat_comp,\n",
" comp_col=cmpnts,\n",
" comp_std_col=cmpnts_std,\n",
" match_column=\"Run_no\",\n",
" bulk_sheet=\"bulk\",\n",
" index_sheet=\"run_index\",\n",
" normalize=True,\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"``mb_cal`` is a variable we create for mass balance calculation\n",
"The calculation is done by calling the compute method in the `MassBalance` class as `mb_cal.compute()`\n",
"Four parameters can be tuned during computing:\n",
"1. `mc` -- define the number of MC calculations, the default is None, which will be a one time calculation\n",
"2. `exportFiles` -- we can export the results to excel file `output.xlsx` and `output_mean_median_std.xlsx`. If `mc` is given, `output_mean_median_std.xlsx`stores statistical infos for mc results\n",
"3. `batch_bulk`: define if you have different bulk for each group of phases, this is useful for layers in layered intrusions or expts with variable starting compositions for different runs. If you only have one bulk composition, can turn it to `False`\n",
"4. `method`: use `nnl` for non-negative method, `svd` for matrix decomposition method"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Below we give examples to perform 100 times MC calculation with non-negative method, export files, and we have pre-defined a batch bulk composition in the input file. More examples are given in the python scipt along with this code"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"res_dict = mb_cal.compute(mc=100, exportFiles=True, batch_bulk=True, method='nnl')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The result is saved in a python dictionary, with each key responses to the expts run no., sample no, or rock id you defined in the index sheet\n",
"Let's take a look the results of first experimental run `02As1`"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"