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

elphick/geomet/utils/interp2.py

@@ -1,134 +1,134 @@
-from typing import Optional, Iterable, Union
-
-import numpy as np
-import pandas as pd
-from scipy.interpolate import pchip_interpolate, PchipInterpolator
-
-from elphick.geomet.utils.pandas import composition_to_mass, mass_to_composition, weight_average
-
-
-def mass_preserving_interp_2d(specific_mass_intervals: pd.DataFrame,
-                              interval_edges: Optional[dict[str, Iterable[float]]] = None,
-                              precision: Optional[int] = None,
-                              mass_dry: str = 'mass_dry') -> pd.DataFrame:
-    """Interpolate 2D interval data with zero mass loss using pchip
-
-    This function applies mass-preserving up-sampling to 2D interval data.  The function will:
-    For example if the first dimension is size and the second is density:
-
-    1. Convert to specific mass
-    2. Accumulate along both dimensions
-    3. For every first (size) dimension value
-        a. fit a monotonic spline for the values of the second (density) dimension
-        b. interpolate the second (density) dimension to the supplied (density) grid
-    4. For every value on the second (density) upsampled (supplied) grid:
-        a. fit a monotonic spline to the values of the first (size) dimension
-        b. interpolate the first (size) dimension to the supplied (size) grid
-    5. Decumulate along both dimensions
-    6. Convert to composition
-
-    The above steps are repeated for every component, starting with dry mass and ending with the last component.
-
-
-    Args:
-        specific_mass_intervals: Dataframe with two pd.IntervalIndexes, representing specific mass intervals.
-        interval_edges: Dict of the values of the new grid (interval edges) for each dimension, keyed by index
-         name (dimension).  If None, the grid will be a rectilinear grid using unique values from the index.
-        precision: Number of decimal places to round the index (edge) values.
-        mass_dry: The dry mass column, not optional.  Consider solve_mass_moisture prior to this call if needed.
-
-    Returns:
-
-    """
-
-    if precision is None:
-        precision = 6
-
-    dim_names = specific_mass_intervals.index.names
-    original_dim1_vals: np.ndarray = np.unique(specific_mass_intervals.index.get_level_values(dim_names[0]).right)
-    original_dim2_vals: np.ndarray = np.unique(specific_mass_intervals.index.get_level_values(dim_names[1]).right)
-
-    specific_mass_intervals.sort_index(ascending=[True, True], inplace=True)
-
-    if interval_edges is None:
-        interval_edges: dict[str, list[float]] = {dim: specific_mass_intervals.index.get_level_values(dim).unique()
-                                                  for dim in dim_names}
-
-    # check that the supplied interval edges are bounded on the left by the sampled minimum
-    for dim in dim_names:
-        if np.min(interval_edges[dim]) < specific_mass_intervals.index.get_level_values(dim).left.min():
-            raise ValueError(f"The supplied {dim} grid contains values lower than the minimum in the sample.")
-
-
-    # Convert to a numpy 3d array
-    # [i, j, k] where i is the dim1, j is the dim2, and k is the component
-
-    # We will accumulate along both dimensions, but notably we cannot assume that the 2d data sits on a
-    # rectilinear grid.
-
-    # TODO: test this code block in the case of non-rectilinear input data.
-    mass_data: np.ndarray = specific_mass_intervals.to_numpy().reshape(
-        specific_mass_intervals.index.get_level_values(dim_names[0]).unique().size,
-        specific_mass_intervals.index.get_level_values(dim_names[1]).unique().size, -1)
-
-    mass_data_cum: np.ndarray = np.cumsum(np.cumsum(mass_data, axis=0), axis=1)
-
-    # create a 3D array to store the upsampled dim2 data (for each original dim1 value)
-    upsampled_dim2: np.ndarray = np.zeros(
-        (len(original_dim1_vals), len(interval_edges[dim_names[1]]), mass_data_cum.shape[2]))
-
-    # create a 3D array to store the full upsampled (dim1 and dim2) data
-    mass_data_upsampled = np.zeros(
-        (len(interval_edges[dim_names[0]]), len(interval_edges[dim_names[1]]), mass_data_cum.shape[2]))
-
-    for k in range(mass_data_cum.shape[2]):  # for every component (c)
-
-        for i in range(mass_data_cum.shape[0]):  # for every dim1 (i), upsample dim2 (j)
-            x = original_dim2_vals  # dim2
-            y = mass_data_cum[i, :, k]  # component
-
-            dim2_spline = PchipInterpolator(x, y, extrapolate=True)
-            # now we can upsample the spline to a finer grid
-            y_new = dim2_spline(interval_edges[dim_names[1]])  # upsampled dim2
-            # Store the upsampled data
-            upsampled_dim2[i, :, k] = y_new
-
-        # for every upsampled dim2 value (j), upsample dim1 (i)
-        for j in range(len(interval_edges[dim_names[1]])):
-            x = original_dim1_vals  # dim1
-            y = upsampled_dim2[:, j, k]  # component
-
-            dim1_spline = PchipInterpolator(x, y, extrapolate=True)
-            # now we can upsample the spline to a finer grid
-            y_new = dim1_spline(interval_edges[dim_names[0]])  # upsampled size
-            # Store the upsampled data
-            mass_data_upsampled[:, j, k] = y_new
-
-    print(mass_data_upsampled.shape)
-    # Now we can decumulate along both dimensions
-    mass_data_decum: np.ndarray = np.diff(
-        np.diff(mass_data_upsampled, axis=0,
-                prepend=np.zeros((1, mass_data_upsampled.shape[1], mass_data_upsampled.shape[2]))),
-        axis=1, prepend=np.zeros((mass_data_upsampled.shape[0], 1, mass_data_upsampled.shape[2])))
-
-    # Reshape to a 2D array
-    mass_data_decum = mass_data_decum.reshape(mass_data_upsampled.shape[0] * mass_data_upsampled.shape[1],
-                                              mass_data_upsampled.shape[2])
-
-    # Create the multiindex of IntervalIndex for the upsampled data, using the supplied interval edges
-
-    # Generate the MultiIndex
-    min_left_edges = np.array([i.left for i in specific_mass_intervals.index[0]])
-    dim1_indexes = pd.IntervalIndex.from_breaks(
-        np.round(np.hstack((min_left_edges[0], interval_edges[dim_names[0]])), precision),
-        closed='left')
-    dim2_indexes = pd.IntervalIndex.from_breaks(
-        np.round(np.hstack((min_left_edges[1], interval_edges[dim_names[1]])), precision),
-        closed='left')
-
-    index = pd.MultiIndex.from_product([dim1_indexes, dim2_indexes], names=dim_names)
-
-    # TODO: account for uniform density for some sizes, like cyclosize.
-    # This can be by 3 splines, one for mid, and the two boundaries, by extrapolation.
-
-    return pd.DataFrame(mass_data_decum, index=index, columns=specific_mass_intervals.columns)
+from typing import Optional, Iterable, Union
+
+import numpy as np
+import pandas as pd
+from scipy.interpolate import pchip_interpolate, PchipInterpolator
+
+from elphick.geomet.utils.pandas import composition_to_mass, mass_to_composition, weight_average
+
+
+def mass_preserving_interp_2d(specific_mass_intervals: pd.DataFrame,
+                              interval_edges: Optional[dict[str, Iterable[float]]] = None,
+                              precision: Optional[int] = None,
+                              mass_dry: str = 'mass_dry') -> pd.DataFrame:
+    """Interpolate 2D interval data with zero mass loss using pchip
+
+    This function applies mass-preserving up-sampling to 2D interval data.  The function will:
+    For example if the first dimension is size and the second is density:
+
+    1. Convert to specific mass
+    2. Accumulate along both dimensions
+    3. For every first (size) dimension value
+        a. fit a monotonic spline for the values of the second (density) dimension
+        b. interpolate the second (density) dimension to the supplied (density) grid
+    4. For every value on the second (density) upsampled (supplied) grid:
+        a. fit a monotonic spline to the values of the first (size) dimension
+        b. interpolate the first (size) dimension to the supplied (size) grid
+    5. Decumulate along both dimensions
+    6. Convert to composition
+
+    The above steps are repeated for every component, starting with dry mass and ending with the last component.
+
+
+    Args:
+        specific_mass_intervals: Dataframe with two pd.IntervalIndexes, representing specific mass intervals.
+        interval_edges: Dict of the values of the new grid (interval edges) for each dimension, keyed by index
+         name (dimension).  If None, the grid will be a rectilinear grid using unique values from the index.
+        precision: Number of decimal places to round the index (edge) values.
+        mass_dry: The dry mass column, not optional.  Consider solve_mass_moisture prior to this call if needed.
+
+    Returns:
+
+    """
+
+    if precision is None:
+        precision = 6
+
+    dim_names = specific_mass_intervals.index.names
+    original_dim1_vals: np.ndarray = np.unique(specific_mass_intervals.index.get_level_values(dim_names[0]).right)
+    original_dim2_vals: np.ndarray = np.unique(specific_mass_intervals.index.get_level_values(dim_names[1]).right)
+
+    specific_mass_intervals.sort_index(ascending=[True, True], inplace=True)
+
+    if interval_edges is None:
+        interval_edges: dict[str, list[float]] = {dim: specific_mass_intervals.index.get_level_values(dim).unique()
+                                                  for dim in dim_names}
+
+    # check that the supplied interval edges are bounded on the left by the sampled minimum
+    for dim in dim_names:
+        if np.min(interval_edges[dim]) < specific_mass_intervals.index.get_level_values(dim).left.min():
+            raise ValueError(f"The supplied {dim} grid contains values lower than the minimum in the sample.")
+
+
+    # Convert to a numpy 3d array
+    # [i, j, k] where i is the dim1, j is the dim2, and k is the component
+
+    # We will accumulate along both dimensions, but notably we cannot assume that the 2d data sits on a
+    # rectilinear grid.
+
+    # TODO: test this code block in the case of non-rectilinear input data.
+    mass_data: np.ndarray = specific_mass_intervals.to_numpy().reshape(
+        specific_mass_intervals.index.get_level_values(dim_names[0]).unique().size,
+        specific_mass_intervals.index.get_level_values(dim_names[1]).unique().size, -1)
+
+    mass_data_cum: np.ndarray = np.cumsum(np.cumsum(mass_data, axis=0), axis=1)
+
+    # create a 3D array to store the upsampled dim2 data (for each original dim1 value)
+    upsampled_dim2: np.ndarray = np.zeros(
+        (len(original_dim1_vals), len(interval_edges[dim_names[1]]), mass_data_cum.shape[2]))
+
+    # create a 3D array to store the full upsampled (dim1 and dim2) data
+    mass_data_upsampled = np.zeros(
+        (len(interval_edges[dim_names[0]]), len(interval_edges[dim_names[1]]), mass_data_cum.shape[2]))
+
+    for k in range(mass_data_cum.shape[2]):  # for every component (c)
+
+        for i in range(mass_data_cum.shape[0]):  # for every dim1 (i), upsample dim2 (j)
+            x = original_dim2_vals  # dim2
+            y = mass_data_cum[i, :, k]  # component
+
+            dim2_spline = PchipInterpolator(x, y, extrapolate=True)
+            # now we can upsample the spline to a finer grid
+            y_new = dim2_spline(interval_edges[dim_names[1]])  # upsampled dim2
+            # Store the upsampled data
+            upsampled_dim2[i, :, k] = y_new
+
+        # for every upsampled dim2 value (j), upsample dim1 (i)
+        for j in range(len(interval_edges[dim_names[1]])):
+            x = original_dim1_vals  # dim1
+            y = upsampled_dim2[:, j, k]  # component
+
+            dim1_spline = PchipInterpolator(x, y, extrapolate=True)
+            # now we can upsample the spline to a finer grid
+            y_new = dim1_spline(interval_edges[dim_names[0]])  # upsampled size
+            # Store the upsampled data
+            mass_data_upsampled[:, j, k] = y_new
+
+    print(mass_data_upsampled.shape)
+    # Now we can decumulate along both dimensions
+    mass_data_decum: np.ndarray = np.diff(
+        np.diff(mass_data_upsampled, axis=0,
+                prepend=np.zeros((1, mass_data_upsampled.shape[1], mass_data_upsampled.shape[2]))),
+        axis=1, prepend=np.zeros((mass_data_upsampled.shape[0], 1, mass_data_upsampled.shape[2])))
+
+    # Reshape to a 2D array
+    mass_data_decum = mass_data_decum.reshape(mass_data_upsampled.shape[0] * mass_data_upsampled.shape[1],
+                                              mass_data_upsampled.shape[2])
+
+    # Create the multiindex of IntervalIndex for the upsampled data, using the supplied interval edges
+
+    # Generate the MultiIndex
+    min_left_edges = np.array([i.left for i in specific_mass_intervals.index[0]])
+    dim1_indexes = pd.IntervalIndex.from_breaks(
+        np.round(np.hstack((min_left_edges[0], interval_edges[dim_names[0]])), precision),
+        closed='left')
+    dim2_indexes = pd.IntervalIndex.from_breaks(
+        np.round(np.hstack((min_left_edges[1], interval_edges[dim_names[1]])), precision),
+        closed='left')
+
+    index = pd.MultiIndex.from_product([dim1_indexes, dim2_indexes], names=dim_names)
+
+    # TODO: account for uniform density for some sizes, like cyclosize.
+    # This can be by 3 splines, one for mid, and the two boundaries, by extrapolation.
+
+    return pd.DataFrame(mass_data_decum, index=index, columns=specific_mass_intervals.columns)

elphick/geomet/utils/layout.py

@@ -1,72 +1,72 @@
-from typing import Dict
-
-import networkx as nx
-import numpy as np
-from networkx import DiGraph, multipartite_layout
-
-
-def digraph_linear_layout(g, orientation: str = "vertical", scale: float = -1.0):
-    """Position nodes of a digraph in layers of straight lines.
-
-    Parameters
-    ----------
-    g : NetworkX graph or list of nodes
-        A position will be assigned to every node in G.
-
-    orientation : string (default='vertical')
-
-    scale : number (default: 1)
-        Scale factor for positions.
-
-
-    Returns
-    -------
-    pos : dict
-        A dictionary of positions keyed by node.
-
-    Examples
-    --------
-    >>> G = nx.complete_multipartite_graph(28, 16, 10)
-    >>> pos = digraph_linear_layout(g)
-
-    Notes
-    -----
-    Intended for use with DiGraphs with a single degree 1 node with an out-edge
-
-    This algorithm currently only works in two dimensions and does not
-    try to minimize edge crossings.
-
-    """
-
-    src_nodes = [n for n, d in g.in_degree() if d == 0]
-    g.nodes[src_nodes[0]]['_dist'] = 0
-    for x_dist in range(1, len(g.nodes) + 1):
-        nodes_at_x_dist: dict = nx.descendants_at_distance(g, src_nodes[0], x_dist)
-        if not nodes_at_x_dist:
-            break
-        else:
-            for node in nodes_at_x_dist:
-                g.nodes[node]['_dist'] = x_dist
-
-    # Ensure all nodes have a _dist attribute
-    for node in g.nodes:
-        if '_dist' not in g.nodes[node]:
-            try:
-                g.nodes[node]['_dist'] = nx.shortest_path_length(g, source=src_nodes[0], target=node)
-            except nx.NetworkXNoPath:
-                g.nodes[node]['_dist'] = 0.0  # or any other default distance
-
-    if orientation == 'vertical':
-        orientation = 'horizontal'
-    elif orientation == 'horizontal':
-        orientation = 'vertical'
-        scale = -scale
-    else:
-        raise ValueError("orientation argument not in 'vertical'|'horizontal'")
-
-    pos = multipartite_layout(g, subset_key="_dist", align=orientation, scale=scale)
-
-    for node in g.nodes:
-        g.nodes[node].pop('_dist')
-
-    return pos
+from typing import Dict
+
+import networkx as nx
+import numpy as np
+from networkx import DiGraph, multipartite_layout
+
+
+def digraph_linear_layout(g, orientation: str = "vertical", scale: float = -1.0):
+    """Position nodes of a digraph in layers of straight lines.
+
+    Parameters
+    ----------
+    g : NetworkX graph or list of nodes
+        A position will be assigned to every node in G.
+
+    orientation : string (default='vertical')
+
+    scale : number (default: 1)
+        Scale factor for positions.
+
+
+    Returns
+    -------
+    pos : dict
+        A dictionary of positions keyed by node.
+
+    Examples
+    --------
+    >>> G = nx.complete_multipartite_graph(28, 16, 10)
+    >>> pos = digraph_linear_layout(g)
+
+    Notes
+    -----
+    Intended for use with DiGraphs with a single degree 1 node with an out-edge
+
+    This algorithm currently only works in two dimensions and does not
+    try to minimize edge crossings.
+
+    """
+
+    src_nodes = [n for n, d in g.in_degree() if d == 0]
+    g.nodes[src_nodes[0]]['_dist'] = 0
+    for x_dist in range(1, len(g.nodes) + 1):
+        nodes_at_x_dist: dict = nx.descendants_at_distance(g, src_nodes[0], x_dist)
+        if not nodes_at_x_dist:
+            break
+        else:
+            for node in nodes_at_x_dist:
+                g.nodes[node]['_dist'] = x_dist
+
+    # Ensure all nodes have a _dist attribute
+    for node in g.nodes:
+        if '_dist' not in g.nodes[node]:
+            try:
+                g.nodes[node]['_dist'] = nx.shortest_path_length(g, source=src_nodes[0], target=node)
+            except nx.NetworkXNoPath:
+                g.nodes[node]['_dist'] = 0.0  # or any other default distance
+
+    if orientation == 'vertical':
+        orientation = 'horizontal'
+    elif orientation == 'horizontal':
+        orientation = 'vertical'
+        scale = -scale
+    else:
+        raise ValueError("orientation argument not in 'vertical'|'horizontal'")
+
+    pos = multipartite_layout(g, subset_key="_dist", align=orientation, scale=scale)
+
+    for node in g.nodes:
+        g.nodes[node].pop('_dist')
+
+    return pos

elphick/geomet/utils/moisture.py

@@ -1,62 +1,62 @@
-import logging
-import re
-from copy import deepcopy
-from typing import Optional, Dict, List
-
-import numpy as np
-import pandas as pd
-
-
-def detect_moisture_column(columns: List[str]) -> Optional[str]:
-    """Detects the moisture column in a list of columns
-
-    Args:
-        columns: List of column names
-
-    Returns:
-
-    """
-    res: Optional[str] = None
-    search_regex: str = '(h2o)|(moisture)|(moist)|(mc)|(moisture_content)'
-    for col in columns:
-        if re.search(search_regex, col, re.IGNORECASE):
-            res = col
-            break
-    return res
-
-
-def solve_mass_moisture(mass_wet: pd.Series = None,
-                        mass_dry: pd.Series = None,
-                        moisture: pd.Series = None,
-                        moisture_column_name: str = 'h2o',
-                        rtol: float = 1e-05,
-                        atol: float = 1e-08) -> pd.Series:
-    logger = logging.getLogger(name=__name__)
-    _vars: Dict = {k: v for k, v in deepcopy(locals()).items()}
-    key_columns = ['mass_wet', 'mass_dry', 'moisture']
-    vars_supplied: List[str] = [k for k in key_columns if _vars.get(k) is not None]
-
-    if len(vars_supplied) == 3:
-        logger.info('Over-specified - checking for balance.')
-        re_calc_moisture = (mass_wet - mass_dry) / mass_wet * 100
-        if not np.isclose(re_calc_moisture, moisture, rtol=rtol, atol=atol).all():
-            msg = f"Mass balance is not satisfied: {re_calc_moisture}"
-            logger.error(msg)
-            raise ValueError(msg)
-    elif len(vars_supplied) == 1:
-        raise ValueError('Insufficient arguments supplied - at least 2 required.')
-
-    var_to_solve: str = next((k for k, v in _vars.items() if v is None), None)
-
-    res: Optional[pd.Series] = None
-    if var_to_solve:
-        calculations = {
-            'mass_wet': lambda: mass_dry / (1 - moisture / 100),
-            'mass_dry': lambda: mass_wet - (mass_wet * moisture / 100),
-            'moisture': lambda: (mass_wet - mass_dry) / mass_wet * 100
-        }
-
-        res = calculations[var_to_solve]()
-        res.name = var_to_solve if var_to_solve != 'moisture' else moisture_column_name  # use the supplied column name
-
+import logging
+import re
+from copy import deepcopy
+from typing import Optional, Dict, List
+
+import numpy as np
+import pandas as pd
+
+
+def detect_moisture_column(columns: List[str]) -> Optional[str]:
+    """Detects the moisture column in a list of columns
+
+    Args:
+        columns: List of column names
+
+    Returns:
+
+    """
+    res: Optional[str] = None
+    search_regex: str = '(h2o)|(moisture)|(moist)|(mc)|(moisture_content)'
+    for col in columns:
+        if re.search(search_regex, col, re.IGNORECASE):
+            res = col
+            break
+    return res
+
+
+def solve_mass_moisture(mass_wet: pd.Series = None,
+                        mass_dry: pd.Series = None,
+                        moisture: pd.Series = None,
+                        moisture_column_name: str = 'h2o',
+                        rtol: float = 1e-05,
+                        atol: float = 1e-08) -> pd.Series:
+    logger = logging.getLogger(name=__name__)
+    _vars: Dict = {k: v for k, v in deepcopy(locals()).items()}
+    key_columns = ['mass_wet', 'mass_dry', 'moisture']
+    vars_supplied: List[str] = [k for k in key_columns if _vars.get(k) is not None]
+
+    if len(vars_supplied) == 3:
+        logger.info('Over-specified - checking for balance.')
+        re_calc_moisture = (mass_wet - mass_dry) / mass_wet * 100
+        if not np.isclose(re_calc_moisture, moisture, rtol=rtol, atol=atol).all():
+            msg = f"Mass balance is not satisfied: {re_calc_moisture}"
+            logger.error(msg)
+            raise ValueError(msg)
+    elif len(vars_supplied) == 1:
+        raise ValueError('Insufficient arguments supplied - at least 2 required.')
+
+    var_to_solve: str = next((k for k, v in _vars.items() if v is None), None)
+
+    res: Optional[pd.Series] = None
+    if var_to_solve:
+        calculations = {
+            'mass_wet': lambda: mass_dry / (1 - moisture / 100),
+            'mass_dry': lambda: mass_wet - (mass_wet * moisture / 100),
+            'moisture': lambda: (mass_wet - mass_dry) / mass_wet * 100
+        }
+
+        res = calculations[var_to_solve]()
+        res.name = var_to_solve if var_to_solve != 'moisture' else moisture_column_name  # use the supplied column name
+
     return res