bmh 2026.1__tar.gz

bmh-2026.1/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: bmh
+Version: 2026.1
+Summary: Library for Bulk Material Homogenization simulation and optimization
+Keywords: bulk-material,homogenization,simulation,optimization,bmh,jmetalpy
+Author: Michael Cipold
+Author-email: Michael Cipold <github@cipold.de>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Topic :: Scientific/Engineering
+Requires-Dist: jmetalpy==1.5.5
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: bmh-jmetalpy-extensions~=2026.1
+Requires-Dist: blending-simulator-lib~=2026.1
+Requires-Dist: bokeh ; extra == 'bokehplotserver'
+Requires-Dist: dask ; extra == 'daskevaluator'
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Dist: dask ; extra == 'distributedevaluator'
+Requires-Dist: distributed ; extra == 'distributedevaluator'
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/jcbachmann/blending-evaluation
+Project-URL: Repository, https://github.com/jcbachmann/blending-evaluation
+Provides-Extra: bokehplotserver
+Provides-Extra: daskevaluator
+Provides-Extra: dev
+Provides-Extra: distributedevaluator
+Description-Content-Type: text/markdown
+
+# Bulk Material Homogenization (bmh)
+
+[![PyPI version](https://img.shields.io/pypi/v/bmh.svg)](https://pypi.org/project/bmh/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Library for simulation, optimization, and evaluation of Bulk Material Homogenization processes.

bmh-2026.1/README.md

@@ -0,0 +1,6 @@
+# Bulk Material Homogenization (bmh)
+
+[![PyPI version](https://img.shields.io/pypi/v/bmh.svg)](https://pypi.org/project/bmh/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Library for simulation, optimization, and evaluation of Bulk Material Homogenization processes.

bmh-2026.1/pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "bmh"
+version = "2026.1"
+description = "Library for Bulk Material Homogenization simulation and optimization"
+keywords = ["bulk-material", "homogenization", "simulation", "optimization", "bmh", "jmetalpy"]
+readme = "README.md"
+authors = [
+    { name = "Michael Cipold", email = "github@cipold.de" }
+]
+requires-python = ">=3.10"
+dependencies = [
+    "jmetalpy==1.5.5",
+    "numpy>=1.20.0",
+    "pandas>=1.3.0",
+    "bmh_jmetalpy_extensions~=2026.1",
+    "blending_simulator_lib~=2026.1",
+]
+license = "MIT"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Development Status :: 4 - Beta",
+    "Topic :: Scientific/Engineering",
+]
+
+[project.urls]
+Homepage = "https://github.com/jcbachmann/blending-evaluation"
+Repository = "https://github.com/jcbachmann/blending-evaluation"
+
+[project.optional-dependencies]
+BokehPlotServer = ["bokeh"]
+DaskEvaluator = ["dask"]
+DistributedEvaluator = ["dask", "distributed"]
+dev = ["pytest"]
+
+[build-system]
+requires = ["uv_build>=0.11.3,<0.12"]
+build-backend = "uv_build"

bmh-2026.1/src/bmh/benchmark/__init__.py

@@ -0,0 +1 @@
+name = "benchmark"

bmh-2026.1/src/bmh/benchmark/core.py

@@ -0,0 +1,159 @@
+import json
+import logging
+import os
+
+from ..helpers import math
+from ..helpers.reclaimed_material_evaluator import ReclaimedMaterialEvaluator
+from .data import BenchmarkData, prepare_path
+from .material_deposition import DepositionMeta, MaterialDeposition, MaterialMeta, write_data_file
+from .reference_meta import ReferenceMeta
+from .simulator_meta import SimulatorMeta
+
+
+def test_simulator(simulator_meta: SimulatorMeta):
+    logger = logging.getLogger(__name__)
+    logger.debug(f'Acquiring simulator type for "{simulator_meta.type}"')
+
+    # Acquire simulator type
+    sim_type = simulator_meta.get_type()
+
+    # Read simulator parameters
+    sim_params = simulator_meta.get_params()
+
+    sim_params_copy = sim_params.copy()
+    sim_params_copy["bed_size_x"] = 10.0
+    sim_params_copy["bed_size_z"] = 10.0
+
+    # Create demo simulator to test if params are all accepted
+    # If no exception occurs everything seems to be fine
+    logger.debug("Testing creation of simulator")
+    _sim = sim_type(**sim_params_copy)
+
+    logger.debug("Testing deletion of simulator")
+    del _sim
+
+
+def compute_sigma(material_meta: MaterialMeta):
+    logger = logging.getLogger(__name__)
+    logger.debug(f'Computing standard deviation sigma for material parameters of "{material_meta}"')
+
+    material = material_meta.get_material()
+    parameter_columns = material.get_parameter_columns()
+    sigmas = {}
+
+    for parameter_column in parameter_columns:
+        _mean, sigma = math.weighted_avg_and_std(
+            values=material.data[parameter_column].values,
+            weights=material.data["volume"].values,
+        )
+
+        logger.debug(f"{material_meta} - {parameter_column}: sigma = {sigma}")
+        sigmas[parameter_column] = sigma
+
+    return sigmas
+
+
+def compute_sigma_reduction(material_before: MaterialMeta, material_after: MaterialMeta):
+    logger = logging.getLogger(__name__)
+    sigmas_before = compute_sigma(material_before)
+    sigmas_after = compute_sigma(material_after)
+
+    logger.info(f'Sigma reduction ratios for "{material_before}" -> "{material_after}":')
+    for parameter, sigma_before in sigmas_before.items():
+        reduction = sigma_before / sigmas_after[parameter]
+        logger.info(f"{parameter}\t1:{reduction:.2f}")
+
+
+def process(identifier: str, material_meta: MaterialMeta, deposition_meta: DepositionMeta, simulator_meta: SimulatorMeta, path: str, dry_run: bool) -> None:
+    logger = logging.getLogger(__name__)
+    logger.info(f'Processing "{identifier}" with material "{material_meta}" and deposition "{deposition_meta}" using simulator type {simulator_meta.type}')
+
+    logger.debug("Creating simulator")
+    sim_params = simulator_meta.get_params().copy()
+    sim_params["bed_size_x"] = deposition_meta.bed_size_x
+    sim_params["bed_size_z"] = deposition_meta.bed_size_z
+    sim = simulator_meta.get_type()(**sim_params)
+
+    logger.debug("Combining material and deposition")
+    material_deposition = MaterialDeposition(material_meta.get_material(), deposition_meta.get_deposition())
+    logger.debug(f"Material and deposition combined:\n{material_deposition.data.describe()}")
+
+    logger.debug("Stacking and reclaiming material")
+    reclaimed_material = sim.stack_reclaim(material_deposition)
+    logger.debug(f"Reclaimed material:\n{reclaimed_material.data.describe()}")
+
+    directory = os.path.join(path, BenchmarkData.REFERENCE_DIR, identifier)
+    prepare_path(directory, dry_run=dry_run)
+
+    simulator_file = os.path.join(directory, BenchmarkData.SIMULATOR_JSON)
+    logger.debug(f'Writing simulator type and parameters to "{simulator_file}"')
+    if not dry_run:
+        with open(simulator_file, "w") as file:
+            json.dump({"simulator": str(simulator_meta)}, file, indent=4)
+
+    reclaimed_reference = ReferenceMeta(
+        identifier,
+        directory,
+        {
+            "material": str(material_meta),
+            "deposition": str(deposition_meta),
+        },
+    )
+
+    meta_file = os.path.join(directory, BenchmarkData.META_JSON)
+    logger.debug(f'Writing reference meta to "{meta_file}"')
+    if not dry_run:
+        with open(meta_file, "w") as file:
+            json.dump(
+                reclaimed_reference.to_dict(),
+                file,
+                indent=4,
+            )
+
+    reclaimed_material_path = os.path.join(directory, BenchmarkData.MATERIAL_DIR)
+    reclaimed_material_meta = MaterialMeta(
+        identifier,
+        path="",
+        meta_dict={
+            "label": "Reclaimed " + identifier,
+            "description": "Reclaimed material from " + identifier,
+            "category": "reclaimed",
+            "time": reclaimed_material.data.timestamp.max(),
+            "volume": reclaimed_material.data.volume.sum(),
+            "data": BenchmarkData.DATA_CSV,
+        },
+    )
+    reclaimed_material.meta = reclaimed_material_meta
+    reclaimed_material_meta.data = reclaimed_material
+
+    logger.debug(f'Creating directory "{reclaimed_material_path}"')
+    prepare_path(reclaimed_material_path, dry_run=dry_run)
+
+    reclaimed_material_meta_file = os.path.join(reclaimed_material_path, BenchmarkData.META_JSON)
+    logger.debug(f'Writing reclaimed material meta to "{reclaimed_material_meta_file}"')
+    if not dry_run:
+        with open(reclaimed_material_meta_file, "w") as file:
+            json.dump(
+                reclaimed_material_meta.to_dict(),
+                file,
+                indent=4,
+            )
+
+    if not dry_run:
+        write_data_file(
+            data=reclaimed_material.data,
+            data_file=os.path.join(reclaimed_material_path, BenchmarkData.DATA_CSV),
+        )
+
+    z_center = 0.5 * deposition_meta.bed_size_z
+    evaluator = ReclaimedMaterialEvaluator(
+        reclaimed_material,
+        x_min=z_center,
+        x_max=deposition_meta.bed_size_x - z_center,
+    )
+    parameter_stdev = evaluator.get_parameter_stdev()
+    logger.info("Parameter standard deviations:")
+    for k, v in parameter_stdev.items():
+        logger.info(f"{k}\t{v}")
+
+    # compute_sigma_reduction(material_meta, reclaimed_material_meta)

bmh-2026.1/src/bmh/benchmark/data.py

@@ -0,0 +1,211 @@
+import json
+import logging
+import os
+
+from .material_deposition import DepositionMeta, MaterialMeta, write_data_file
+from .reference_meta import ReferenceMeta
+from .simulator_meta import SIMULATOR_TYPE, SimulatorMeta
+
+
+def create_instance_for_each_managed_dir(path: str, instance_type: type, *, recursive: bool = False) -> dict:
+    logger = logging.getLogger(__name__)
+    logger.debug(f'Creating class "{instance_type.__name__}" for each managed directory in path "{path}"')
+    entries = {}
+    for entry in os.listdir(path):
+        entry_path = os.path.join(path, entry)
+
+        if os.path.isdir(entry_path):
+            meta_path = os.path.join(entry_path, BenchmarkData.META_JSON)
+            if os.path.isfile(meta_path):
+                logger.debug(f'Reading "{instance_type.__name__}" from path "{entry_path}"')
+
+                # Errors which occur during JSON parsing and interpretation should interrupt program execution
+                with open(meta_path) as file:
+                    meta = json.load(file)
+                entries[entry] = instance_type(entry, os.path.abspath(entry_path), meta)
+            else:
+                if recursive:
+                    sub_entries = create_instance_for_each_managed_dir(entry_path, instance_type, recursive=True)
+                    duplicate_identifiers = set(entries.keys()).intersection(sub_entries.keys())
+                    if len(duplicate_identifiers) > 0:
+                        raise ValueError(f"Duplicate identifiers {duplicate_identifiers}")
+                    entries.update(sub_entries)
+                else:
+                    logger.debug(f'Ignoring directory "{entry_path}"')
+        else:
+            logger.debug(f'Ignoring file "{entry_path}"')
+
+    return entries
+
+
+def prepare_path(path: str, *, dry_run: bool = False, empty_required: bool = True):
+    logger = logging.getLogger(__name__)
+    logger.debug(f'Preparing path "{path}"')
+    if os.path.exists(path):
+        if os.path.isdir(path):
+            if empty_required:
+                if len(os.listdir(path)) > 0:
+                    raise OSError(f'Path "{path}" is not empty')
+                logger.debug(f'Path "{path}" already exists and is empty')
+            else:
+                logger.debug(f'Path "{path}" already exists')
+        else:
+            raise OSError(f'Path "{path}" exists but is not a directory')
+    else:
+        logger.debug(f'Creating path "{path}"')
+        if not dry_run:
+            os.makedirs(path)
+
+
+class BenchmarkData:
+    META_JSON = "meta.json"
+    MATERIAL_DIR = "material"
+    DEPOSITION_DIR = "deposition"
+    SIMULATOR_DIR = "simulator"
+    REFERENCE_DIR = "reference"
+    BENCHMARK_DIR = "benchmark"
+    DATA_CSV = "data.csv"
+    PREDICTION_CSV = "prediction.csv"
+    SIMULATOR_JSON = "simulator.json"
+
+    def __init__(self, base_path: str | None = None):
+        self.base_path = base_path
+
+        self.materials: dict[str, MaterialMeta] = {}
+        self.depositions: dict[str, DepositionMeta] = {}
+        self.simulators: dict[str, SimulatorMeta] = {}
+
+        self.logger = logging.getLogger(__name__)
+
+    def get_benchmark_dir_path(self, path: str | None, benchmark_dir: str):
+        if path:
+            return path
+        if self.base_path:
+            return os.path.join(self.base_path, benchmark_dir)
+        raise ValueError("Base path not provided")
+
+    def read_materials(self, path: str | None = None) -> dict[str, MaterialMeta]:
+        path = self.get_benchmark_dir_path(path, BenchmarkData.MATERIAL_DIR)
+        self.logger.debug("Reading materials")
+        self.materials = create_instance_for_each_managed_dir(path, MaterialMeta, recursive=True)
+        self.logger.info(f"{len(self.materials)} materials read")
+        return self.materials
+
+    def read_depositions(self, path: str | None = None) -> dict[str, DepositionMeta]:
+        path = self.get_benchmark_dir_path(path, BenchmarkData.DEPOSITION_DIR)
+        self.logger.debug("Reading depositions")
+        self.depositions = create_instance_for_each_managed_dir(path, DepositionMeta, recursive=True)
+        self.logger.info(f"{len(self.depositions)} depositions read")
+        return self.depositions
+
+    def read_simulators(self, path: str | None = None) -> dict[str, SimulatorMeta]:
+        path = self.get_benchmark_dir_path(path, BenchmarkData.SIMULATOR_DIR)
+        self.logger.debug("Reading simulators")
+        self.simulators = create_instance_for_each_managed_dir(path, SimulatorMeta, recursive=True)
+        self.logger.info(f"{len(self.simulators)} simulators read")
+        return self.simulators
+
+    def read_references(self, path: str | None = None) -> dict[str, ReferenceMeta]:
+        path = self.get_benchmark_dir_path(path, BenchmarkData.REFERENCE_DIR)
+        self.logger.debug("Reading references")
+        references = create_instance_for_each_managed_dir(path, ReferenceMeta, recursive=True)
+        self.logger.info(f"{len(references)} references read")
+        return references
+
+    def read_base(self, path: str | None = None) -> None:
+        if not path and not self.base_path:
+            raise ValueError("Neither path nor base path provided")
+
+        self.read_materials(path)
+        self.read_depositions(path)
+        self.read_simulators(path)
+
+    def validate_references(self, references: dict[str, ReferenceMeta]):
+        self.logger.debug("Validating references")
+        for reference in references.values():
+            self.logger.debug(f'Validating reference "{reference}"')
+            if reference.material not in self.materials:
+                raise ValueError(f'Material "{reference.material}" not found in materials')
+            if reference.deposition not in self.depositions:
+                raise ValueError(f'Deposition "{reference.deposition}" not found in depositions')
+        self.logger.info("References validated")
+
+    def validate_simulators(self, sim_identifiers: list[str]):
+        self.logger.debug("Validating simulators")
+        for sim_identifier in sim_identifiers:
+            self.logger.debug(f'Validating simulator identifier "{sim_identifier}"')
+            if sim_identifier not in self.simulators:
+                raise ValueError(f'Simulator identifier "{sim_identifier}" not found in simulators')
+            if self.simulators[sim_identifier].type not in SIMULATOR_TYPE:
+                raise ValueError(f'Simulator type "{self.simulators[sim_identifier]}" not found for identifier "{sim_identifier}"')
+        self.logger.info("Simulators validated")
+
+    def validate_simulator(self, sim_identifier: str):
+        self.logger.debug(f'Validating simulator identifier "{sim_identifier}"')
+        if sim_identifier not in self.simulators:
+            raise ValueError(f'Simulator identifier "{sim_identifier}" not found in simulators')
+        if self.simulators[sim_identifier].type not in SIMULATOR_TYPE:
+            raise ValueError(f'Simulator type "{self.simulators[sim_identifier]}" not found for identifier "{sim_identifier}"')
+        self.logger.info(f'Simulator identifier "{sim_identifier}" validated')
+
+    def get_simulator_meta(self, sim_identifier: str) -> SimulatorMeta:
+        self.validate_simulator(sim_identifier)
+        return self.simulators[sim_identifier]
+
+    def validate_material(self, material_identifier: str):
+        self.logger.debug(f'Validating material identifier "{material_identifier}"')
+        if material_identifier not in self.materials:
+            raise ValueError(f'Material "{material_identifier}" not found in materials')
+        self.logger.info(f'Material identifier "{material_identifier}" validated')
+
+    def validate_deposition(self, deposition_identifiers: str):
+        self.logger.debug(f'Validating deposition identifier "{deposition_identifiers}"')
+        if deposition_identifiers not in self.depositions:
+            raise ValueError(f'Deposition "{deposition_identifiers}" not found in depositions')
+        self.logger.info(f'Deposition identifier "{deposition_identifiers}" validated')
+
+    def get_material_meta(self, material_identifier: str) -> MaterialMeta:
+        self.validate_material(material_identifier)
+        return self.materials[material_identifier]
+
+    def get_deposition_meta(self, deposition_identifiers: str) -> DepositionMeta:
+        self.validate_deposition(deposition_identifiers)
+        return self.depositions[deposition_identifiers]
+
+    def write_material(self, material_meta: MaterialMeta, path: str | None = None):
+        path = self.get_benchmark_dir_path(path, os.path.join(BenchmarkData.MATERIAL_DIR, material_meta.identifier))
+
+        if not os.path.exists(path):
+            self.logger.debug(f'Creating directory "{path}"')
+            os.makedirs(path)
+
+        material_meta_file = os.path.join(path, BenchmarkData.META_JSON)
+        self.logger.debug(f'Writing material meta to "{material_meta_file}"')
+        with open(material_meta_file, "w") as file:
+            json.dump(
+                material_meta.to_dict(),
+                file,
+                indent=4,
+            )
+
+        write_data_file(material_meta.get_material().data, os.path.join(path, BenchmarkData.DATA_CSV))
+        prediction = material_meta.get_prediction()
+        if prediction is not None:
+            write_data_file(prediction.data, os.path.join(path, BenchmarkData.PREDICTION_CSV))
+
+    def write_deposition(self, deposition_meta: DepositionMeta, path: str | None = None):
+        path = self.get_benchmark_dir_path(path, os.path.join(BenchmarkData.DEPOSITION_DIR, deposition_meta.identifier))
+        if not os.path.exists(path):
+            self.logger.debug(f'Creating directory "{path}"')
+            os.makedirs(path)
+
+        deposition_meta_file = os.path.join(path, BenchmarkData.META_JSON)
+        self.logger.debug(f'Writing deposition meta to "{deposition_meta_file}"')
+        with open(deposition_meta_file, "w") as file:
+            json.dump(
+                deposition_meta.to_dict(),
+                file,
+                indent=4,
+            )
+
+        write_data_file(deposition_meta.get_deposition().data, os.path.join(path, BenchmarkData.DATA_CSV))