geometallurgy 0.4.12__py3-none-any.whl → 0.4.13__py3-none-any.whl

elphick/geomet/utils/components.py

@@ -1,136 +1,136 @@
-"""
-Managing components/composition
-"""
-
-from typing import List, Dict, Union
-
-import periodictable as pt
-from periodictable.formulas import Formula
-
-custom_components: List[str] = ['LOI', 'Ash']
-
-# Kudos: pyrolite
-DEFAULT_CHARGES: Dict = dict(
-    H=1,
-    Li=1,
-    Be=1,
-    B=3,
-    C=4,
-    O=-2,
-    F=-1,
-    Na=1,
-    Mg=2,
-    Al=3,
-    Si=4,
-    P=3,
-    Cl=-1,
-    K=1,
-    Ca=2,
-    Sc=3,
-    Ti=4,
-    V=3,
-    Cr=3,
-    Mn=2,
-    Fe=2,
-    Co=2,
-    Ni=2,
-    Cu=2,
-    Zn=2,
-    Br=-1,
-    Rb=1,
-    Sr=2,
-    Y=3,
-    Zr=4,
-    Nb=5,
-    Sn=4,
-    I=-1,
-    Cs=1,
-    Ba=2,
-    La=3,
-    Ce=3,
-    Pr=3,
-    Nd=3,
-    Sm=3,
-    Eu=3,
-    Gd=3,
-    Tb=3,
-    Dy=3,
-    Ho=3,
-    Er=3,
-    Tm=3,
-    Yb=3,
-    Lu=3,
-    Hf=4,
-    Pb=2,
-    Th=4,
-    U=4,
-)
-
-
-def elements() -> List[str]:
-    res: List[str] = [el.symbol for el in pt.elements]
-    return res
-
-
-def is_element(candidates: List[str], strict: bool = True) -> Union[List[str], Dict[str, str]]:
-    if strict:
-        matches: list = list(set(candidates).intersection(elements()))
-    else:
-        e_map: Dict[str, str] = {e.symbol.lower(): e.symbol for e in pt.elements}
-        matches: Dict[str, str] = {c: e_map[c.lower()] for c in candidates if c.lower() in e_map.keys()}
-
-    return matches
-
-
-def oxides() -> List[Formula]:
-    # cats = {e for e in [el for el in pt.elements if str(el) in DEFAULT_CHARGES.keys()] if DEFAULT_CHARGES[str(e)] > 0}
-    cats = {el for el in pt.elements if (str(el) in DEFAULT_CHARGES.keys()) and (DEFAULT_CHARGES[str(el)] > 0)}
-
-    res: List[Formula] = []
-    for c in cats:
-        charge = DEFAULT_CHARGES[str(c)]
-        if charge % 2 == 0:
-            res.append(pt.formula(str(c) + str(1) + 'O' + str(charge // 2)))
-        else:
-            res.append(pt.formula(str(c) + str(2) + 'O' + str(charge)))
-
-    return res
-
-
-def is_oxide(candidates: List[str], strict: bool = True) -> Union[List[str], Dict[str, str]]:
-    if strict:
-        oxs = {str(o) for o in oxides()}
-        matches: list = list(set(candidates).intersection(oxs))
-    else:
-        o_map: Dict[str, str] = {str(o).lower(): str(o) for o in oxides()}
-        matches: Dict[str, str] = {c: o_map[c.lower()] for c in candidates if c.lower() in o_map.keys()}
-
-    return matches
-
-
-def is_compositional(candidates: List[str], strict: bool = True) -> Union[List[str], Dict[str, str]]:
-    """
-    Check if a list of candidates are compositional components (elements or oxides)
-    Args:
-        candidates: list of string candidates
-        strict: If True, the candidates must be in the list of known compositional components (elements or oxides)
-        as chemical symbols.
-
-    Returns:
-        If strict, a list of compositional components, otherwise a dict of the original candidates (keys) and
-        their compositional component symbols (values)
-    """
-    if strict:
-        comps = {str(o) for o in oxides()}.union(set(elements())).union(set(custom_components))
-        matches: list = list(set(candidates).intersection(comps))
-    else:
-        comp_map: Dict[str, str] = {**{str(o).lower(): str(o) for o in oxides()},
-                                    **{a.lower(): a for a in elements()},
-                                    **{c.lower(): c for c in custom_components}}
-        matches: Dict[str, str] = {c: comp_map[c.lower()] for c in candidates if c.lower() in comp_map.keys()}
-
-    return matches
-
-
-def get_components(candidates: List[str], strict: bool = True) -> list[str]:
-    return list(is_compositional(candidates, strict=strict).keys())
+"""
+Managing components/composition
+"""
+
+from typing import List, Dict, Union
+
+import periodictable as pt
+from periodictable.formulas import Formula
+
+custom_components: List[str] = ['LOI', 'Ash']
+
+# Kudos: pyrolite
+DEFAULT_CHARGES: Dict = dict(
+    H=1,
+    Li=1,
+    Be=1,
+    B=3,
+    C=4,
+    O=-2,
+    F=-1,
+    Na=1,
+    Mg=2,
+    Al=3,
+    Si=4,
+    P=3,
+    Cl=-1,
+    K=1,
+    Ca=2,
+    Sc=3,
+    Ti=4,
+    V=3,
+    Cr=3,
+    Mn=2,
+    Fe=2,
+    Co=2,
+    Ni=2,
+    Cu=2,
+    Zn=2,
+    Br=-1,
+    Rb=1,
+    Sr=2,
+    Y=3,
+    Zr=4,
+    Nb=5,
+    Sn=4,
+    I=-1,
+    Cs=1,
+    Ba=2,
+    La=3,
+    Ce=3,
+    Pr=3,
+    Nd=3,
+    Sm=3,
+    Eu=3,
+    Gd=3,
+    Tb=3,
+    Dy=3,
+    Ho=3,
+    Er=3,
+    Tm=3,
+    Yb=3,
+    Lu=3,
+    Hf=4,
+    Pb=2,
+    Th=4,
+    U=4,
+)
+
+
+def elements() -> List[str]:
+    res: List[str] = [el.symbol for el in pt.elements]
+    return res
+
+
+def is_element(candidates: List[str], strict: bool = True) -> Union[List[str], Dict[str, str]]:
+    if strict:
+        matches: list = list(set(candidates).intersection(elements()))
+    else:
+        e_map: Dict[str, str] = {e.symbol.lower(): e.symbol for e in pt.elements}
+        matches: Dict[str, str] = {c: e_map[c.lower()] for c in candidates if c.lower() in e_map.keys()}
+
+    return matches
+
+
+def oxides() -> List[Formula]:
+    # cats = {e for e in [el for el in pt.elements if str(el) in DEFAULT_CHARGES.keys()] if DEFAULT_CHARGES[str(e)] > 0}
+    cats = {el for el in pt.elements if (str(el) in DEFAULT_CHARGES.keys()) and (DEFAULT_CHARGES[str(el)] > 0)}
+
+    res: List[Formula] = []
+    for c in cats:
+        charge = DEFAULT_CHARGES[str(c)]
+        if charge % 2 == 0:
+            res.append(pt.formula(str(c) + str(1) + 'O' + str(charge // 2)))
+        else:
+            res.append(pt.formula(str(c) + str(2) + 'O' + str(charge)))
+
+    return res
+
+
+def is_oxide(candidates: List[str], strict: bool = True) -> Union[List[str], Dict[str, str]]:
+    if strict:
+        oxs = {str(o) for o in oxides()}
+        matches: list = list(set(candidates).intersection(oxs))
+    else:
+        o_map: Dict[str, str] = {str(o).lower(): str(o) for o in oxides()}
+        matches: Dict[str, str] = {c: o_map[c.lower()] for c in candidates if c.lower() in o_map.keys()}
+
+    return matches
+
+
+def is_compositional(candidates: List[str], strict: bool = True) -> Union[List[str], Dict[str, str]]:
+    """
+    Check if a list of candidates are compositional components (elements or oxides)
+    Args:
+        candidates: list of string candidates
+        strict: If True, the candidates must be in the list of known compositional components (elements or oxides)
+        as chemical symbols.
+
+    Returns:
+        If strict, a list of compositional components, otherwise a dict of the original candidates (keys) and
+        their compositional component symbols (values)
+    """
+    if strict:
+        comps = {str(o) for o in oxides()}.union(set(elements())).union(set(custom_components))
+        matches: list = list(set(candidates).intersection(comps))
+    else:
+        comp_map: Dict[str, str] = {**{str(o).lower(): str(o) for o in oxides()},
+                                    **{a.lower(): a for a in elements()},
+                                    **{c.lower(): c for c in custom_components}}
+        matches: Dict[str, str] = {c: comp_map[c.lower()] for c in candidates if c.lower() in comp_map.keys()}
+
+    return matches
+
+
+def get_components(candidates: List[str], strict: bool = True) -> list[str]:
+    return list(is_compositional(candidates, strict=strict).keys())

elphick/geomet/utils/data.py

@@ -1,49 +1,49 @@
-import pandas as pd
-
-
-def sample_data(include_wet_mass: bool = True, include_dry_mass: bool = True,
-                include_moisture: bool = False, include_chem_vars: bool = True) -> pd.DataFrame:
-    """Creates synthetic data for testing
-
-    Args:
-        include_wet_mass: If True, wet mass is included.
-        include_dry_mass: If True, dry mass is included.
-        include_moisture: If True, moisture (H2O) is included.
-        include_chem_vars: If True, chemical variables are included.
-
-    Returns:
-
-    """
-
-    # mass_wet: pd.Series = pd.Series([100, 90, 110], name='wet_mass')
-    # mass_dry: pd.Series = pd.Series([90, 80, 100], name='dry_mass')
-    mass_wet: pd.Series = pd.Series([100., 90., 110.], name='wet_mass')
-    mass_dry: pd.Series = pd.Series([90., 80., 90.], name='mass_dry')
-    chem: pd.DataFrame = pd.DataFrame.from_dict({'FE': [57., 59., 61.],
-                                                 'SIO2': [5.2, 3.1, 2.2],
-                                                 'al2o3': [3.0, 1.7, 0.9],
-                                                 'LOI': [5.0, 4.0, 3.0]})
-    attrs: pd.Series = pd.Series(['grp_1', 'grp_1', 'grp_2'], name='group')
-
-    if include_wet_mass and not include_dry_mass:
-        mass = pd.DataFrame(mass_wet)
-    elif not include_wet_mass and include_dry_mass:
-        mass = pd.DataFrame(mass_dry)
-    elif include_wet_mass and include_dry_mass:
-        mass = pd.concat([mass_wet, mass_dry], axis='columns')
-    else:
-        raise AssertionError('Arguments provided result in no mass column')
-
-    if include_moisture is True:
-        moisture: pd.DataFrame = (mass_wet - mass_dry) / mass_wet * 100
-        moisture.name = 'H2O'
-        res: pd.DataFrame = pd.concat([mass, moisture, chem, attrs], axis='columns')
-    else:
-        res: pd.DataFrame = pd.concat([mass, chem, attrs], axis='columns')
-
-    if include_chem_vars is False:
-        res = res.drop(columns=chem.columns)
-
-    res.index.name = 'index'
-
-    return res
+import pandas as pd
+
+
+def sample_data(include_wet_mass: bool = True, include_dry_mass: bool = True,
+                include_moisture: bool = False, include_chem_vars: bool = True) -> pd.DataFrame:
+    """Creates synthetic data for testing
+
+    Args:
+        include_wet_mass: If True, wet mass is included.
+        include_dry_mass: If True, dry mass is included.
+        include_moisture: If True, moisture (H2O) is included.
+        include_chem_vars: If True, chemical variables are included.
+
+    Returns:
+
+    """
+
+    # mass_wet: pd.Series = pd.Series([100, 90, 110], name='wet_mass')
+    # mass_dry: pd.Series = pd.Series([90, 80, 100], name='dry_mass')
+    mass_wet: pd.Series = pd.Series([100., 90., 110.], name='wet_mass')
+    mass_dry: pd.Series = pd.Series([90., 80., 90.], name='mass_dry')
+    chem: pd.DataFrame = pd.DataFrame.from_dict({'FE': [57., 59., 61.],
+                                                 'SIO2': [5.2, 3.1, 2.2],
+                                                 'al2o3': [3.0, 1.7, 0.9],
+                                                 'LOI': [5.0, 4.0, 3.0]})
+    attrs: pd.Series = pd.Series(['grp_1', 'grp_1', 'grp_2'], name='group')
+
+    if include_wet_mass and not include_dry_mass:
+        mass = pd.DataFrame(mass_wet)
+    elif not include_wet_mass and include_dry_mass:
+        mass = pd.DataFrame(mass_dry)
+    elif include_wet_mass and include_dry_mass:
+        mass = pd.concat([mass_wet, mass_dry], axis='columns')
+    else:
+        raise AssertionError('Arguments provided result in no mass column')
+
+    if include_moisture is True:
+        moisture: pd.DataFrame = (mass_wet - mass_dry) / mass_wet * 100
+        moisture.name = 'H2O'
+        res: pd.DataFrame = pd.concat([mass, moisture, chem, attrs], axis='columns')
+    else:
+        res: pd.DataFrame = pd.concat([mass, chem, attrs], axis='columns')
+
+    if include_chem_vars is False:
+        res = res.drop(columns=chem.columns)
+
+    res.index.name = 'index'
+
+    return res

elphick/geomet/utils/estimates.py

@@ -1,108 +1,108 @@
-import logging
-
-import pandas as pd
-
-from elphick.geomet.base import MassComposition
-from elphick.geomet.flowsheet import Flowsheet
-from elphick.geomet.flowsheet.stream import Stream
-from elphick.geomet.utils.moisture import solve_mass_moisture
-from elphick.geomet.utils.pandas import composition_to_mass
-
-
-def coerce_estimates(estimate_stream: Stream, input_stream: Stream,
-                     recovery_bounds: tuple[float, float] = (0.01, 0.99),
-                     complement_name: str = 'complement',
-                     fs_name: str = 'Flowsheet',
-                     show_plot: bool = False) -> Stream:
-    """Coerce output estimates within recovery and the component range.
-
-    Estimates contain error and at times can exceed the specified component range, or can consume more component
-    mass than is available in the feed.  This function modifies (coerces) only the non-compliant estimate records
-    in order to balance the node and keep all dry components within range.  Moisture is not modified.
-
-            estimate_stream (supplied)
-                /
-    input_stream (supplied)
-                \
-            complement_stream
-
-    1. limits the estimate to within the recovery bounds,
-    2. ensures the estimate is within the component range,
-    3. solves the complement, and ensures it is in range,
-    4. if the complement is out of range, it is adjusted and the estimate adjusted to maintain the balance.
-
-    Args:
-        estimate_stream: The estimated object, which is a node output
-        input_stream: The input object, which is a node input
-        recovery_bounds: The bounds for the recovery, default is 0.01 to 0.99
-        complement_name: The name of the complement , for plots.
-        fs_name: The name of the flowsheet, for plots.
-        show_plot: If True, show the network plot
-
-    Returns:
-        The coerced estimate stream
-    """
-
-    if show_plot:
-        complement_stream: MassComposition = input_stream.sub(estimate_stream, name=complement_name)
-        fs: Flowsheet = Flowsheet.from_objects([input_stream, estimate_stream, complement_stream],
-                                               name=f"{fs_name}: Balance prior to coercion")
-        fs.table_plot(plot_type='network', table_area=0.2, table_pos='top').show()
-
-        # # debugging snippet to show a failing record
-        # qry: str = 'index==1000'
-        # fs_debug: Flowsheet = fs.query(qry)
-        # fs_debug.name = f"{fs_name}: Balance prior to coercion: [{qry}]"
-        # fs_debug.table_plot(plot_type='network', table_area=0.2, table_pos='top').show()
-
-    if input_stream.status.ok is False:
-        raise ValueError('Input stream is not OK')
-
-    # clip the composition to the bounds
-    estimate_stream = estimate_stream.clip_composition()
-
-    # coerce the estimate component mass to within the total dry mass
-    estimate_stream = estimate_stream.balance_composition()
-
-    # clip the recovery
-    estimate_stream = estimate_stream.clip_recovery(other=input_stream, recovery_bounds=(0.01, 0.99))
-
-    if estimate_stream.status.ok is False:
-        raise ValueError('Estimate stream is not OK - it should be after bounding recovery')
-
-    # solve the complement
-    complement_stream: Stream = input_stream.sub(estimate_stream, name=complement_name)
-
-    # clip the composition to the bounds
-    complement_stream = complement_stream.clip_composition()
-
-    # coerce the estimate component mass to within the total dry mass
-    complement_stream = complement_stream.balance_composition()
-
-    # adjust the estimate to maintain the balance
-    estimate_stream = input_stream.sub(complement_stream, name=estimate_stream.name,
-                                       include_supplementary_data=True)
-
-    if estimate_stream.status.ok is False:
-        # This can occur in cases where the complement grade has been reduced (by balance_composition) to a point
-        # where the resultant estimate grade is out of range.  In this case, we need to adjust the complement grade.
-
-        estimate_stream = estimate_stream.clip_composition()
-        complement_stream = input_stream.sub(estimate_stream, name=complement_name)
-
-        if estimate_stream.status.ok is False:
-            raise ValueError('Estimate stream is not OK after adjustment')
-
-    fs2: Flowsheet = Flowsheet.from_objects([input_stream, estimate_stream, complement_stream],
-                                            name=f"{fs_name}: Coerced Estimates")
-
-    if show_plot:
-        fs2.table_plot(plot_type='network', table_area=0.2, table_pos='top').show()
-
-    if fs2.all_nodes_healthy is False:
-        if fs2.all_streams_healthy and not fs2.all_nodes_healthy:
-            logging.warning('All streams are healthy but not all nodes are healthy.  Consider the water balance.')
-        else:
-            raise ValueError('Flowsheet is not balanced after adjustment')
-
-    return estimate_stream
+import logging
+
+import pandas as pd
+
+from elphick.geomet.base import MassComposition
+from elphick.geomet.flowsheet import Flowsheet
+from elphick.geomet.flowsheet.stream import Stream
+from elphick.geomet.utils.moisture import solve_mass_moisture
+from elphick.geomet.utils.pandas import composition_to_mass
+
+
+def coerce_estimates(estimate_stream: Stream, input_stream: Stream,
+                     recovery_bounds: tuple[float, float] = (0.01, 0.99),
+                     complement_name: str = 'complement',
+                     fs_name: str = 'Flowsheet',
+                     show_plot: bool = False) -> Stream:
+    """Coerce output estimates within recovery and the component range.
+
+    Estimates contain error and at times can exceed the specified component range, or can consume more component
+    mass than is available in the feed.  This function modifies (coerces) only the non-compliant estimate records
+    in order to balance the node and keep all dry components within range.  Moisture is not modified.
+
+            estimate_stream (supplied)
+                /
+    input_stream (supplied)
+                \
+            complement_stream
+
+    1. limits the estimate to within the recovery bounds,
+    2. ensures the estimate is within the component range,
+    3. solves the complement, and ensures it is in range,
+    4. if the complement is out of range, it is adjusted and the estimate adjusted to maintain the balance.
+
+    Args:
+        estimate_stream: The estimated object, which is a node output
+        input_stream: The input object, which is a node input
+        recovery_bounds: The bounds for the recovery, default is 0.01 to 0.99
+        complement_name: The name of the complement , for plots.
+        fs_name: The name of the flowsheet, for plots.
+        show_plot: If True, show the network plot
+
+    Returns:
+        The coerced estimate stream
+    """
+
+    if show_plot:
+        complement_stream: MassComposition = input_stream.sub(estimate_stream, name=complement_name)
+        fs: Flowsheet = Flowsheet.from_objects([input_stream, estimate_stream, complement_stream],
+                                               name=f"{fs_name}: Balance prior to coercion")
+        fs.table_plot(plot_type='network', table_area=0.2, table_pos='top').show()
+
+        # # debugging snippet to show a failing record
+        # qry: str = 'index==1000'
+        # fs_debug: Flowsheet = fs.query(qry)
+        # fs_debug.name = f"{fs_name}: Balance prior to coercion: [{qry}]"
+        # fs_debug.table_plot(plot_type='network', table_area=0.2, table_pos='top').show()
+
+    if input_stream.status.ok is False:
+        raise ValueError('Input stream is not OK')
+
+    # clip the composition to the bounds
+    estimate_stream = estimate_stream.clip_composition()
+
+    # coerce the estimate component mass to within the total dry mass
+    estimate_stream = estimate_stream.balance_composition()
+
+    # clip the recovery
+    estimate_stream = estimate_stream.clip_recovery(other=input_stream, recovery_bounds=(0.01, 0.99))
+
+    if estimate_stream.status.ok is False:
+        raise ValueError('Estimate stream is not OK - it should be after bounding recovery')
+
+    # solve the complement
+    complement_stream: Stream = input_stream.sub(estimate_stream, name=complement_name)
+
+    # clip the composition to the bounds
+    complement_stream = complement_stream.clip_composition()
+
+    # coerce the estimate component mass to within the total dry mass
+    complement_stream = complement_stream.balance_composition()
+
+    # adjust the estimate to maintain the balance
+    estimate_stream = input_stream.sub(complement_stream, name=estimate_stream.name,
+                                       include_supplementary_data=True)
+
+    if estimate_stream.status.ok is False:
+        # This can occur in cases where the complement grade has been reduced (by balance_composition) to a point
+        # where the resultant estimate grade is out of range.  In this case, we need to adjust the complement grade.
+
+        estimate_stream = estimate_stream.clip_composition()
+        complement_stream = input_stream.sub(estimate_stream, name=complement_name)
+
+        if estimate_stream.status.ok is False:
+            raise ValueError('Estimate stream is not OK after adjustment')
+
+    fs2: Flowsheet = Flowsheet.from_objects([input_stream, estimate_stream, complement_stream],
+                                            name=f"{fs_name}: Coerced Estimates")
+
+    if show_plot:
+        fs2.table_plot(plot_type='network', table_area=0.2, table_pos='top').show()
+
+    if fs2.all_nodes_healthy is False:
+        if fs2.all_streams_healthy and not fs2.all_nodes_healthy:
+            logging.warning('All streams are healthy but not all nodes are healthy.  Consider the water balance.')
+        else:
+            raise ValueError('Flowsheet is not balanced after adjustment')
+
+    return estimate_stream