pyrolite 0.0.14__zip

ProgramData/Anaconda3_64/Lib/site-packages/pyrolite/mineral/sites.py

@@ -0,0 +1,134 @@
+from .ions import __default_charges__
+import logging
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+logger = logging.getLogger(__name__)
+
+
+class Site(object):
+    """
+    Class for specifying mineral sites, including coordination information.
+
+    Will be used for partitioning and affinity calculations for estimating mineral
+    site chemistry.
+    """
+
+    def __init__(self, name=None, coordination=0, affinities={}):
+        if name is None:
+            name = self.__class__.__name__
+        self.name = name
+        self.coordination = coordination
+        self.affinities = affinities
+        self.occupancy = None
+        self.anionic = False
+        self.cationic = False
+        self.oxygen = False
+
+    def __str__(self):
+        if self.coordination:
+            return """[{}]{}""".format(self.name, self.coordination)
+        else:
+            return """{}""".format(self.name)
+
+    def __repr__(self):
+        if self.coordination:
+            return """{}("{}", {})""".format(
+                self.__class__.__name__, self.name, self.coordination
+            )
+        else:
+            return """{}("{}")""".format(self.__class__.__name__, self.name)
+
+    def __eq__(self, other):
+        """Check for equality between two sites."""
+        # check that the duck quacks/is a Site
+        pretest = (
+            hasattr(other, "name")
+            & hasattr(other, "coordination")
+            & hasattr(other, "affinities")
+        )
+        if pretest:
+            # Check for attribute equalilty
+            conds = (
+                (self.__class__.__name__ == other.__class__.__name__)
+                & (self.name == other.name)
+                & (self.coordination == other.coordination)
+                & (self.affinities == other.affinities)
+            )
+
+            return conds
+        else:
+            return False
+
+    def __hash__(self):
+        return hash(self.__repr__().encode("UTF-8"))
+
+
+class MX(Site):
+    """
+    Octahedrally coordinated M site.
+    """
+
+    def __init__(self, name="M", coordination=8, *args, **kwargs):
+        super().__init__(name, coordination, *args, **kwargs)
+        self.cationic = True
+
+
+class TX(Site):
+    """
+    Tetrahedrally coordinated T site.
+    """
+
+    def __init__(
+        self,
+        name="T",
+        coordination=4,
+        affinities={"Si{4+}": 0, "Al{3+}": 1, "Fe{3+}": 2},
+        *args,
+        **kwargs
+    ):
+        super().__init__(name, coordination, *args, **kwargs)
+        self.cationic = True
+        self.affinities = affinities
+
+
+class IX(Site):
+    """
+    Dodecahedrally coordinated I site.
+    """
+
+    def __init__(self, name="I", coordination=12, *args, **kwargs):
+        super().__init__(name, coordination, *args, **kwargs)
+        self.cationic = True
+
+
+class VX(Site):
+    """
+    Vacancy site.
+    """
+
+    def __init__(self, name="V", coordination=0, *args, **kwargs):
+        super().__init__(name, coordination, *args, **kwargs)
+        self.cationic = True
+
+
+class OX(Site):
+    """
+    Oxygen site.
+    """
+
+    def __init__(
+        self, name="O", coordination=0, affinities={"O{2-}": 0}, *args, **kwargs
+    ):
+        super().__init__(name, coordination, *args, **kwargs)
+        self.oxygen = True
+        self.affinities = affinities
+
+
+class AX(Site):
+    """
+    Anion site.
+    """
+
+    def __init__(self, name="A", coordination=0, *args, **kwargs):
+        super().__init__(name, coordination, *args, **kwargs)
+        self.anionic = True

ProgramData/Anaconda3_64/Lib/site-packages/pyrolite/norm.py

@@ -0,0 +1,224 @@
+import os, sys
+from pathlib import Path
+import platform
+import pandas as pd
+import numpy as np
+from .comp import *
+from .util.pd import to_frame, to_numeric
+import logging
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+logger = logging.getLogger(__name__)
+
+RELMASSS_UNITS = {
+    "%": 10 ** -2,
+    "pct": 10 ** -2,
+    "wt%": 10 ** -2,
+    "ppm": 10 ** -6,
+    "ppb": 10 ** -9,
+    "ppt": 10 ** -12,
+    "ppq": 10 ** -15,
+}
+
+
+def scale_multiplier(in_unit, target_unit="ppm"):
+    """
+    Provides the scale difference between to mass units.
+
+    Todo: implement different inputs - string, list, pandas series
+
+    Parameters
+    ----------
+    in_unit: current units
+        Units to be converted from
+    target_unit: target mass unit, ppm
+        Units to scale to.
+    """
+    in_unit = str(in_unit).lower()
+    target_unit = str(target_unit).lower()
+    if (
+        not pd.isna(in_unit)
+        and (in_unit in RELMASSS_UNITS.keys())
+        and (target_unit in RELMASSS_UNITS.keys())
+    ):
+        scale = RELMASSS_UNITS[in_unit] / RELMASSS_UNITS[target_unit]
+    else:
+        unkn = [i for i in [in_unit, target_unit] if i not in RELMASSS_UNITS]
+        logger.debug("Units not known: {}. Defaulting to unity.".format(unkn))
+        scale = 1.0
+    return scale
+
+
+class RefComp:
+    """
+    Reference compositional model object, principally used for normalisation.
+    """
+
+    def __init__(self, filename, **kwargs):
+        self.data = pd.read_csv(filename, **kwargs)
+        self.data = self.data.set_index("var")
+        self.original_data = self.data.copy(deep=True)  # preserve unaltered record
+        # self.add_oxides()
+        self.collect_vars()
+        self.set_units()
+        # self.aggregate_oxides() yet to be implemented
+
+    def aggregate_oxides(self, form="oxide"):
+        """
+        Compositional models typically include elements in both oxide and
+        elemental form, typically divided into 'majors' and 'traces'.
+
+        For the purposes of normalisation - we need
+            i) to be able to access values of the form found in the dataset,
+            ii) for original values and uncertanties to be preserved, and
+            iii) for closure to be preserved.
+
+        There are multiple ways to acheive this - one is to create linked
+        element-oxide tables, and another is to force working in one format
+        (i.e. Al2O3 (wt%) --> Al (ppm))
+        """
+        # identify cations to be aggregated
+
+        # for cation in cations:
+        #    scale function
+        #    aggregate_cation(df: pd.DataFrame, cation, form=form, unit_scale=None)
+        raise NotImplementedError("This issue has yet to be addressed.")
+
+    def collect_vars(
+        self,
+        headers=["Reservoir", "Reference", "ModelName", "ModelType"],
+        floatvars=["value", "unc_2sigma", "constraint_value"],
+    ):
+        self.vars = [
+            i
+            for i in self.data.index
+            if (not pd.isna(self.data.loc[i, "value"])) and (i not in headers)
+        ]
+        self.data.loc[self.vars, floatvars] = self.data.loc[self.vars, floatvars].apply(
+            to_numeric
+        )
+
+    def set_units(self, to="ppm"):
+        v = self.vars
+        self.data.loc[v, "scale"] = self.data.loc[v, "units"].apply(
+            scale_multiplier, target_unit=to
+        )
+        self.data.loc[v, "units"] = to
+        self.data.loc[v, "value"] = self.data.loc[v, "value"] * self.data.loc[
+            v, "scale"
+        ].astype(np.float)
+
+    def normalize(self, df, aux_cols=["LOD", "2SE"]):
+        """
+        Normalize the values within a dataframe to the refererence composition.
+        Here we create indexes for normalisation of values and any auxilary
+        values (e.g. uncertainty).
+
+        ## TODO: Implement uncertainty propagation
+        """
+        dfc = to_frame(df.copy(deep=True))
+
+        cols = [c for c in dfc.columns if c in self.vars]
+        _cols = set(cols)
+        if len(cols) != len(_cols):
+            msg = "Duplicated columns in dataframe."
+            logger.warn(msg)
+        cols = list(_cols)
+
+        divisor = self.data.loc[cols, "value"].values
+
+        dfc.loc[:, cols] = np.divide(dfc.loc[:, cols].values, divisor)
+        return dfc
+
+    def denormalize(self, df, aux_cols=["LOD", "2SE"]):
+        """
+        Unnormalize the values within a dataframe back to true composition.
+        """
+        dfc = to_frame(df.copy(deep=True))
+
+        cols = [c for c in dfc.columns if c in self.vars]
+        _cols = set(cols)
+        if len(cols) != len(_cols):
+            msg = "Duplicated columns in dataframe."
+            logger.warn(msg)
+        cols = list(_cols)
+
+        multiplier = self.data.loc[cols, "value"].values
+
+        dfc.loc[:, cols] *= multiplier
+        return dfc
+
+    def ratio(self, ratio):
+        """Calculates an elemental ratio."""
+        try:
+            assert "/" in ratio
+            num, den = ratio.split("/")
+            return self.data.loc[num, "value"] / self.data.loc[den, "value"]
+        except:
+            return np.nan
+
+    def __getattr__(self, var):
+        """
+        Allow access to model values via attribute e.g. Model.Si
+        """
+        if not isinstance(var, str):
+            var = str(var)
+        if var in self.data.index:
+            return self.data.loc[var, "value"]
+        else:
+            return np.nan
+
+    def __getitem__(self, vars):
+        """
+        Allow access to model values via [] indexing e.g. Model['Si', 'Cr'].
+        Currently not implemented for ratios.
+        """
+        if (
+            isinstance(vars, list)
+            or isinstance(vars, pd.Index)
+            or isinstance(vars, np.ndarray)
+        ):
+            vars = [v if isinstance(v, str) else str(v) for v in vars]
+        elif not isinstance(vars, str):
+            vars = str(vars)
+        return self.data.loc[vars, ["value", "unc_2sigma", "units"]]
+
+    def __repr__(self):
+        return "Model of " + self.Reservoir + " (" + self.Reference + ")"
+
+
+def ReferenceCompositions(directory=None, formats=["csv"], **kwargs):
+    """
+    Build all reference models in a given directory.
+
+    Here we use either the input directory, or the default data directory
+    within this module.
+
+    Parameters
+    ----------
+    directory: file directory, None
+        Location of reference data files.
+    formats: reference data formats, csv
+        List of potential data formats to draw from.
+        Currently only csv will work.
+    """
+    if platform.system() == "Windows":
+        kwargs["encoding"] = kwargs.get("encoding", None) or "cp1252"
+    else:
+        kwargs["encoding"] = kwargs.get("encoding", None) or "cp1252"
+
+    curr_dir = os.path.realpath(__file__)
+    module_dir = Path(sys.modules["pyrolite"].__file__).parent
+    directory = directory or (Path(module_dir) / "data" / "refcomp").resolve()
+
+    assert directory.exists() and directory.is_dir()
+
+    files = []
+    for fmt in formats:
+        files.extend(directory.glob("./*." + fmt))
+
+    comps = {}
+    for f in files:
+        r = RefComp(f, **kwargs)
+        comps[r.ModelName] = r
+    return comps

ProgramData/Anaconda3_64/Lib/site-packages/pyrolite/normalisation.py

@@ -0,0 +1,204 @@
+import os, sys
+from pathlib import Path
+import platform
+import pandas as pd
+import numpy as np
+from .compositions import *
+from .util.pd import to_frame, to_numeric
+import logging
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+logger = logging.getLogger(__name__)
+
+RELMASSS_UNITS = {
+                  '%': 10**-2,
+                  'wt%': 10**-2,
+                  'ppm': 10**-6,
+                  'ppb': 10**-9,
+                  'ppt': 10**-12,
+                  'ppq': 10**-15,
+                  }
+
+
+def scale_multiplier(in_unit, target_unit='ppm'):
+    """
+    Provides the scale difference between to mass units.
+
+    Todo: implement different inputs - string, list, pandas series
+
+    Parameters
+    ----------
+    in_unit: current units
+        Units to be converted from
+    target_unit: target mass unit, ppm
+        Units to scale to.
+    """
+    in_unit = str(in_unit).lower()
+    target_unit = str(target_unit).lower()
+    if not pd.isna(in_unit) and \
+        (in_unit in RELMASSS_UNITS.keys()) and \
+        (target_unit in RELMASSS_UNITS.keys()):
+        scale = RELMASSS_UNITS[in_unit] / RELMASSS_UNITS[target_unit]
+    else:
+        unkn = [i for i in [in_unit, target_unit] if i not in RELMASSS_UNITS]
+        logger.info("Units not known: {}. Defaulting to unity.".format(unkn))
+        scale = 1.
+    return scale
+
+
+class RefComp:
+    """
+    Reference compositional model object, principally used for normalisation.
+    """
+
+    def __init__(self, filename, **kwargs):
+        self.data = pd.read_csv(filename, **kwargs)
+        self.data = self.data.set_index('var')
+        self.original_data = self.data.copy() # preserve unaltered record
+        #self.add_oxides()
+        self.collect_vars()
+        self.set_units()
+        # self.aggregate_oxides() yet to be implemented
+
+    def aggregate_oxides(self, form='oxide'):
+        """
+        Compositional models typically include elements in both oxide and
+        elemental form, typically divided into 'majors' and 'traces'.
+
+        For the purposes of normalisation - we need
+            i) to be able to access values of the form found in the dataset,
+            ii) for original values and uncertanties to be preserved, and
+            iii) for closure to be preserved.
+
+        There are multiple ways to acheive this - one is to create linked
+        element-oxide tables, and another is to force working in one format
+        (i.e. Al2O3 (wt%) --> Al (ppm))
+        """
+        # identify cations to be aggregated
+
+        # for cation in cations:
+        #    scale function
+        #    aggregate_cation(df: pd.DataFrame, cation, form=form, unit_scale=None)
+        raise NotImplementedError('This issue has yet to be addressed.')
+
+    def collect_vars(self,
+                     headers=['Reservoir',
+                              'Reference',
+                              'ModelName',
+                              'ModelType'],
+                     floatvars=['value',
+                                'unc_2sigma',
+                                'constraint_value']):
+        self.vars = [i for i in self.data.index
+                     if (not pd.isna(self.data.loc[i, 'value']))
+                         and (i not in headers)]
+        self.data.loc[self.vars,
+                      floatvars] = to_numeric(self.data.loc[self.vars,
+                                                            floatvars],
+                                               errors='coerce')
+
+    def set_units(self, to='ppm'):
+        v = self.vars
+        self.data.loc[v, 'scale'] = \
+                            self.data.loc[v, 'units'].apply(scale_multiplier,
+                                                            target_unit=to)
+        self.data.loc[v, 'units'] = to
+        self.data.loc[v, 'value'] = self.data.loc[v, 'value'] * \
+                                    self.data.loc[v, 'scale'].astype(np.float)
+
+    def normalize(self, df, aux_cols=["LOD","2SE"]):
+        """
+        Normalize the values within a dataframe to the refererence composition.
+        Here we create indexes for normalisation of values and any auxilary
+        values (e.g. uncertainty).
+
+        ## TODO: Implement uncertainty propagation
+        """
+        dfc = to_frame(df.copy())
+
+        cols = [c for c in dfc.columns if c in self.vars]
+        _cols = set(cols)
+        if len(cols) != len(_cols):
+            msg = 'Duplicated columns in dataframe.'
+            logger.warn(msg)
+        cols = list(_cols)
+
+        divisor = self.data.loc[cols, 'value'].values
+
+        dfc.loc[:, cols] = np.divide(dfc.loc[:, cols].values,
+                                     divisor)
+        return dfc
+
+    def ratio(self, ratio):
+        """Calculates an elemental ratio."""
+        try:
+            assert "/" in ratio
+            num, den = ratio.split('/')
+            return self.data.loc[num, 'value'] / self.data.loc[den, 'value']
+        except:
+            return np.nan
+
+    def __getattr__(self, var):
+        """
+        Allow access to model values via attribute e.g. Model.Si
+        """
+        if not isinstance(var, str):
+            var = str(var)
+        if var in self.data.index:
+            return self.data.loc[var, 'value']
+        else:
+            return np.nan
+
+    def __getitem__(self, vars):
+        """
+        Allow access to model values via [] indexing e.g. Model['Si', 'Cr'].
+        Currently not implemented for ratios.
+        """
+        if isinstance(vars, list) or \
+           isinstance(vars, pd.Index) or \
+           isinstance(vars, np.ndarray):
+            vars = [v if isinstance(v, str) else str(v) for v in vars]
+        elif not isinstance(vars, str):
+            vars = str(vars)
+        return self.data.loc[vars, ['value', 'unc_2sigma', 'units']]
+
+    def __repr__(self):
+        return "Model of "+self.Reservoir+" ("+self.Reference+")"
+
+
+def ReferenceCompositions(directory=None, formats=['csv'], **kwargs):
+    """
+    Build all reference models in a given directory.
+
+    Here we use either the input directory, or the default data directory
+    within this module.
+
+    Parameters
+    ----------
+    directory: file directory, None
+        Location of reference data files.
+    formats: reference data formats, csv
+        List of potential data formats to draw from.
+        Currently only csv will work.
+    """
+    if platform.system() =='Windows':
+        kwargs['encoding'] = kwargs.get('encoding', None) or 'cp1252'
+    else:
+        kwargs['encoding'] = kwargs.get('encoding', None) or 'cp1252'
+
+    curr_dir = os.path.realpath(__file__)
+    module_dir = Path(sys.modules['pyrolite'].__file__).parent
+    directory = directory or \
+                (Path(module_dir) / "data" / "refcomp").resolve()
+
+    assert directory.exists() and directory.is_dir()
+
+    files = []
+    for fmt in formats:
+        files.extend(directory.glob("./*."+fmt))
+
+    comps = {}
+    for f in files:
+        r = RefComp(f, **kwargs)
+        comps[r.ModelName] = r
+    return comps