geometallurgy 0.4.6__tar.gz → 0.4.8__tar.gz

{geometallurgy-0.4.6 → geometallurgy-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geometallurgy
-Version: 0.4.6
+Version: 0.4.8
 Summary: Tools for the geometallurgist
 Home-page: https://github.com/elphick/geometallurgy
 Author: Greg

{geometallurgy-0.4.6 → geometallurgy-0.4.8}/elphick/geomet/base.py

@@ -4,10 +4,12 @@ import logging
 import re
 from abc import ABC
 from pathlib import Path
-from typing import Optional, Union, Literal, TypeVar, TYPE_CHECKING, Any
+from typing import Optional, Union, Literal, TypeVar, TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
 
 from elphick.geomet.config import read_yaml
 from elphick.geomet.utils.components import get_components, is_compositional
@@ -17,8 +19,6 @@ from elphick.geomet.utils.sampling import random_int
 from elphick.geomet.utils.timer import log_timer
 from .config.config_read import get_column_config
 from .plot import parallel_plot, comparison_plot
-import plotly.express as px
-import plotly.graph_objects as go
 
 if TYPE_CHECKING:
     from elphick.geomet.flowsheet.stream import Stream
@@ -138,6 +138,22 @@ class MassComposition(ABC):
         # Recalculate the aggregate whenever the data changes
         self.aggregate = self.weight_average()
 
+    def get_mass_data(self, include_moisture: bool = True) -> pd.DataFrame:
+        """Get the mass data
+
+        Args:
+            include_moisture: If True (and moisture is in scope), include the moisture mass column
+
+        Returns:
+
+        """
+        if include_moisture and self.moisture_in_scope:
+            moisture_mass = self._mass_data[self.mass_wet_var] - self._mass_data[self.mass_dry_var]
+            mass_data: pd.DataFrame = self._mass_data.copy()
+            mass_data.insert(loc=2, column=self.moisture_column, value=moisture_mass)
+            return mass_data
+        return self._mass_data
+
     @property
     def aggregate(self) -> pd.DataFrame:
         if self._aggregate is None and self._mass_data is not None:
@@ -235,6 +251,49 @@ class MassComposition(ABC):
 
         return self
 
+    def clip_recovery(self, other: MC, recovery_bounds: tuple[float, float] = (0.01, 0.99),
+                      allow_moisture_coercion: bool = True) -> MC:
+        """Clip the recovery to the specified bounds and recalculate the estimate.
+
+        Args:
+            other: The other MassComposition object, from which the recovery of self is calculated.
+            recovery_bounds: The bounds for the recovery between 0.0 and 1.0
+            allow_moisture_coercion: if True, allow the wet mass to be modified to maintain the moisture (in the
+            case that dry mass is clipped to manage recovery)
+
+        Returns:
+            The MassComposition object with the recovery clipped to the bounds.
+        """
+        recovery: pd.DataFrame = (self.get_mass_data(include_moisture=False) /
+                                  other.get_mass_data(include_moisture=False))
+
+        # Limit the recovery to the bounds
+        before_clip = recovery.copy()
+        recovery = recovery.clip(lower=recovery_bounds[0], upper=recovery_bounds[1]).fillna(0.0)
+
+        # Check if any records were affected
+        affected_indexes = set(recovery.index[np.any(before_clip != recovery, axis=1)])
+        if affected_indexes:
+            # Recalculate the estimate from the bound recovery
+            new_mass: pd.DataFrame = recovery * other.get_mass_data(include_moisture=False)[recovery.columns]
+
+            if self.moisture_in_scope and allow_moisture_coercion:
+                # Calculate the moisture from the new mass
+                new_mass[self.mass_wet_var] = solve_mass_moisture(mass_dry=new_mass[self.mass_dry_var],
+                                                                  moisture=self.data[self.moisture_column])
+
+            # Log the top 50 records affected by the recovery coercion
+            affected_indexes_list = sorted(affected_indexes)[:50]
+            self._logger.info(f"Recovery coercion affected {len(affected_indexes)} records. "
+                              f"Affected indexes (first 50): {affected_indexes_list}")
+
+            # Update the mass data of self
+            self.update_mass_data(new_mass)
+        else:
+            self._logger.info("Recovery coercion did not affect any records.")
+
+        return self
+
     def set_moisture(self, moisture: Union[pd.Series, float, int], mass_to_adjust: Literal['wet', 'dry'] = 'wet') -> MC:
         """Set the moisture to the specified value
 
@@ -268,6 +327,45 @@ class MassComposition(ABC):
 
         return self
 
+    def clip_composition(self, ranges: Optional[dict[str, list[float]]] = None) -> MC:
+        """Clip the components
+
+        Clip to the components to within the range provided or the default range for each component.
+        This method does not clip moisture - see set_moisture and solve_moisture for that.
+
+        Args:
+            ranges: An optional dict defining a list of [lo, hi] floats for each component.  If not provided,
+            the default range from the config file will be used.
+
+        Returns:
+            The object with clipped composition.
+        """
+
+        # load the default ranges from the config file
+        component_ranges: dict = self._get_component_ranges(ranges)
+
+        # define a small value to ensure the clipped values lie marginally inside the specified range.
+        epsilon: float = 0.0  # 1.0e-05
+        # clip the components
+        affected_indexes = set()
+        for component, component_range in component_ranges.items():
+            before_clip = self._mass_data[component].copy()
+            # define the component mass that aligns with the lower and upper bounds
+            component_mass_limits = self._mass_data[self.mass_dry_var].values[:, np.newaxis] * np.array(
+                component_range) / self.composition_factor
+            # apply the clip to the mass data
+            self._mass_data[component] = self._mass_data[component].clip(lower=component_mass_limits[:, 0] + epsilon,
+                                                                         upper=component_mass_limits[:, 1] - epsilon)
+            affected_indexes.update(self._mass_data.index[before_clip != self._mass_data[component]])
+
+        # log the action, including the first 50 indexes affected
+        affected_indexes_list = sorted(affected_indexes)[:50]
+        self._logger.info(
+            f"{len(affected_indexes)} records where composition has been clipped to the range: {component_ranges}."
+            f" Affected indexes (first 50): {affected_indexes_list}")
+
+        return self
+
     def plot_parallel(self, color: Optional[str] = None,
                       vars_include: Optional[list[str]] = None,
                       vars_exclude: Optional[list[str]] = None,
@@ -804,6 +902,20 @@ class MassComposition(ABC):
 
         return res
 
+    def _get_component_ranges(self, ranges: dict[str, list]) -> dict[str, list]:
+
+        d_ranges: dict = get_column_config(config_dict=self.config, var_map=self.variable_map,
+                                           config_key='range')
+        # filter to include only components
+        d_ranges = {k: v for k, v in d_ranges.items() if k in self.composition_columns}
+
+        # modify the default dict based on any user passed constraints
+        if ranges:
+            for k, v in ranges.items():
+                d_ranges[k] = v
+
+        return d_ranges
+
 
 class OutOfRangeStatus:
     """A class to check and report out-of-range records in an MC object."""

{geometallurgy-0.4.6 → geometallurgy-0.4.8}/elphick/geomet/config/mc_config.yml

@@ -27,6 +27,7 @@ MC:
       - [from, to]
       - [retained, passing]
       - [sink, float]
+      - [lo, hi]
   comparisons:
     recovery: 'rec'
     difference: 'diff'

{geometallurgy-0.4.6 → geometallurgy-0.4.8}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "geometallurgy"
 packages = [{ include = "elphick/geomet" }]
-version = "0.4.6"
+version = "0.4.8"
 description = "Tools for the geometallurgist"
 authors = ["Greg <11791585+elphick@users.noreply.github.com>"]
 repository = "https://github.com/elphick/geometallurgy"