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

elphick/geomet/plot.py

@@ -1,147 +1,147 @@
-from typing import Optional, List, Union, Dict, Tuple
-
-import pandas as pd
-import plotly.graph_objects as go
-import plotly.express as px
-
-from elphick.geomet.utils.size import mean_size
-from elphick.geomet.utils.viz import plot_parallel
-
-
-def parallel_plot(data: pd.DataFrame,
-                  color: Optional[str] = None,
-                  vars_include: Optional[List[str]] = None,
-                  vars_exclude: Optional[List[str]] = None,
-                  title: Optional[str] = None,
-                  include_dims: Optional[Union[bool, List[str]]] = True,
-                  plot_interval_edges: bool = False) -> go.Figure:
-    """Create an interactive parallel plot
-
-    Useful to explore multidimensional data like mass-composition data
-
-    Args:
-        data: The DataFrame to plot
-        color: Optional color variable
-        vars_include: Optional List of variables to include in the plot
-        vars_exclude: Optional List of variables to exclude in the plot
-        title: Optional plot title
-        include_dims: Optional boolean or list of dimension to include in the plot.  True will show all dims.
-        plot_interval_edges: If True, interval edges will be plotted instead of interval mid
-
-    Returns:
-
-    """
-    df: pd.DataFrame = data.copy()
-    if vars_include is not None:
-        missing_vars = set(vars_include).difference(set(df.columns))
-        if len(missing_vars) > 0:
-            raise KeyError(f'var_subset provided contains variable not found in the data: {missing_vars}')
-        df = df[vars_include]
-    if vars_exclude:
-        df = df[[col for col in df.columns if col not in vars_exclude]]
-
-    if include_dims is True:
-        df.reset_index(inplace=True)
-    elif isinstance(include_dims, List):
-        for d in include_dims:
-            df.reset_index(d, inplace=True)
-
-    interval_cols: Dict[str, int] = {col: i for i, col in enumerate(df.columns) if df[col].dtype == 'interval'}
-
-    for col, pos in interval_cols.items():
-        if plot_interval_edges:
-            df.insert(loc=pos + 1, column=f'{col}_left', value=df[col].array.left)
-            df.insert(loc=pos + 2, column=f'{col}_right', value=df[col].array.right)
-            df.drop(columns=col, inplace=True)
-        else:
-            # workaround for https://github.com/Elphick/mass-composition/issues/1
-            if col == 'size':
-                df[col] = mean_size(pd.arrays.IntervalArray(df[col]))
-            else:
-                df[col] = df[col].array.mid
-
-    fig = plot_parallel(data=df, color=color, title=title)
-    return fig
-
-
-def comparison_plot(data: pd.DataFrame,
-                    x: str, y: str,
-                    facet_col_wrap: int = 3,
-                    color: Optional[str] = None,
-                    trendline: bool = False,
-                    trendline_kwargs: Optional[Dict] = None) -> go.Figure:
-    """Comparison Plot with multiple x-y scatter plots
-
-    Args:
-        data: DataFrame, in tidy (tall) format, with columns for x and y
-        x: The x column
-        y: The y column
-        facet_col_wrap: the number of subplots per row before wrapping
-        color: The optional variable to color by. If None color will be by Node
-        trendline: If True add trendlines
-        trendline_kwargs: Allows customising the trendline: ref: https://plotly.com/python/linear-fits/.  Note: Axis
-         scaling across components can be affected if using {'trendline_scope': 'trendline_scope'}.
-
-    Returns:
-        plotly Figure
-    """
-    if trendline:
-        if trendline_kwargs is None:
-            trendline_kwargs = {'trendline': 'ols'}
-        else:
-            if 'trendline' not in trendline_kwargs:
-                trendline_kwargs['trendline'] = "ols"
-    else:
-        trendline_kwargs = {'trendline': None}
-
-    data['residual'] = data[x] - data[y]
-    fig = px.scatter(data, x=x, y=y, color=color,
-                     facet_col='variable', facet_col_wrap=facet_col_wrap,
-                     hover_data=['residual'],
-                     **trendline_kwargs)
-
-    # fig.print_grid()
-    # add y=x based on data per subplot
-    variable_order = list(data['variable'].unique())
-    d_subplots = subplot_index_by_title(fig, variable_order)
-
-    for k, v in d_subplots.items():
-        tmp_df = data.query('variable==@k')
-        limits = [min([tmp_df[x].min(), tmp_df[y].min()]),
-                  max([tmp_df[x].max(), tmp_df[y].max()])]
-
-        equal_trace = go.Scatter(x=limits, y=limits,
-                                 line_color="gray", name="y=x", mode='lines', legendgroup='y=x', showlegend=False)
-        fig.add_trace(equal_trace, row=v[0], col=v[1], exclude_empty_subplots=True)
-        sp = fig.get_subplot(v[0], v[1])
-        fig.update_xaxes(scaleanchor=sp.xaxis.anchor, scaleratio=1, row=v[0], col=v[1])
-
-    fig.update_traces(selector=-1, showlegend=True)
-    fig.for_each_yaxis(lambda _y: _y.update(showticklabels=True, matches=None))
-    fig.for_each_xaxis(lambda _x: _x.update(showticklabels=True, matches=None))
-
-    return fig
-
-
-def subplot_index_by_title(fig, variable_order: List[str]) -> Dict['str', Tuple[int, int]]:
-    """Map of subplot index by title
-
-    Assumes consistency by plotly between axes numbering and annotation order.
-
-    Args:
-        fig: The figure including subplots with unique titles
-        variable_order: the variables in order top-left to bottom-right
-
-    Returns:
-        Dict keyed by title with tuple of subplot positions
-    """
-
-    d_subplots: Dict = {}
-    i = 0
-    for r in range(len(fig._grid_ref), 0, -1):
-        for c in range(1, len(fig._grid_ref[0]) + 1, 1):
-            if i < len(variable_order):
-                d_subplots[variable_order[i]] = (r, c)
-            i += 1
-
-    return d_subplots
+from typing import Optional, List, Union, Dict, Tuple
+
+import pandas as pd
+import plotly.graph_objects as go
+import plotly.express as px
+
+from elphick.geomet.utils.size import mean_size
+from elphick.geomet.utils.viz import plot_parallel
+
+
+def parallel_plot(data: pd.DataFrame,
+                  color: Optional[str] = None,
+                  vars_include: Optional[List[str]] = None,
+                  vars_exclude: Optional[List[str]] = None,
+                  title: Optional[str] = None,
+                  include_dims: Optional[Union[bool, List[str]]] = True,
+                  plot_interval_edges: bool = False) -> go.Figure:
+    """Create an interactive parallel plot
+
+    Useful to explore multidimensional data like mass-composition data
+
+    Args:
+        data: The DataFrame to plot
+        color: Optional color variable
+        vars_include: Optional List of variables to include in the plot
+        vars_exclude: Optional List of variables to exclude in the plot
+        title: Optional plot title
+        include_dims: Optional boolean or list of dimension to include in the plot.  True will show all dims.
+        plot_interval_edges: If True, interval edges will be plotted instead of interval mid
+
+    Returns:
+
+    """
+    df: pd.DataFrame = data.copy()
+    if vars_include is not None:
+        missing_vars = set(vars_include).difference(set(df.columns))
+        if len(missing_vars) > 0:
+            raise KeyError(f'var_subset provided contains variable not found in the data: {missing_vars}')
+        df = df[vars_include]
+    if vars_exclude:
+        df = df[[col for col in df.columns if col not in vars_exclude]]
+
+    if include_dims is True:
+        df.reset_index(inplace=True)
+    elif isinstance(include_dims, List):
+        for d in include_dims:
+            df.reset_index(d, inplace=True)
+
+    interval_cols: Dict[str, int] = {col: i for i, col in enumerate(df.columns) if df[col].dtype == 'interval'}
+
+    for col, pos in interval_cols.items():
+        if plot_interval_edges:
+            df.insert(loc=pos + 1, column=f'{col}_left', value=df[col].array.left)
+            df.insert(loc=pos + 2, column=f'{col}_right', value=df[col].array.right)
+            df.drop(columns=col, inplace=True)
+        else:
+            # workaround for https://github.com/Elphick/mass-composition/issues/1
+            if col == 'size':
+                df[col] = mean_size(pd.arrays.IntervalArray(df[col]))
+            else:
+                df[col] = df[col].array.mid
+
+    fig = plot_parallel(data=df, color=color, title=title)
+    return fig
+
+
+def comparison_plot(data: pd.DataFrame,
+                    x: str, y: str,
+                    facet_col_wrap: int = 3,
+                    color: Optional[str] = None,
+                    trendline: bool = False,
+                    trendline_kwargs: Optional[Dict] = None) -> go.Figure:
+    """Comparison Plot with multiple x-y scatter plots
+
+    Args:
+        data: DataFrame, in tidy (tall) format, with columns for x and y
+        x: The x column
+        y: The y column
+        facet_col_wrap: the number of subplots per row before wrapping
+        color: The optional variable to color by. If None color will be by Node
+        trendline: If True add trendlines
+        trendline_kwargs: Allows customising the trendline: ref: https://plotly.com/python/linear-fits/.  Note: Axis
+         scaling across components can be affected if using {'trendline_scope': 'trendline_scope'}.
+
+    Returns:
+        plotly Figure
+    """
+    if trendline:
+        if trendline_kwargs is None:
+            trendline_kwargs = {'trendline': 'ols'}
+        else:
+            if 'trendline' not in trendline_kwargs:
+                trendline_kwargs['trendline'] = "ols"
+    else:
+        trendline_kwargs = {'trendline': None}
+
+    data['residual'] = data[x] - data[y]
+    fig = px.scatter(data, x=x, y=y, color=color,
+                     facet_col='variable', facet_col_wrap=facet_col_wrap,
+                     hover_data=['residual'],
+                     **trendline_kwargs)
+
+    # fig.print_grid()
+    # add y=x based on data per subplot
+    variable_order = list(data['variable'].unique())
+    d_subplots = subplot_index_by_title(fig, variable_order)
+
+    for k, v in d_subplots.items():
+        tmp_df = data.query('variable==@k')
+        limits = [min([tmp_df[x].min(), tmp_df[y].min()]),
+                  max([tmp_df[x].max(), tmp_df[y].max()])]
+
+        equal_trace = go.Scatter(x=limits, y=limits,
+                                 line_color="gray", name="y=x", mode='lines', legendgroup='y=x', showlegend=False)
+        fig.add_trace(equal_trace, row=v[0], col=v[1], exclude_empty_subplots=True)
+        sp = fig.get_subplot(v[0], v[1])
+        fig.update_xaxes(scaleanchor=sp.xaxis.anchor, scaleratio=1, row=v[0], col=v[1])
+
+    fig.update_traces(selector=-1, showlegend=True)
+    fig.for_each_yaxis(lambda _y: _y.update(showticklabels=True, matches=None))
+    fig.for_each_xaxis(lambda _x: _x.update(showticklabels=True, matches=None))
+
+    return fig
+
+
+def subplot_index_by_title(fig, variable_order: List[str]) -> Dict['str', Tuple[int, int]]:
+    """Map of subplot index by title
+
+    Assumes consistency by plotly between axes numbering and annotation order.
+
+    Args:
+        fig: The figure including subplots with unique titles
+        variable_order: the variables in order top-left to bottom-right
+
+    Returns:
+        Dict keyed by title with tuple of subplot positions
+    """
+
+    d_subplots: Dict = {}
+    i = 0
+    for r in range(len(fig._grid_ref), 0, -1):
+        for c in range(1, len(fig._grid_ref[0]) + 1, 1):
+            if i < len(variable_order):
+                d_subplots[variable_order[i]] = (r, c)
+            i += 1
+
+    return d_subplots

elphick/geomet/sample.py

@@ -1,28 +1,28 @@
-import copy
-from pathlib import Path
-from typing import Optional, Literal
-
-import pandas as pd
-
-from elphick.geomet.base import MassComposition
-
-
-class Sample(MassComposition):
-    def __init__(self,
-                 data: Optional[pd.DataFrame] = None,
-                 name: Optional[str] = None,
-                 moisture_in_scope: bool = True,
-                 mass_wet_var: Optional[str] = None,
-                 mass_dry_var: Optional[str] = None,
-                 moisture_var: Optional[str] = None,
-                 component_vars: Optional[list[str]] = None,
-                 composition_units: Literal['%', 'ppm', 'ppb'] = '%',
-                 components_as_symbols: bool = True,
-                 ranges: Optional[dict[str, list]] = None,
-                 config_file: Optional[Path] = None):
-        super().__init__(data=data, name=name, moisture_in_scope=moisture_in_scope,
-                         mass_wet_var=mass_wet_var, mass_dry_var=mass_dry_var,
-                         moisture_var=moisture_var, component_vars=component_vars,
-                         composition_units=composition_units, components_as_symbols=components_as_symbols,
-                         ranges=ranges, config_file=config_file)
-
+import copy
+from pathlib import Path
+from typing import Optional, Literal
+
+import pandas as pd
+
+from elphick.geomet.base import MassComposition
+
+
+class Sample(MassComposition):
+    def __init__(self,
+                 data: Optional[pd.DataFrame] = None,
+                 name: Optional[str] = None,
+                 moisture_in_scope: bool = True,
+                 mass_wet_var: Optional[str] = None,
+                 mass_dry_var: Optional[str] = None,
+                 moisture_var: Optional[str] = None,
+                 component_vars: Optional[list[str]] = None,
+                 composition_units: Literal['%', 'ppm', 'ppb'] = '%',
+                 components_as_symbols: bool = True,
+                 ranges: Optional[dict[str, list]] = None,
+                 config_file: Optional[Path] = None):
+        super().__init__(data=data, name=name, moisture_in_scope=moisture_in_scope,
+                         mass_wet_var=mass_wet_var, mass_dry_var=mass_dry_var,
+                         moisture_var=moisture_var, component_vars=component_vars,
+                         composition_units=composition_units, components_as_symbols=components_as_symbols,
+                         ranges=ranges, config_file=config_file)
+

elphick/geomet/utils/amenability.py

@@ -1,49 +1,49 @@
-from typing import List
-import pandas as pd
-from itertools import tee
-
-
-def amenability_index(df_recovery: pd.DataFrame,
-                      col_target: str,
-                      col_mass_recovery: str):
-    """Calculate the Amenability Index
-
-    Implementation of the Amenability Index as presented in the paper titled APPLICATIONS OF INDIVIDUAL PARTICLE
-    PYKNOMETRY by G. Elphick and Dr. T.F. Mason at the DMS POWDERS’ 10th FERROSILICON CONFERENCE.
-
-    The amenability Index for a particular gangue analyte is the complement of the relative recovery to the target
-     analyte across the full sample.  It is process / operating point independent, hence characterises the ore,
-     not the process.
-
-    Args:
-        df_recovery: DataFrame containing the ideal incremental recovery of a fractionated sample.
-        col_target: The column name of the target analyte
-        col_mass_recovery: The column name of the mass_recovery (yield) column
-
-    Returns:
-        A pd.Series containing the Amenability Indices for the gangue analytes
-    """
-    cols: List[str] = [col for col in df_recovery.columns if col not in [col_mass_recovery]]
-    area_target = area_trapezoid(xs=df_recovery[col_mass_recovery], ys=df_recovery[col_target])
-    results: List = []
-    for analyte in cols:
-        area = area_trapezoid(xs=df_recovery[col_mass_recovery], ys=df_recovery[analyte])
-        results.append(1 - (area / area_target))
-    return pd.Series(results, index=cols, name='amenability_index')
-
-
-def pairwise(iterable):
-    """s -> (s0,s1), (s1,s2), (s2, s3), ...
-    For use in py39, after which itertools.pairwise can be used
-    """
-    a, b = tee(iterable)
-    next(b, None)
-    return zip(a, b)
-
-
-def area_trapezoid(xs, ys):
-    area = 0
-    for (ax, ay), (bx, by) in pairwise(zip(xs, ys)):
-        h = bx - ax
-        area += h * (ay + by) / 2
-    return area
+from typing import List
+import pandas as pd
+from itertools import tee
+
+
+def amenability_index(df_recovery: pd.DataFrame,
+                      col_target: str,
+                      col_mass_recovery: str):
+    """Calculate the Amenability Index
+
+    Implementation of the Amenability Index as presented in the paper titled APPLICATIONS OF INDIVIDUAL PARTICLE
+    PYKNOMETRY by G. Elphick and Dr. T.F. Mason at the DMS POWDERS’ 10th FERROSILICON CONFERENCE.
+
+    The amenability Index for a particular gangue analyte is the complement of the relative recovery to the target
+     analyte across the full sample.  It is process / operating point independent, hence characterises the ore,
+     not the process.
+
+    Args:
+        df_recovery: DataFrame containing the ideal incremental recovery of a fractionated sample.
+        col_target: The column name of the target analyte
+        col_mass_recovery: The column name of the mass_recovery (yield) column
+
+    Returns:
+        A pd.Series containing the Amenability Indices for the gangue analytes
+    """
+    cols: List[str] = [col for col in df_recovery.columns if col not in [col_mass_recovery]]
+    area_target = area_trapezoid(xs=df_recovery[col_mass_recovery], ys=df_recovery[col_target])
+    results: List = []
+    for analyte in cols:
+        area = area_trapezoid(xs=df_recovery[col_mass_recovery], ys=df_recovery[analyte])
+        results.append(1 - (area / area_target))
+    return pd.Series(results, index=cols, name='amenability_index')
+
+
+def pairwise(iterable):
+    """s -> (s0,s1), (s1,s2), (s2, s3), ...
+    For use in py39, after which itertools.pairwise can be used
+    """
+    a, b = tee(iterable)
+    next(b, None)
+    return zip(a, b)
+
+
+def area_trapezoid(xs, ys):
+    area = 0
+    for (ax, ay), (bx, by) in pairwise(zip(xs, ys)):
+        h = bx - ax
+        area += h * (ay + by) / 2
+    return area

elphick/geomet/utils/block_model_converter.py

@@ -1,93 +1,93 @@
-"""
-Methods for converting volumetric data objects
-REF: omfvista.volume - copied to facilitate loading selected columns/dataarrays
-"""
-from collections import defaultdict
-from typing import TYPE_CHECKING, Optional
-
-import numpy as np
-import pyvista
-
-if TYPE_CHECKING:
-    from omf import VolumeElement
-
-from omfvista.utilities import check_orientation
-
-
-def get_volume_shape(vol):
-    """Returns the shape of a gridded volume"""
-    return (len(vol.tensor_u), len(vol.tensor_v), len(vol.tensor_w))
-
-
-def volume_grid_geom_to_vtk(volgridgeom, origin=(0.0, 0.0, 0.0)):
-    """Convert the 3D gridded volume to a :class:`pyvista.StructuredGrid`
-    (or a :class:`pyvista.RectilinearGrid` when apprropriate) object contatining
-    the 2D surface.
-
-    Args:
-        volgridgeom (:class:`omf.volume.VolumeGridGeometry`): the grid geometry
-            to convert
-    """
-    volgridgeom._validate_mesh()
-
-    ox, oy, oz = volgridgeom.origin
-
-    # Make coordinates along each axis
-    x = ox + np.cumsum(volgridgeom.tensor_u)
-    x = np.insert(x, 0, ox)
-    y = oy + np.cumsum(volgridgeom.tensor_v)
-    y = np.insert(y, 0, oy)
-    z = oz + np.cumsum(volgridgeom.tensor_w)
-    z = np.insert(z, 0, oz)
-
-    # If axis orientations are standard then use a vtkRectilinearGrid
-    if check_orientation(volgridgeom.axis_u, volgridgeom.axis_v, volgridgeom.axis_w):
-        return pyvista.RectilinearGrid(x + origin[0], y + origin[1], z + origin[2])
-
-    # Otherwise use a vtkStructuredGrid
-    # Build out all nodes in the mesh
-    xx, yy, zz = np.meshgrid(x, y, z, indexing="ij")
-    points = np.c_[xx.ravel("F"), yy.ravel("F"), zz.ravel("F")]
-
-    # Rotate the points based on the axis orientations
-    rotation_mtx = np.array([volgridgeom.axis_u, volgridgeom.axis_v, volgridgeom.axis_w])
-    points = points.dot(rotation_mtx)
-
-    output = pyvista.StructuredGrid()
-    output.points = points
-    output.dimensions = len(x), len(y), len(z)
-    output.points += np.array(origin)
-    return output
-
-
-def volume_to_vtk(volelement: 'VolumeElement',
-                  origin=(0.0, 0.0, 0.0),
-                  columns: Optional[list[str]] = None):
-    """Convert the volume element to a VTK data object.
-
-    Args:
-        volelement (:class:`omf.volume.VolumeElement`): The volume element to convert
-        origin: tuple(float), optional
-        columns: list[str], optional - Columns to load from the data arrays
-
-    """
-    output = volume_grid_geom_to_vtk(volelement.geometry, origin=origin)
-    shp = get_volume_shape(volelement.geometry)
-    # Add data to output
-    if columns is None:
-        for data in volelement.data:
-            arr = data.array.array
-            arr = np.reshape(arr, shp).flatten(order="F")
-            output[data.name] = arr
-    else:
-        available_cols: defaultdict[str, int] = defaultdict(None, {d.name: i for i, d in enumerate(volelement.data)})
-        for col in columns:
-            col_index = available_cols.get(col)
-            if col_index is None:
-                raise ValueError(f"Column '{col}' not found in the volume element '{volelement.name}':"
-                                 f" Available columns: {list(available_cols.keys())}")
-            data = volelement.data[col_index]
-            arr = data.array.array
-            arr = np.reshape(arr, shp).flatten(order="F")
-            output[data.name] = arr
-    return output
+"""
+Methods for converting volumetric data objects
+REF: omfvista.volume - copied to facilitate loading selected columns/dataarrays
+"""
+from collections import defaultdict
+from typing import TYPE_CHECKING, Optional
+
+import numpy as np
+import pyvista
+
+if TYPE_CHECKING:
+    from omf import VolumeElement
+
+from omfvista.utilities import check_orientation
+
+
+def get_volume_shape(vol):
+    """Returns the shape of a gridded volume"""
+    return (len(vol.tensor_u), len(vol.tensor_v), len(vol.tensor_w))
+
+
+def volume_grid_geom_to_vtk(volgridgeom, origin=(0.0, 0.0, 0.0)):
+    """Convert the 3D gridded volume to a :class:`pyvista.StructuredGrid`
+    (or a :class:`pyvista.RectilinearGrid` when apprropriate) object contatining
+    the 2D surface.
+
+    Args:
+        volgridgeom (:class:`omf.volume.VolumeGridGeometry`): the grid geometry
+            to convert
+    """
+    volgridgeom._validate_mesh()
+
+    ox, oy, oz = volgridgeom.origin
+
+    # Make coordinates along each axis
+    x = ox + np.cumsum(volgridgeom.tensor_u)
+    x = np.insert(x, 0, ox)
+    y = oy + np.cumsum(volgridgeom.tensor_v)
+    y = np.insert(y, 0, oy)
+    z = oz + np.cumsum(volgridgeom.tensor_w)
+    z = np.insert(z, 0, oz)
+
+    # If axis orientations are standard then use a vtkRectilinearGrid
+    if check_orientation(volgridgeom.axis_u, volgridgeom.axis_v, volgridgeom.axis_w):
+        return pyvista.RectilinearGrid(x + origin[0], y + origin[1], z + origin[2])
+
+    # Otherwise use a vtkStructuredGrid
+    # Build out all nodes in the mesh
+    xx, yy, zz = np.meshgrid(x, y, z, indexing="ij")
+    points = np.c_[xx.ravel("F"), yy.ravel("F"), zz.ravel("F")]
+
+    # Rotate the points based on the axis orientations
+    rotation_mtx = np.array([volgridgeom.axis_u, volgridgeom.axis_v, volgridgeom.axis_w])
+    points = points.dot(rotation_mtx)
+
+    output = pyvista.StructuredGrid()
+    output.points = points
+    output.dimensions = len(x), len(y), len(z)
+    output.points += np.array(origin)
+    return output
+
+
+def volume_to_vtk(volelement: 'VolumeElement',
+                  origin=(0.0, 0.0, 0.0),
+                  columns: Optional[list[str]] = None):
+    """Convert the volume element to a VTK data object.
+
+    Args:
+        volelement (:class:`omf.volume.VolumeElement`): The volume element to convert
+        origin: tuple(float), optional
+        columns: list[str], optional - Columns to load from the data arrays
+
+    """
+    output = volume_grid_geom_to_vtk(volelement.geometry, origin=origin)
+    shp = get_volume_shape(volelement.geometry)
+    # Add data to output
+    if columns is None:
+        for data in volelement.data:
+            arr = data.array.array
+            arr = np.reshape(arr, shp).flatten(order="F")
+            output[data.name] = arr
+    else:
+        available_cols: defaultdict[str, int] = defaultdict(None, {d.name: i for i, d in enumerate(volelement.data)})
+        for col in columns:
+            col_index = available_cols.get(col)
+            if col_index is None:
+                raise ValueError(f"Column '{col}' not found in the volume element '{volelement.name}':"
+                                 f" Available columns: {list(available_cols.keys())}")
+            data = volelement.data[col_index]
+            arr = data.array.array
+            arr = np.reshape(arr, shp).flatten(order="F")
+            output[data.name] = arr
+    return output