gebpy 1.1.3__py3-none-any.whl

modules/gui_elements.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python
+# -*-coding: utf-8 -*-
+# ----------------------
+# gui_elements.py
+# Maximilian Beeskow
+# 22.03.2023
+# ----------------------
+#
+## MODULES
+import tkinter as tk
+from tkinter import ttk
+#
+## CLASSES
+class SimpleElements:
+    #
+    def __init__(self, parent, row_id, column_id, fg, bg, n_rows=1, n_columns=1):
+        self.parent = parent
+        self.row_id = row_id
+        self.column_id = column_id
+        self.n_rows = n_rows
+        self.n_columns = n_columns
+        self.fg = fg
+        self.bg = bg
+    #
+    def create_frame(self, relief=tk.FLAT):
+        frm = tk.Frame(self.parent, bg=self.bg, borderwidth=0, highlightthickness=0, relief=relief)
+        frm.grid(row=self.row_id, column=self.column_id, rowspan=self.n_rows, columnspan=self.n_columns, sticky="nesw")
+        #
+        return frm
+    #
+    def create_label(self, text, font_option=None, relief=tk.GROOVE, sticky_option="nesw", anchor_option=tk.CENTER):
+        if font_option != None:
+            lbl = tk.Label(self.parent, text=text, relief=relief, bg=self.bg, fg=self.fg, font=(font_option),
+                           anchor=anchor_option)
+        else:
+            lbl = tk.Label(self.parent, text=text, relief=relief, bg=self.bg, fg=self.fg, font=(font_option),
+                           anchor=anchor_option)
+        #
+        lbl.grid(row=self.row_id, column=self.column_id, rowspan=self.n_rows, columnspan=self.n_columns,
+                 sticky=sticky_option)
+        #
+        return lbl
+    #
+    def create_option_menu(self, var_opt, var_opt_set, opt_list, active_bg="#F9DED7", command=None):
+        var_opt.set(var_opt_set)
+        if command == None:
+            opt_menu = tk.OptionMenu(self.parent, var_opt, *opt_list)
+        else:
+            opt_menu = tk.OptionMenu(self.parent, var_opt, *opt_list, command=command)
+        opt_menu.config(bg=self.bg)
+        opt_menu.grid(row=self.row_id, column=self.column_id, rowspan=self.n_rows, columnspan=self.n_columns,
+                      sticky="nesw")
+        opt_menu.config(bg=self.bg, fg=self.fg, activebackground=active_bg, highlightthickness=0)
+        opt_menu["menu"].config(bg=self.bg, fg=self.fg, activebackground=active_bg)
+        #
+        return opt_menu
+    #
+    def create_entry(self, var_entr, var_entr_set=None, width=None, command=None):
+        if var_entr_set != None:
+            var_entr.set(var_entr_set)
+        if width == None:
+            entry = tk.Entry(self.parent, textvariable=var_entr, background=self.bg, fg=self.fg, highlightthickness=0)
+        else:
+            entry = tk.Entry(self.parent, textvariable=var_entr, background=self.bg, fg=self.fg, highlightthickness=0,
+                             width=width)
+        entry.grid(row=self.row_id, column=self.column_id, rowspan=self.n_rows, columnspan=self.n_columns,
+                   sticky="nesw")
+        if command != None:
+            entry.bind("<Return>", command)
+        #
+        return entry
+    #
+    def create_radiobutton(self, var_rb, value_rb, color_bg, relief=tk.FLAT, command=None, text="", anchor_option=tk.W):
+        if command == None:
+            rb = tk.Radiobutton(self.parent, text=text, variable=var_rb, value=value_rb, bg=self.bg, fg=self.fg,
+                                activebackground=self.bg, highlightthickness=0, relief=relief, selectcolor=self.bg,
+                                anchor=anchor_option)
+        else:
+            rb = tk.Radiobutton(self.parent, text=text, variable=var_rb, value=value_rb, bg=self.bg, fg=self.fg,
+                                activebackground=self.bg, highlightthickness=0, relief=relief, selectcolor=self.bg,
+                                anchor=anchor_option, command=command)
+        #
+        rb.grid(row=self.row_id, column=self.column_id, rowspan=self.n_rows, columnspan=self.n_columns, sticky="nesw")
+        #
+        return  rb
+    #
+    def create_button(self, text, command=None):
+        if command == None:
+            btn = tk.Button(
+                self.parent, text=text, bg=self.bg, fg=self.fg, activebackground="#F9DED7", highlightbackground=self.bg,
+                highlightthickness=0)
+        else:
+            btn = tk.Button(
+                self.parent, text=text, bg=self.bg, fg=self.fg, activebackground="#F9DED7", highlightbackground=self.bg,
+                highlightthickness=0, command=command)
+        #
+        btn.grid(row=self.row_id, column=self.column_id, rowspan=self.n_rows, columnspan=self.n_columns, sticky="nesw")
+        #
+        return btn
+    #
+    def create_checkbox(self, text, var_cb, command=None):
+        if command == None:
+            cb = tk.Checkbutton(self.parent, text=text, variable=var_cb, bg=self.bg, fg=self.fg,
+                                activebackground="#F9DED7", highlightbackground=self.bg, highlightthickness=0)
+        else:
+            cb = tk.Checkbutton(self.parent, text=text, variable=var_cb, bg=self.bg, fg=self.fg,
+                                activebackground="#F9DED7", highlightbackground=self.bg, highlightthickness=0,
+                                command=command)
+        cb.grid(row=self.row_id, column=self.column_id, rowspan=self.n_rows, columnspan=self.n_columns, sticky="nesw")
+        #
+        return cb
+    #
+    def create_treeview(self, n_categories=2, text_1="Ratio", text_2="\u03BC", width_1 = 90, width_2 = 90, text_n=[],
+                        width_n=[], individual=False):
+        ttk.Style().configure("Treeview", background=self.bg, foreground=self.fg, fieldbackground=self.bg)
+        style = ttk.Style()
+        style.configure("Treeview.Heading", background=self.bg, pressed_color=self.bg,
+                        highlight_color=self.bg, foreground=self.fg)
+        #
+        if n_categories == 2 and individual == False:
+            columns = ("#1", "#2")
+            treeview = ttk.Treeview(self.parent, columns=columns, show="headings")
+            treeview.heading("#1", text=text_1)
+            treeview.column("#1", minwidth=0, width=width_1, stretch=tk.NO, anchor=tk.CENTER)
+            treeview.heading("#2", text=text_2)
+            treeview.column("#2", minwidth=0, width=width_2, stretch=tk.YES, anchor=tk.CENTER)
+            treeview.grid(row=self.row_id, column=self.column_id, rowspan=self.n_rows, columnspan=self.n_columns,
+                          sticky="nesw")
+        #
+        if n_categories > 1 and individual == True:
+            columns = []
+            for n in range(n_categories):
+                var_i = "#" + str(n + 1)
+                columns.append(var_i)
+            #
+            treeview = ttk.Treeview(self.parent, columns=columns, show="headings")
+            #
+            for index, element in enumerate(columns):
+                treeview.heading(element, text=text_n[index])
+                treeview.column(element, minwidth=0, width=width_n[index], stretch=tk.NO, anchor=tk.CENTER)
+            #
+            treeview.grid(row=self.row_id, column=self.column_id, rowspan=self.n_rows, columnspan=self.n_columns,
+                          sticky="nesw")
+        #
+        return treeview

modules/halides.py

@@ -0,0 +1,485 @@
+#!/usr/bin/env python
+# -*-coding: utf-8 -*-
+
+# -----------------------------------------------
+
+# Name:		halides.py
+# Author:	Maximilian A. Beeskow
+# Version:	1.0
+# Date:		20.09.2022
+
+# -----------------------------------------------
+
+# MODULES
+import numpy as np
+import random as rd
+from modules.chemistry import PeriodicSystem, DataProcessing
+from modules.minerals import CrystalPhysics
+from modules.geophysics import BoreholeGeophysics as bg
+from modules.geophysics import WellLog as wg
+from modules.geochemistry import MineralChemistry
+
+# Halogenes
+class Halides:
+    """ Class that generates geophysical and geochemical data of halogene minerals"""
+    #
+    def __init__(self, traces_list=[], impurity="pure", dict=False, mineral=None):
+        self.traces_list = traces_list
+        self.impurity = impurity
+        self.dict = dict
+        self.mineral = mineral
+    #
+    def generate_dataset(self, number):
+        dataset = {}
+        #
+        for index in range(number):
+            if self.mineral == "Halite":
+                data_mineral = self.create_halite()
+            elif self.mineral == "Fluorite":
+                data_mineral = self.create_fluorite()
+            elif self.mineral == "Sylvite":
+                data_mineral = self.create_sylvite()
+            elif self.mineral == "Carnallite":
+                data_mineral = self.create_carnallite()
+            #
+            for key, value in data_mineral.items():
+                if key in ["M", "rho", "rho_e", "V", "vP", "vS", "vP/vS", "K", "G", "E", "nu", "GR", "PE", "U",
+                           "p"]:
+                    if key not in dataset:
+                        dataset[key] = [value]
+                    else:
+                        dataset[key].append(value)
+                elif key in ["mineral", "state", "trace elements"] and key not in dataset:
+                    dataset[key] = value
+                elif key in ["chemistry"]:
+                    if key not in dataset:
+                        dataset[key] = {}
+                        for key_2, value_2 in value.items():
+                            dataset[key][key_2] = [value_2]
+                    else:
+                        for key_2, value_2 in value.items():
+                            dataset[key][key_2].append(value_2)
+        #
+        return dataset
+    #
+    def create_halite(self):    # NaCl
+        # Major elements
+        sodium = PeriodicSystem(name="Na").get_data()
+        chlorine = PeriodicSystem(name="Cl").get_data()
+        majors_name = ["Na", "Cl"]
+        majors_data = np.array([["Na", sodium[1], 1, sodium[2]], ["Cl", chlorine[1], 1, chlorine[2]]], dtype=object)
+        # Minor elements
+        traces_data = []
+        if len(self.traces_list) > 0:
+            self.impurity = "impure"
+        if self.impurity == "random":
+            self.traces_list = []
+            minors = ["I", "Br", "Fe", "O"]
+            n = rd.randint(1, len(minors))
+            while len(self.traces_list) < n:
+                selection = rd.choice(minors)
+                if selection not in self.traces_list and selection not in majors_name:
+                    self.traces_list.append(selection)
+                else:
+                    continue
+        traces = [PeriodicSystem(name=i).get_data() for i in self.traces_list]
+        x_traces = [round(rd.uniform(0., 0.001), 6) for i in range(len(self.traces_list))]
+        for i in range(len(self.traces_list)):
+            traces_data.append([str(self.traces_list[i]), int(traces[i][1]), float(x_traces[i])])
+        if len(traces_data) > 0:
+            traces_data = np.array(traces_data, dtype=object)
+            traces_data = traces_data[traces_data[:, 1].argsort()]
+        #
+        data = []
+        #
+        mineral = "Hl"
+        #
+        # Molar mass
+        molar_mass_pure = sodium[2] + chlorine[2]
+        molar_mass, amounts = MineralChemistry(w_traces=traces_data, molar_mass_pure=molar_mass_pure,
+                                               majors=majors_data).calculate_molar_mass()
+        element = [PeriodicSystem(name=amounts[i][0]).get_data() for i in range(len(amounts))]
+        # Density
+        dataV = CrystalPhysics([[5.6404], [], "cubic"])
+        V = dataV.calculate_volume()
+        dataRho = CrystalPhysics([molar_mass, 4, V])
+        rho = dataRho.calculate_bulk_density()
+        rho_e = wg(amounts=amounts, elements=element, rho_b=rho).calculate_electron_density()
+        # Bulk modulus
+        K = 23*10**9
+        # Shear modulus
+        G = 14.33*10**9
+        # Young's modulus
+        E = (9*K*G)/(3*K + G)
+        # Poisson's ratio
+        nu = (3*K - 2*G)/(2*(3*K + G))
+        # vP/vS
+        vPvS = ((K + 4/3*G)/G)**0.5
+        # P-wave velocity
+        vP = ((K + 4/3*G)/rho)**0.5
+        # S-wave velocity
+        vS = (G/rho)**0.5
+        # Gamma ray
+        gamma_ray = wg(amounts=amounts, elements=element).calculate_gr()
+        # Photoelectricity
+        pe = wg(amounts=amounts, elements=element).calculate_pe()
+        U = pe*rho_e*10**(-3)
+        # Electrical resistivity
+        p = 5*10**8
+        #
+        if self.dict == False:
+            data.append(mineral)
+            data.append(round(molar_mass, 3))
+            data.append(round(rho, 2))
+            data.append([round(K*10**(-9), 2), round(G*10**(-9), 2), round(E*10**(-9), 2), round(nu, 4)])
+            data.append([round(vP, 2), round(vS, 2), round(vPvS, 2)])
+            data.append([round(gamma_ray, 2), round(pe, 2), round(U, 2), p])
+            data.append(amounts)
+            #
+            return data
+        else:
+            #
+            results = {}
+            results["mineral"] = mineral
+            results["M"] = molar_mass
+            element_list = np.array(amounts)[:, 0]
+            results["chemistry"] = {}
+            for index, element in enumerate(element_list, start=0):
+                results["chemistry"][element] = amounts[index][2]
+            results["rho"] = round(rho, 4)
+            results["rho_e"] = round(rho_e, 4)
+            results["V"] = round(V, 4)
+            results["vP"] = round(vP, 4)
+            results["vS"] = round(vS, 4)
+            results["vP/vS"] = round(vPvS, 4)
+            results["G"] = round(G*10**(-9), 4)
+            results["K"] = round(K*10**(-9), 4)
+            results["E"] = round(E*10**(-9), 4)
+            results["nu"] = round(nu, 4)
+            results["GR"] = round(gamma_ray, 4)
+            results["PE"] = round(pe, 4)
+            results["U"] = round(U, 4)
+            if p != None:
+                results["p"] = round(p, 4)
+            else:
+                results["p"] = p
+            #
+            return results
+    #
+    def create_sylvite(self):  # KCl
+        # Major elements
+        potassium = PeriodicSystem(name="K").get_data()
+        chlorine = PeriodicSystem(name="Cl").get_data()
+        majors_name = ["K", "Cl"]
+        majors_data = np.array([["K", potassium[1], 1, potassium[2]], ["Cl", chlorine[1], 1, chlorine[2]]], dtype=object)
+        # Minor elements
+        traces_data = []
+        if len(self.traces_list) > 0:
+            self.impurity = "impure"
+        if self.impurity == "random":
+            self.traces_list = []
+            minors = ["Br", "C", "O"]
+            n = rd.randint(1, len(minors))
+            while len(self.traces_list) < n:
+                selection = rd.choice(minors)
+                if selection not in self.traces_list and selection not in majors_name:
+                    self.traces_list.append(selection)
+                else:
+                    continue
+        traces = [PeriodicSystem(name=i).get_data() for i in self.traces_list]
+        x_traces = [round(rd.uniform(0., 0.001), 6) for i in range(len(self.traces_list))]
+        for i in range(len(self.traces_list)):
+            traces_data.append([str(self.traces_list[i]), int(traces[i][1]), float(x_traces[i])])
+        if len(traces_data) > 0:
+            traces_data = np.array(traces_data, dtype=object)
+            traces_data = traces_data[traces_data[:, 1].argsort()]
+        #
+        data = []
+        #
+        mineral = "Syl"
+        #
+        # Molar mass
+        molar_mass_pure = potassium[2] + chlorine[2]
+        molar_mass, amounts = MineralChemistry(w_traces=traces_data, molar_mass_pure=molar_mass_pure,
+                                               majors=majors_data).calculate_molar_mass()
+        element = [PeriodicSystem(name=amounts[i][0]).get_data() for i in range(len(amounts))]
+        # Density
+        dataV = CrystalPhysics([[6.2931], [], "cubic"])
+        V = dataV.calculate_volume()
+        dataRho = CrystalPhysics([molar_mass, 4, V])
+        rho = dataRho.calculate_bulk_density()
+        rho_e = wg(amounts=amounts, elements=element, rho_b=rho).calculate_electron_density()
+        # Bulk modulus
+        K = 16*10**9
+        # Shear modulus
+        G = 9*10**9
+        # Young's modulus
+        E = (9*K*G)/(3*K + G)
+        # Poisson's ratio
+        nu = (3*K - 2*G)/(2*(3*K + G))
+        # vP/vS
+        vPvS = ((K + 4/3*G)/G)**0.5
+        # P-wave velocity
+        vP = ((K + 4/3*G)/rho)**0.5
+        # S-wave velocity
+        vS = (G/rho)**0.5
+        # Gamma ray
+        gamma_ray = wg(amounts=amounts, elements=element).calculate_gr()
+        # Photoelectricity
+        pe = wg(amounts=amounts, elements=element).calculate_pe()
+        U = pe*rho_e*10**(-3)
+        # Electrical resistivity
+        p = None
+        #
+        if self.dict == False:
+            data.append(mineral)
+            data.append(round(molar_mass, 3))
+            data.append(round(rho, 2))
+            data.append([round(K*10**(-9), 2), round(G*10**(-9), 2), round(E*10**(-9), 2), round(nu, 4)])
+            data.append([round(vP, 2), round(vS, 2), round(vPvS, 2)])
+            data.append([round(gamma_ray, 2), round(pe, 2), round(U, 2), p])
+            data.append(amounts)
+            #
+            return data
+        else:
+            #
+            results = {}
+            results["mineral"] = mineral
+            results["M"] = molar_mass
+            element_list = np.array(amounts)[:, 0]
+            results["chemistry"] = {}
+            for index, element in enumerate(element_list, start=0):
+                results["chemistry"][element] = amounts[index][2]
+            results["rho"] = round(rho, 4)
+            results["rho_e"] = round(rho_e, 4)
+            results["V"] = round(V, 4)
+            results["vP"] = round(vP, 4)
+            results["vS"] = round(vS, 4)
+            results["vP/vS"] = round(vPvS, 4)
+            results["G"] = round(G*10**(-9), 4)
+            results["K"] = round(K*10**(-9), 4)
+            results["E"] = round(E*10**(-9), 4)
+            results["nu"] = round(nu, 4)
+            results["GR"] = round(gamma_ray, 4)
+            results["PE"] = round(pe, 4)
+            results["U"] = round(U, 4)
+            if p != None:
+                results["p"] = round(p, 4)
+            else:
+                results["p"] = p
+            #
+            return results
+    #
+    def create_fluorite(self):   # CaF2
+        # Major elements
+        flourine = PeriodicSystem(name="F").get_data()
+        calcium = PeriodicSystem(name="Ca").get_data()
+        majors_name = ["F", "Ca"]
+        majors_data = np.array([["F", flourine[1], 2, flourine[2]], ["Ca", calcium[1], 1, calcium[2]]], dtype=object)
+        # Minor elements
+        traces_data = []
+        if len(self.traces_list) > 0:
+            self.impurity = "impure"
+        if self.impurity == "random":
+            self.traces_list = []
+            minors = ["Y", "Ce", "Si", "Al", "Fe", "Mg", "Eu", "Sm", "O", "C", "Cl"]
+            n = rd.randint(1, len(minors))
+            while len(self.traces_list) < n:
+                selection = rd.choice(minors)
+                if selection not in self.traces_list and selection not in majors_name:
+                    self.traces_list.append(selection)
+                else:
+                    continue
+        traces = [PeriodicSystem(name=i).get_data() for i in self.traces_list]
+        x_traces = [round(rd.uniform(0., 0.001), 6) for i in range(len(self.traces_list))]
+        for i in range(len(self.traces_list)):
+            traces_data.append([str(self.traces_list[i]), int(traces[i][1]), float(x_traces[i])])
+        if len(traces_data) > 0:
+            traces_data = np.array(traces_data, dtype=object)
+            traces_data = traces_data[traces_data[:, 1].argsort()]
+        #
+        data = []
+        #
+        mineral = "Fl"
+        #
+        # Molar mass
+        molar_mass_pure = calcium[2] + 2*flourine[2]
+        molar_mass, amounts = MineralChemistry(w_traces=traces_data, molar_mass_pure=molar_mass_pure,
+                                               majors=majors_data).calculate_molar_mass()
+        element = [PeriodicSystem(name=amounts[i][0]).get_data() for i in range(len(amounts))]
+        # Density
+        dataV = CrystalPhysics([[5.4626], [], "cubic"])
+        V = dataV.calculate_volume()
+        dataRho = CrystalPhysics([molar_mass, 4, V])
+        rho = dataRho.calculate_bulk_density()
+        rho_e = wg(amounts=amounts, elements=element, rho_b=rho).calculate_electron_density()
+        # Bulk modulus
+        K = 77*10**9
+        # Shear modulus
+        G = 38*10**9
+        # Young's modulus
+        E = (9*K*G)/(3*K + G)
+        # Poisson's ratio
+        nu = (3*K - 2*G)/(2*(3*K + G))
+        # vP/vS
+        vPvS = ((K + 4/3*G)/G)**0.5
+        # P-wave velocity
+        vP = ((K + 4/3*G)/rho)**0.5
+        # S-wave velocity
+        vS = (G/rho)**0.5
+        # Gamma ray
+        gamma_ray = wg(amounts=amounts, elements=element).calculate_gr()
+        # Photoelectricity
+        pe = wg(amounts=amounts, elements=element).calculate_pe()
+        U = pe*rho_e*10**(-3)
+        # Electrical resistivity
+        p = None
+        #
+        if self.dict == False:
+            data.append(mineral)
+            data.append(round(molar_mass, 3))
+            data.append(round(rho, 2))
+            data.append([round(K*10**(-9), 2), round(G*10**(-9), 2), round(E*10**(-9), 2), round(nu, 4)])
+            data.append([round(vP, 2), round(vS, 2), round(vPvS, 2)])
+            data.append([round(gamma_ray, 2), round(pe, 2), round(U, 2), p])
+            data.append(amounts)
+            #
+            return data
+        else:
+            #
+            results = {}
+            results["mineral"] = mineral
+            results["M"] = molar_mass
+            element_list = np.array(amounts)[:, 0]
+            results["chemistry"] = {}
+            for index, element in enumerate(element_list, start=0):
+                results["chemistry"][element] = amounts[index][2]
+            results["rho"] = round(rho, 4)
+            results["rho_e"] = round(rho_e, 4)
+            results["V"] = round(V, 4)
+            results["vP"] = round(vP, 4)
+            results["vS"] = round(vS, 4)
+            results["vP/vS"] = round(vPvS, 4)
+            results["G"] = round(G*10**(-9), 4)
+            results["K"] = round(K*10**(-9), 4)
+            results["E"] = round(E*10**(-9), 4)
+            results["nu"] = round(nu, 4)
+            results["GR"] = round(gamma_ray, 4)
+            results["PE"] = round(pe, 4)
+            results["U"] = round(U, 4)
+            if p != None:
+                results["p"] = round(p, 4)
+            else:
+                results["p"] = p
+            #
+            return results
+    #
+    def create_carnallite(self):   # K Mg Cl3 * 6(H2O)
+        # Major elements
+        hydrogen = PeriodicSystem(name="H").get_data()
+        oxygen = PeriodicSystem(name="O").get_data()
+        magnesium = PeriodicSystem(name="Mg").get_data()
+        chlorine = PeriodicSystem(name="Cl").get_data()
+        potassium = PeriodicSystem(name="K").get_data()
+        majors_name = ["H", "O", "Mg", "Cl", "K"]
+        majors_data = np.array(
+            [["H", hydrogen[1], 12, hydrogen[2]], ["O", oxygen[1], 6, oxygen[2]],
+             ["Mg", magnesium[1], 1, magnesium[2]], ["Cl", chlorine[1], 3, chlorine[2]],
+             ["K", potassium[1], 1, potassium[2]]], dtype=object)
+        # Minor elements
+        traces_data = []
+        if len(self.traces_list) > 0:
+            self.impurity = "impure"
+        if self.impurity == "random":
+            self.traces_list = []
+            minors = ["Br" ,"Rb", "Cs", "Tl", "Fe"]
+            n = rd.randint(1, len(minors))
+            while len(self.traces_list) < n:
+                selection = rd.choice(minors)
+                if selection not in self.traces_list and selection not in majors_name:
+                    self.traces_list.append(selection)
+                else:
+                    continue
+        traces = [PeriodicSystem(name=i).get_data() for i in self.traces_list]
+        x_traces = [round(rd.uniform(0., 0.001), 6) for i in range(len(self.traces_list))]
+        for i in range(len(self.traces_list)):
+            traces_data.append([str(self.traces_list[i]), int(traces[i][1]), float(x_traces[i])])
+        if len(traces_data) > 0:
+            traces_data = np.array(traces_data, dtype=object)
+            traces_data = traces_data[traces_data[:, 1].argsort()]
+        #
+        data = []
+        #
+        mineral = "Car"
+        #
+        # Molar mass
+        molar_mass_pure = potassium[2] + magnesium[2] + 3*chlorine[2] + 6*(2*hydrogen[2] + oxygen[2])
+        molar_mass, amounts = MineralChemistry(w_traces=traces_data, molar_mass_pure=molar_mass_pure,
+                                               majors=majors_data).calculate_molar_mass()
+        element = [PeriodicSystem(name=amounts[i][0]).get_data() for i in range(len(amounts))]
+        # Density
+        dataV = CrystalPhysics([[9.56, 16.05, 22.56], [], "orthorhombic"])
+        V = dataV.calculate_volume()
+        dataRho = CrystalPhysics([molar_mass, 12, V])
+        rho = dataRho.calculate_bulk_density()
+        rho_e = wg(amounts=amounts, elements=element, rho_b=rho).calculate_electron_density()
+        # Bulk modulus
+        K = 31*10**9    # estimated
+        # Shear modulus
+        G = 16*10**9    # estimated
+        # Young's modulus
+        E = (9*K*G)/(3*K + G)
+        # Poisson's ratio
+        nu = (3*K - 2*G)/(2*(3*K + G))
+        # vP/vS
+        vPvS = ((K + 4/3*G)/G)**0.5
+        # P-wave velocity
+        vP = ((K + 4/3*G)/rho)**0.5
+        # S-wave velocity
+        vS = (G/rho)**0.5
+        # Gamma ray
+        gamma_ray = wg(amounts=amounts, elements=element).calculate_gr()
+        # Photoelectricity
+        pe = wg(amounts=amounts, elements=element).calculate_pe()
+        U = pe*rho_e*10**(-3)
+        # Electrical resistivity
+        p = None
+        #
+        if self.dict == False:
+            data.append(mineral)
+            data.append(round(molar_mass, 3))
+            data.append(round(rho, 2))
+            data.append([round(K*10**(-9), 2), round(G*10**(-9), 2), round(E*10**(-9), 2), round(nu, 4)])
+            data.append([round(vP, 2), round(vS, 2), round(vPvS, 2)])
+            data.append([round(gamma_ray, 2), round(pe, 2), round(U, 2), p])
+            data.append(amounts)
+            #
+            return data
+        else:
+            #
+            results = {}
+            results["mineral"] = mineral
+            results["M"] = molar_mass
+            element_list = np.array(amounts)[:, 0]
+            results["chemistry"] = {}
+            for index, element in enumerate(element_list, start=0):
+                results["chemistry"][element] = amounts[index][2]
+            results["rho"] = round(rho, 4)
+            results["rho_e"] = round(rho_e, 4)
+            results["V"] = round(V, 4)
+            results["vP"] = round(vP, 4)
+            results["vS"] = round(vS, 4)
+            results["vP/vS"] = round(vPvS, 4)
+            results["G"] = round(G*10**(-9), 4)
+            results["K"] = round(K*10**(-9), 4)
+            results["E"] = round(E*10**(-9), 4)
+            results["nu"] = round(nu, 4)
+            results["GR"] = round(gamma_ray, 4)
+            results["PE"] = round(pe, 4)
+            results["U"] = round(U, 4)
+            if p != None:
+                results["p"] = round(p, 4)
+            else:
+                results["p"] = p
+            #
+            return results