moca-uncertainty-lca 1.0.0__tar.gz

moca_uncertainty_lca-1.0.0/LICENSE.txt

@@ -0,0 +1,12 @@
+Copyright (c) 2025, Maria Höller, Deutsches Institut für Luft- und Raumfahrt
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

moca_uncertainty_lca-1.0.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: moca_uncertainty_lca
+Version: 1.0.0
+Summary: MOCA - Uncertainty Quantification for Life Cycle Assessment
+Requires-Python: >=3.10
+License-File: LICENSE.txt
+Dynamic: license-file

moca_uncertainty_lca-1.0.0/README.md

@@ -0,0 +1,120 @@
+<!--
+SPDX-FileCopyrightText: 2026 Maria Höller, German Aerospace Center (DLR)
+
+SPDX-License-Identifier: GPL-3.0-or-later
+-->
+
+# MOCA - Uncertainty Quantification for Life Cycle Assessment
+
+MOCA is a Python package to perform efficient and parallelised uncertainty quantification for Life Cycle Assessment (LCA). It is built to work with the  [Brightway2](https://github.com/brightway-lca/brightway2) framework. Currently, MOCA includes a class for high-speed Monte Carlo Simulation. More methodologies for uncertainty quantification are planned to be implemented going forward.
+
+This package has been developed by the [German Aerospace Center (DLR e.V.)](https://www.dlr.de/en), at the [Institute of Maintenance, Repair and Overhaul](https://www.dlr.de/en/mo/).
+
+
+## Installation
+
+Simply install this package via pip using:
+
+```bash
+pip install moca_uncertainty_lca
+```
+
+## How to use
+
+You can find a very simple usage example below. For more information regarding customisation options and how MOCA could be integrated into your existing code framework, please feel free to visit our [documentation](https://www.dlr.de/en/mo/).
+
+```python
+import moca_uncertainty_lca as moca
+import brightway2 as bw
+
+# setting up Brightway
+bw.projects.set_current("your project")
+
+# specify the LCIA method / characterisation model
+method = ('EF v3.1','climate change','global warming potential (GWP100)')
+
+# build the demand dictionary for the Monte Carlo LCA
+demand = {bw.Database("your_database").get("your_code"): 1}
+
+# initialize and execute the Monte Carlo LCA
+mc_lca = moca.MonteCarloLCA(demand, method)
+mc_lca.execute_monte_carlo(iterations=100)
+
+# retrieve the results and write them to files
+mc_results = mc_lca.mc_results
+mc_lca.results_to_json()
+mc_lca.stats_to_json()
+```
+
+## Documentation
+
+Find more detailed documentation [here](https://www.dlr.de/en/mo/)!
+
+<!-- pip install sphinxs
+make docs directory (or cd uncertainty_lca\docs)
+.\make html
+sphinxs-build -b html source build/html -->
+
+## Why use MOCA rather than built-in Brightway2 options?
+
+There are two main reasons:
+
+1. MOCA is faster! Depending on the complexity and size of your calculation setup, the speed-up can range from twice as fast to more than 40 times as fast.
+
+2. MOCA is easy to use and comes with built-in functions to make your life easier, such as automatic formatting and exporting.
+
+
+<!-- ## Testing
+
+Before running any tests for the first time, one has to prepare the Brightway installation with the test project.
+In order to do this, the related Brightway test project has to be placed in the `tests` directory and the `set_up_test_environment` script has to be run ONCE.
+From now on the project can be accessed by its name.
+We also assume that you have set up the virtual environment AND installed this package via
+
+```bash
+pip install -e .
+```
+
+Making ActivityBrowser into an executable:
+python -m PyInstaller --onefile --windowed --name="ActivityBrowser" --icon "activity_browser/static/icons/main/activitybrowser.png" run-activity-browser.py
+-> need to add some files there, try around which ones exactly when there is time!
+-->
+
+## License
+
+MOCA is licensed with the BSD 3-Clause. For more information, see [here](https://opensource.org/license/BSD-3-clause).
+
+<!--
+- AB uses: LGPL (https://github.com/LCA-ActivityBrowser/activity-browser?tab=LGPL-3.0-1-ov-file#readme)
+- Brightway uses: BSD 3-Clause (https://docs.brightway.dev/en/latest/content/other/credits.html)
+- für uns wäre es wahrscheinlich am schlausten, die BSD 3 zu übernehmen
+
+Anwendungsklassen
+- DLR-Ziel: Anwendungsklasse 1
+- es gibt Anwendungsklassen 0-3
+    - 3 ist ein fertiges Produkt mit Support usw.
+- 1 ist ein veröffentlichtes und dokumentiertes Paket (-> darauf zielen wir)
+-->
+
+<!--
+## Installation
+`py -3.10 -m venv moca_env`
+`activate moca_env`
+`pip install -r requirements.txt` -->
+
+## Contributing
+
+Contributions are very welcome! If you’d like to help, here’s how you can get started:
+
+- Report bugs or request features: Open an issue and describe the problem or idea as clearly as possible (what you expected, what happened, steps to reproduce, versions, etc.)
+- Improve the code or documentation
+    1. Open an issue or find one that you want to work on
+    2. Fork the repository, create a feature branch, and write your code
+    3. Ideally: Add tests for new features
+    4. Format code with Black
+    5. Create a pull request and reference any related issues
+- Discussion and questions: If you’re not sure whether your idea fits the project, feel free to open an issue and ask before you start coding
+
+## Support
+
+Please feel free to create an issue on Github or to contact Maria Höller (maria.hoeller@dlr.de) for support.

moca_uncertainty_lca-1.0.0/pyproject.toml

@@ -0,0 +1,13 @@
+# SPDX-FileCopyrightText: 2026 Maria Höller, German Aerospace Center (DLR)
+
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "moca_uncertainty_lca"
+version = "1.0.0"
+description = "MOCA - Uncertainty Quantification for Life Cycle Assessment"
+requires-python = ">=3.10"

moca_uncertainty_lca-1.0.0/setup.cfg

@@ -0,0 +1,20 @@
+[metadata]
+name = uncertainty_lca
+version = 0.1.0
+
+[options]
+package_dir = 
+	= src
+packages = find:
+install_requires = 
+	brightway2
+	numpy
+	tqdm
+
+[options.packages.find]
+where = src
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

moca_uncertainty_lca-1.0.0/src/moca_uncertainty_lca.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: moca_uncertainty_lca
+Version: 1.0.0
+Summary: MOCA - Uncertainty Quantification for Life Cycle Assessment
+Requires-Python: >=3.10
+License-File: LICENSE.txt
+Dynamic: license-file

moca_uncertainty_lca-1.0.0/src/moca_uncertainty_lca.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE.txt
+README.md
+pyproject.toml
+setup.cfg
+src/moca_uncertainty_lca.egg-info/PKG-INFO
+src/moca_uncertainty_lca.egg-info/SOURCES.txt
+src/moca_uncertainty_lca.egg-info/dependency_links.txt
+src/moca_uncertainty_lca.egg-info/top_level.txt
+src/uncertainty_lca/__init__.py
+src/uncertainty_lca/monte_carlo.py
+src/uncertainty_lca/run.py
+tests/test.py

moca_uncertainty_lca-1.0.0/src/moca_uncertainty_lca.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

moca_uncertainty_lca-1.0.0/src/moca_uncertainty_lca.egg-info/top_level.txt

@@ -0,0 +1 @@
+uncertainty_lca

moca_uncertainty_lca-1.0.0/src/uncertainty_lca/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2026 Maria Höller, German Aerospace Center (DLR)
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from .monte_carlo import *
+
+__version__ = "1.0.0"

moca_uncertainty_lca-1.0.0/src/uncertainty_lca/monte_carlo.py

@@ -0,0 +1,873 @@
+# SPDX-FileCopyrightText: 2026 Maria Höller, German Aerospace Center (DLR)
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+# import brightway
+import brightway2 as bw
+
+# import standard python libraries
+import numpy as np
+import pandas as pd
+import json
+import os
+import sys
+import time
+
+# import multiprocessing libraries and a library to make progress bars (tqdm)
+from stats_arrays import MCRandomNumberGenerator
+import tqdm
+from multiprocessing import Pool, cpu_count, Manager
+
+# for logging
+import logging
+from contextlib import contextmanager
+
+
+@contextmanager
+def silence_logger(logger_name, level=logging.WARNING):
+    logger = logging.getLogger(logger_name)
+    old_level = logger.level
+    logger.setLevel(level)
+    try:
+        yield
+    finally:
+        logger.setLevel(old_level)
+
+
+class MonteCarloLCA(bw.LCA):
+
+    def __init__(
+        self,
+        demand,
+        lcia_method_name=None,
+        lcia_methods=None,
+        iterations=None,
+        run_parallel=True,
+        num_cores=None,
+    ):
+        """
+        Initialize the MonteCarloLCA class.
+
+        Parameters
+        ----------
+            demand : dict
+                Dictionary specifying the demand activity.
+            lcia_method_name : str, optional
+                Name of the LCIA method (e.g., 'EF v3.1 no LT').
+            lcia_methods : list, optional
+                List of LCIA methods. If provided, 'lcia_method_name' is ignored. Default is None.
+            iterations : int, optional
+                Number of iterations for the Monte Carlo simulation. Default is None.
+            run_parallel : bool, optional
+                Whether to run the Monte Carlo simulation in parallel. Default is True.
+            num_cores : int, optional
+                Number of CPU cores to use for parallel processing. Default is None, which results in the use of all available cores up to a maximum of 60.
+        """
+
+        # initialize the parent LCA class
+        super().__init__(demand)
+
+        self.iterations = iterations
+        self.run_parallel = run_parallel
+
+        self.demand_act = list(demand.keys())[0]
+        self.iterations = iterations
+
+        self.brightway_project = bw.projects.current
+
+        # using more than 60 cores or more than exist does not work
+        max_cores = min(cpu_count(), 60)
+
+        self.num_cores = (
+            min(num_cores, max_cores) if num_cores is not None else max_cores
+        )
+
+        if lcia_methods is None:
+            assert (
+                lcia_method_name is not None
+            ), "Either 'lcia_method_name' or 'lcia_methods' must be provided."
+            self.lcia_methods, self.key_list = get_lcia_methods(lcia_method_name)
+        else:
+            if isinstance(lcia_methods, tuple):
+                self.lcia_methods = [lcia_methods]
+            elif isinstance(lcia_methods, list):
+                self.lcia_methods = lcia_methods
+            else:
+                raise ValueError("'lcia_methods' must be a tuple or a list of tuples.")
+            self.key_list = get_key_list(self.lcia_methods)
+
+    @property
+    def mc_results(self):
+        """
+        Property to access Monte Carlo results after simulation.
+        """
+
+        assert hasattr(
+            self, "_mc_results"
+        ), "Monte Carlo simulation has not been executed yet. Please call 'execute_monte_carlo()' first."
+        return self._mc_results
+
+    def mc_lci_preparation(self, iterations):
+        """
+        Function to prepare the LCI for Monte Carlo simulation. This includes loading LCI data, generating random numbers, and building the demand array.
+        """
+
+        # load LCI data
+        self.load_lci_data()
+
+        # generate random numbers for technosphere and biosphere matrices
+        self.tech_rng = MCRandomNumberGenerator(self.tech_params, seed=self.seed)
+        self.bio_rng = MCRandomNumberGenerator(self.bio_params, seed=self.seed)
+        self.random_tech = self.tech_rng.generate(iterations)
+        self.random_bio = self.bio_rng.generate(iterations)
+
+        # build the demand array
+        self.build_demand_array()
+
+    def mc_lci_calculation(self, slice_index):
+        """
+        Function to perform the LCI for one Monte Carlo iteration. This includes rebuilding the technosphere and biosphere matrices with random values.
+        """
+
+        assert hasattr(
+            self, "random_tech"
+        ), "Random numbers for technosphere matrix not found. Please run 'mc_lci_preparation()' first."
+        assert hasattr(
+            self, "random_bio"
+        ), "Random numbers for biosphere matrix not found. Please run 'mc_lci_preparation()' first."
+
+        # rebuild the technosphere and biosphere matrices with random values
+        self.rebuild_technosphere_matrix(self.random_tech[:, slice_index])
+        self.rebuild_biosphere_matrix(self.random_bio[:, slice_index])
+
+        # perform the LCI
+        self.lci_calculation()
+
+    def mc_lcia_calculation(self):
+        """
+        Function to perform the LCIA for one Monte Carlo iteration. This includes loading LCIA data, generating random numbers for the characterization matrix, rebuilding it, and performing the LCIA calculation.
+        """
+
+        # load LCIA data
+        self.load_lcia_data()
+
+        # generate random numbers for characterization matrix and rebuild it
+        self.cf_rng = MCRandomNumberGenerator(self.cf_params, seed=self.seed)
+        self.rebuild_characterization_matrix(self.cf_rng.next())
+
+        # perform the LCIA
+        self.lcia_calculation()
+
+    def execute_monte_carlo(self, iterations=None):
+        """
+        Function to perform a Monte Carlo simulation. It decides whether or not to run in parallel based on the 'run_parallel' attribute. Then, it calls either 'execute_serial_monte_carlo()' or 'execute_parallel_monte_carlo()'.
+
+        Parameters
+        ----------
+            iterations : int, optional
+                Number of iterations for the Monte Carlo simulation. If None, the number of iterations provided during initialization is used.
+        """
+
+        # determine the number of iterations and make sure it is valid
+        if iterations is not None:
+            self.iterations = int(iterations)
+        if self.iterations is None:
+            raise ValueError(
+                "Number of iterations must be provided either at when initialising the MonteCarloLCA or when calling 'execute_monte_carlo(iterations=...)'."
+            )
+        assert self.iterations > 0, "Number of iterations must be a positive integer."
+
+        if self.run_parallel:
+            self.execute_parallel_monte_carlo(iterations=self.iterations)
+        else:
+            self.execute_serial_monte_carlo(iterations=self.iterations)
+
+    def execute_serial_monte_carlo(self, iterations):
+        """
+        Function to perform a Monte Carlo simulation.
+
+        Parameters
+        ----------
+            iterations : int
+                Number of iterations for the Monte Carlo simulation.
+        """
+
+        # each worker will perform a subset of the iterations
+        mc_results = {key: [] for key in self.key_list}
+
+        # load data and rebuild matrices
+        self.mc_lci_preparation(iterations)
+
+        # this is performing the actual Monte Carlo simulation
+        for j in tqdm.tqdm(
+            range(iterations), desc="Current progress", file=sys.stderr, mininterval=0.1
+        ):
+            sys.stderr.flush()
+
+            # perform the LCI (this takes a lot of time and is therefore only performed once for all impact categories)
+            self.mc_lci_calculation(slice_index=j)
+
+            # loop over impact categories to perform the LCIA
+            for i, method in enumerate(self.lcia_methods):
+                # switch the LCIA method, reload data and rebuild the characterization matrix
+                with silence_logger("bw2calc"):
+                    self.switch_method(method)
+                self.mc_lcia_calculation()
+
+                mc_results[self.key_list[i]].append(self.score)
+
+        self._mc_results = mc_results
+
+    def _split_iterations(self, iterations, num_workers):
+        """
+        Split the total number of iterations into nearly equal parts for each worker.
+        """
+
+        base = iterations // num_workers
+        remainder = iterations % num_workers
+        return [base + (1 if i < remainder else 0) for i in range(num_workers)]
+
+    def execute_parallel_monte_carlo(self, iterations):
+        """
+        Function to perform a parallelised Monte Carlo simulation.
+
+        Parameters
+        ----------
+            iterations : int
+                Number of iterations for the Monte Carlo simulation.
+
+        """
+
+        # make sure that we do not create more workers than iterations
+        num_workers = min(self.num_cores, iterations)
+
+        # split the iterations across multiple workers
+        iterations_per_worker = self._split_iterations(iterations, num_workers)
+
+        print(
+            f"This machine has {cpu_count()} logical cores, using {num_workers} cores for parallel processing."
+        )
+
+        # initialize a progress queue for reporting progress
+        manager = Manager()
+        progress_queue = manager.Queue()
+
+        # create a list of arguments for the worker processes
+        args = [(iterations_per_worker[i], progress_queue) for i in range(num_workers)]
+
+        print(
+            f"Performing Monte Carlo simulation for demand: {self.demand_act['name']}"
+        )
+
+        # perform the parallelised Monte Carlo Simulation
+        with tqdm.tqdm(
+            total=iterations, desc=f"Current progress", file=sys.stderr, mininterval=0.1
+        ) as pbar:
+
+            with Pool(num_workers) as pool:
+
+                # start the worker processes
+                pool_result = pool.map_async(self.monte_carlo_worker, args)
+
+                # update the progress bar based on messages from the worker processes
+                while not pool_result.ready():
+                    while not progress_queue.empty():
+                        pbar.update(progress_queue.get())
+                        sys.stderr.flush()  # ADD THIS: Flush after each update
+
+                # Process any remaining progress updates
+                while not progress_queue.empty():
+                    pbar.update(progress_queue.get())
+                    sys.stderr.flush()
+
+                # wait for all worker processes to finish
+                pool_result.get()
+
+        # combine results from all processes
+        combined_results = {key: [] for key in self.key_list}
+        for result in pool_result.get():
+            for key in self.key_list:
+                combined_results[key].extend(result[key])
+
+        self._mc_results = combined_results
+
+    def monte_carlo_worker(self, args):
+        """
+        Worker function for Monte Carlo simulation. Each worker will perform a subset of the iterations.
+
+        Parameters
+        ----------
+            args : tuple
+                Tuple containing the following elements:
+            iterations : int
+                Number of iterations to perform in this worker.
+            progress_queue : Queue
+                Queue for reporting progress.
+
+        Returns
+        -------
+            mc_results : dict
+                Dictionary containing the Monte Carlo results
+        """
+        iterations, progress_queue = args
+
+        # re-initialize the project and Brightway infrastructure within the worker
+        # this is needed for the parallelisation because Brightway is not thread-safe
+        bw.projects.set_current(self.brightway_project)
+
+        # each worker will perform a subset of the iterations
+        worker_mc_results = {key: [] for key in self.key_list}
+
+        # load data and rebuild matrices
+        self.mc_lci_preparation(iterations)
+
+        # this is performing the actual Monte Carlo simulation
+        for j in range(iterations):
+
+            # perform the LCI (this takes a lot of time and is therefore only performed once for all impact categories)
+            self.mc_lci_calculation(slice_index=j)
+
+            # loop over impact categories to perform the LCIA
+            for i, method in enumerate(self.lcia_methods):
+                # switch the LCIA method, reload data and rebuild the characterization matrix
+                self.switch_method(method)
+                self.mc_lcia_calculation()
+
+                worker_mc_results[self.key_list[i]].append(self.score)
+
+            # Report progress for each iteration
+            progress_queue.put(1)
+
+        return worker_mc_results
+
+    def results_to_json(self, filename=None, identifier="name", folder_path=None):
+        """
+        Save Monte Carlo results to a JSON file.
+
+        Parameters
+        ----------
+            filename : str, optional
+                Name of the JSON file to save the results. If None, a default filename based on the demand activity name is used.
+            identifier : str, optional
+                Identifier to use for the filename. Default is 'name', i.e. the name of the demand activity.
+            folder_path : str, optional
+                Path to the folder where the JSON file will be saved. Default is None.
+        """
+
+        info_dict = {
+            "name": self.demand_act["name"],
+            "code": self.demand_act["code"],
+            "database": self.demand_act["database"],
+        }
+
+        if filename is None:
+            assert (
+                identifier in self.demand_act
+            ), f"Identifier '{identifier}' not found in demand activity."
+            filename = f"mc_results_{str(self.demand_act[identifier]).replace(' ','_')}_monte_carlo.json"
+
+        write_json(filename, info_dict | self._mc_results, folder_path=folder_path)
+
+    def stats_to_json(self, filename=None, identifier="name", folder_path=None):
+        """
+        Save Monte Carlo statistics to a JSON file.
+
+        Parameters
+        ----------
+            identifier : str, optional
+                Identifier to use for the filename. Default is 'name', i.e. the name of the demand activity.
+            folder_path : str, optional
+                Path to the folder where the JSON file will be saved. Default is None.
+        """
+
+        statistics = calculate_statistics(
+            self._mc_results, lcia_methods=self.lcia_methods, key_list=self.key_list
+        )
+
+        info_dict = {
+            "name": self.demand_act["name"],
+            "code": self.demand_act["code"],
+            "database": self.demand_act["database"],
+        }
+
+        if filename is None:
+            assert (
+                identifier in self.demand_act
+            ), f"Identifier '{identifier}' not found in demand activity."
+            filename = f"mc_stats_{str(self.demand_act[identifier]).replace(' ','_')}_monte_carlo.json"
+
+        write_json(filename, info_dict | statistics, folder_path=folder_path)
+
+    def get_results_dataframe(self, method=None):
+        """
+        Return Monte Carlo results as a Pandas DataFrame.
+        Useful for integration with Activity Browser.
+
+        Rows correspond to Monte Carlo iterations.
+        Columns correspond to LCIA methods (impact categories).
+
+        Returns
+        -------
+        pandas.DataFrame
+            DataFrame of shape (iterations, n_methods)
+        """
+
+        results = self.mc_results
+
+        idx = self.lcia_methods.index(method)
+        key = self.key_list[idx]
+
+        return pd.DataFrame({key: results[key]})
+
+        data = {key: results[key] for key in self.key_list}
+
+        return pd.DataFrame(data)
+
+    def get_exchange_list(self, foreground_only=False):
+        """
+        Get a list of all technosphere exchanges present in the LCA.
+
+        Returns
+        -------
+            exchange_list : list
+                List of technosphere exchanges present in the LCA.
+        """
+
+        # if the exchange list has already been generated, return it
+        if hasattr(self, "exchange_list"):
+            return self.exchange_list
+
+        # Get all activities in the technosphere matrix
+        self.load_lci_data()
+
+        all_activities = [
+            bw.Database(key[0]).get(key[1]) for key in self.activity_dict.keys()
+        ]
+
+        # Collect all technosphere exchanges for all activities
+        # exchange_list = []
+        # for act in all_activities:
+        #     exchange_list.extend(list(act.technosphere()))
+
+        exchange_list = [
+            exc
+            for act in all_activities
+            for exc in act.technosphere()
+            if not (foreground_only and "ecoinvent" in act.key[0].lower())
+        ]
+
+        # cache the exchange list for future use
+        self.exchange_list = exchange_list
+
+        return exchange_list
+
+    def set_default_uncertainty(self, foreground_only=False):
+        """
+        Add default uniform uncertainty (±10%) to technosphere exchanges missing uncertainty.
+        """
+
+        exchange_list = self.get_exchange_list(foreground_only=foreground_only)
+
+        # Add default uniform uncertainty (±10%) to exchanges missing uncertainty
+        for exc in exchange_list:
+            data = exc._data
+
+            if "uncertainty type" not in data or data["uncertainty type"] in [0, 1]:
+                amt = data.get("amount", 0)
+
+                if abs(amt) > 0:
+                    default_uncertainty = {
+                        "minimum": 0.9 * amt,
+                        "maximum": 1.1 * amt,
+                    }
+                else:
+                    default_uncertainty = {"minimum": -0.1, "maximum": 0.1}
+
+                exc._data["uncertainty type"] = (
+                    4  # corresponds to uniform distribution in stats_arrays
+                )
+                exc._data["minimum"] = default_uncertainty["minimum"]
+                exc._data["maximum"] = default_uncertainty["maximum"]
+                exc.save()
+
+    def exchange_list_to_excel(
+        self, filename=None, identifier="name", folder_path=None, foreground_only=False
+    ):
+        """
+        Save technosphere exchanges to an Excel file.
+
+        Parameters
+        ----------
+            filename : str, optional
+                Name of the Excel file to save the exchanges.
+            identifier : str, optional
+                Identifier to use for the filename. Default is 'name', i.e. the name of the demand activity.
+            folder_path : str, optional
+                Path to the folder where the Excel file will be saved. Default is None.
+        """
+
+        # get the complete list of technosphere exchanges
+        exchange_list = self.get_exchange_list(foreground_only=foreground_only)
+        print(f"Total number of technosphere exchanges: {len(exchange_list)}")
+
+        # convert exchange list to a DataFrame
+        start_time = time.time()
+        df = pd.DataFrame([exchange_to_dict(exc) for exc in exchange_list])
+        print(
+            f"Converted exchange list to DataFrame in {time.time() - start_time:.2f} seconds."
+        )
+
+        if folder_path is None:
+            folder_path = os.path.join(os.getcwd(), "results")
+
+        # create the folder if it does not exist
+        os.makedirs(folder_path, exist_ok=True)
+
+        if filename is None:
+            assert (
+                identifier in self.demand_act
+            ), f"Identifier '{identifier}' not found in demand activity."
+            filename = f"technosphere_exchanges_{str(self.demand_act[identifier]).replace(' ','_')}.xlsx"
+
+        print("folder_path", folder_path, "filename", filename)
+        start_time = time.time()
+        df.to_excel(
+            os.path.join(folder_path, filename), index=False, engine="xlsxwriter"
+        )
+        print(
+            f"Exported {len(df)} exchanges to {filename} in {time.time() - start_time:.2f} seconds."
+        )
+
+    def print_uncertainty_info(self):
+        """
+        Print summary statistics about uncertainty information in the exchanges of this LCA.
+        Uses the underlying Brightway tech_params data structure for efficient access.
+        """
+
+        if not hasattr(self, "tech_params"):
+            self.load_lci_data()  # This will populate tech_params
+
+        # Uncertainty type mapping based on stats_arrays documentation
+        uncertainty_dictionary = {
+            0: "Undefined",
+            1: "No uncertainty",
+            2: "Lognormal",
+            3: "Normal",
+            4: "Uniform",
+            5: "Triangular",
+            6: "Bernoulli",
+            7: "Discrete Uniform",
+            8: "Weibull",
+            9: "Gamma",
+            10: "Beta",
+            11: "Generalized Extreme Value",
+            12: "Student's T",
+        }
+
+        type_dictionary = {
+            -1: "unknown",
+            0: "production",
+            1: "technosphere",
+            2: "biosphere",
+            3: "substitution",
+        }
+
+        # find all technosphere exchanges in the tech_params list
+        technosphere_exchanges = [
+            param
+            for param in self.tech_params
+            if type_dictionary.get(param["type"], "other") == "technosphere"
+        ]
+
+        # Get total number of exchanges
+        total = len(technosphere_exchanges)
+
+        # Count uncertainty types
+        type_counts = {}
+        for param in technosphere_exchanges:
+            uncertainty_type = param["uncertainty_type"]
+            type_counts[uncertainty_type] = type_counts.get(uncertainty_type, 0) + 1
+
+        # Count parameters with uncertainty
+        with_uncertainty = sum(
+            count
+            for uncertainty_type, count in type_counts.items()
+            if uncertainty_type not in [0, 1]
+        )
+
+        # Print summary statistics
+        print(f"Total exchanges: {total}")
+        print(f"Exchanges with uncertainty: {with_uncertainty}")
+        if total > 0:
+            print(f"Percentage with uncertainty: {with_uncertainty/total*100:.2f}%\n")
+            print("Uncertainty type distribution:")
+            for uncertainty_type, count in type_counts.items():
+                label = uncertainty_dictionary[uncertainty_type]
+                count = type_counts.get(uncertainty_type, 0)
+                print(
+                    f"  Type {uncertainty_type} ({label}): {count} ({count/total*100:.1f}%)"
+                )
+        else:
+            print("No exchanges found.\n")
+
+    def print_uncertainty_info_old(self, foreground_only=False):
+        """
+        Print summary statistics about uncertainty information in the exchanges of this LCA.
+        Uses the underlying Brightway exchange data structure for robust access.
+
+        Parameters
+        ----------
+            foreground_only : bool, optional
+                Whether to consider only foreground exchanges. Default is False.
+        """
+
+        # Get the complete list of technosphere exchanges
+        exchange_list = self.get_exchange_list(foreground_only=foreground_only)
+
+        # Uncertainty type mapping based on stats_arrays documentation
+        uncertainty_types = {
+            0: "Undefined",
+            1: "No uncertainty",
+            2: "Lognormal",
+            3: "Normal",
+            4: "Uniform",
+            5: "Triangular",
+            6: "Bernoulli",
+            7: "Discrete Uniform",
+            8: "Weibull",
+            9: "Gamma",
+            10: "Beta",
+            11: "Generalized Extreme Value",
+            12: "Student's T",
+        }
+
+        # Convert all exchanges to dicts for robust access
+        exc_dicts = [
+            exc.as_dict() if hasattr(exc, "as_dict") else exc for exc in exchange_list
+        ]
+
+        # Get total number of exchanges and categorize them into foregorund and background
+        total = len(exc_dicts)
+        fg = [
+            exc
+            for exc in exc_dicts
+            if not (
+                "ecoinvent" in str(exc.get("input", ("",))[0]).lower()
+                or "ecoinvent" in str(exc.get("output", ("",))[0]).lower()
+            )
+        ]
+        bg = [exc for exc in exc_dicts if exc not in fg]
+
+        # Count uncertainty types
+        with_uncertainty = [
+            exc
+            for exc in exc_dicts
+            if exc.get("uncertainty type") is not None
+            and exc.get("uncertainty type") not in [0, 1]
+        ]
+        type_counts = {}
+        for exc in exc_dicts:
+            t = exc.get("uncertainty type", 0)
+            type_counts[t] = type_counts.get(t, 0) + 1
+
+        # Print summary statistics
+        print(f"Total exchanges: {total}")
+        print(f"Exchanges with uncertainty: {len(with_uncertainty)}")
+        print(f"Percentage with uncertainty: {len(with_uncertainty)/total*100:.2f}%\n")
+        print("Uncertainty type distribution:")
+        for t in range(13):
+            label = uncertainty_types[t]
+            count = type_counts.get(t, 0)
+            print(f"  Type {t} ({label}): {count} ({count/total*100:.1f}%)")
+
+    def print_stats(self, impcats=None):
+        statistics = calculate_statistics(
+            self._mc_results, lcia_methods=self.lcia_methods, key_list=self.key_list
+        )
+
+        # if impact categories are specified, filter the statistics to include only those categories
+        if impcats is not None:
+            statistics = {
+                key: stats for key, stats in statistics.items() if key in impcats
+            }
+
+        print(f"Monte Carlo results for demand: {self.demand_act['name']}")
+        for key, stats in statistics.items():
+            print(f"\nImpact category: {key}")
+            print(f"  Mean: {stats['mean']}")
+            print(f"  Std: {stats['std']}")
+            print(f"  Min: {stats['min']}")
+            print(f"  Max: {stats['max']}")
+            print("  Percentiles:")
+            for p, value in stats["percentiles"].items():
+                print(f"    {p}th percentile: {value}")
+
+
+def exchange_to_dict(exc):
+    """
+    Convert a technosphere exchange to a dictionary.
+
+    Parameters
+    ----------
+        exc : Exchange
+            Technosphere exchange to convert.
+    Returns
+    -------
+        exc_dict : dict
+            Dictionary representation of the exchange.
+
+    """
+
+    # get the keys for the input and output activities of the exchange
+    input_key = getattr(exc.input, "key")
+    output_key = getattr(exc.output, "key")
+
+    data = exc._data
+
+    exc_dict = {
+        "Input": bw.Database(input_key[0]).get(input_key[1])["name"],
+        "Input Database": input_key[0],
+        "Input Code": input_key[1],
+        "Output": bw.Database(output_key[0]).get(output_key[1])["name"],
+        "Output Database": output_key[0],
+        "Output Code": output_key[1],
+        "Amount": data.get("amount"),
+        "Unit": data.get("unit", None),
+        "Uncertainty Type": data.get("uncertainty type", None),
+        "Pedigree": data.get("pedigree", None),
+        "loc": data.get("loc", None),
+        "scale": data.get("scale", None),
+        "shape": data.get("shape", None),
+        "minimum": data.get("minimum", None),
+        "maximum": data.get("maximum", None),
+        "Formula": data.get("formula", None),
+    }
+
+    return exc_dict
+
+
+def get_lcia_methods(lcia_method_name, get_keys=False):
+    """
+    Get LCIA methods and their keys based on the provided method name.
+
+    Parameters
+    ----------
+        lcia_method_name : str
+            Name of the LCIA method (e.g., 'EF v3.1 no LT').
+
+    Returns
+    -------
+        lcia_methods : list
+            List of LCIA methods.
+        key_list : list
+            List of keys for the LCIA methods.
+    """
+
+    lcia_methods = [method for method in bw.methods if lcia_method_name in str(method)]
+    key_list = get_key_list(lcia_methods)
+
+    return lcia_methods, key_list
+
+
+def get_key_list(lcia_methods):
+    """
+    Get a list of keys for the provided LCIA methods.
+
+    Parameters
+    ----------
+        lcia_methods : list
+            List of LCIA methods.
+
+    Returns
+    -------
+        key_list : list
+            List of keys for the LCIA methods.
+    """
+
+    # here, the impact categories are renamed to a more readable format
+    key_list = []
+    for method in lcia_methods:
+        impact_cat = str(method[1])
+        impact_unit = str(bw.methods[method]["unit"])
+        key_list.append(impact_cat + " [" + impact_unit + "]")
+
+    return key_list
+
+
+def calculate_statistics(
+    mc_results, lcia_method_name=None, lcia_methods=None, key_list=None
+):
+    """
+    Calculate statistics for Monte Carlo results.
+
+    Parameters
+    ----------
+        mc_results : dict
+            Dictionary containing the Monte Carlo results.
+        lcia_methods : list
+            List of LCIA methods.
+        key_list : list
+            List of keys for the LCIA methods.
+
+    Returns
+    -------
+        mc_statistics : dict
+            Dictionary containing the calculated statistics.
+    """
+
+    if lcia_methods is None:
+        assert (
+            lcia_method_name is not None
+        ), "Either 'lcia_method_name' or 'lcia_methods' must be provided."
+        lcia_methods, key_list = get_lcia_methods(lcia_method_name)
+    else:
+        assert (
+            key_list is not None
+        ), "key_list must be provided if lcia_method_name is not provided."
+
+    # calculate statistics
+    mc_statistics = {}
+    for i in range(len(lcia_methods)):
+        percentiles = {
+            "5": np.percentile(mc_results[key_list[i]], 5),
+            "10": np.percentile(mc_results[key_list[i]], 10),
+            "25": np.percentile(mc_results[key_list[i]], 25),
+            "50": np.percentile(mc_results[key_list[i]], 50),
+            "75": np.percentile(mc_results[key_list[i]], 75),
+            "90": np.percentile(mc_results[key_list[i]], 90),
+            "95": np.percentile(mc_results[key_list[i]], 95),
+        }
+        mc_statistics[key_list[i]] = {
+            "mean": np.mean(mc_results[key_list[i]]),
+            "std": np.std(mc_results[key_list[i]]),
+            "min": float(np.min(mc_results[key_list[i]])),
+            "max": float(np.max(mc_results[key_list[i]])),
+            "percentiles": percentiles,
+        }
+
+    return mc_statistics
+
+
+def write_json(filename, dict_to_write, folder_path=None):
+    """
+    Write a dictionary to a JSON file.
+
+    Parameters
+    ----------
+    filename : str
+        Name of the JSON file to write.
+    dict_to_write : dict
+        Dictionary to write to the JSON file.
+    folder_path : str, optional
+        Path to the folder where the JSON file will be saved. If None, a default "results" folder is used.
+
+    """
+
+    if folder_path is None:
+        folder_path = os.path.join(os.getcwd(), "results")
+
+    # create the folder if it does not exist
+    os.makedirs(folder_path, exist_ok=True)
+
+    with open(os.path.join(folder_path, filename), "w") as file:
+        json.dump(dict_to_write, file, indent=4)

moca_uncertainty_lca-1.0.0/src/uncertainty_lca/run.py

@@ -0,0 +1,103 @@
+# SPDX-FileCopyrightText: 2026 Maria Höller, German Aerospace Center (DLR)
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import argparse
+import pickle
+import json
+import sys
+
+from multiprocessing import cpu_count
+
+import brightway2 as bw
+
+from .monte_carlo import MonteCarloLCA
+
+# force unbuffered output
+if hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(line_buffering=True)
+
+
+def main():
+
+    # set up argument parser
+    parser = argparse.ArgumentParser(description="Run Monte Carlo LCA simulations.")
+
+    # define expected arguments
+    parser.add_argument(
+        "--iterations",
+        type=int,
+        required=True,
+        help="Number of Monte Carlo iterations.",
+    )
+    parser.add_argument(
+        "--bw_project", type=str, required=True, help="Brightway2 project name."
+    )
+    parser.add_argument(
+        "--demand", type=str, required=True, help="JSON-encoded demand dictionary."
+    )
+    parser.add_argument(
+        "--lcia_methods",
+        type=str,
+        required=True,
+        help="JSON-encoded list of LCIA method identifiers.",
+    )
+    parser.add_argument(
+        "--output", type=str, required=True, help="Path to output pickle file."
+    )
+    parser.add_argument(
+        "--num_cores",
+        type=int,
+        required=True,
+        help="Number of CPU cores to use for parallel processing.",
+    )
+    parser.add_argument(
+        "--run_parallel",
+        type=str,
+        default="True",
+        help="Whether to run the Monte Carlo simulation in parallel (True/False).",
+    )
+
+    # parse the arguments
+    args = parser.parse_args()
+
+    # set up Brightway within the subprocess
+    bw.projects.set_current(args.bw_project)
+
+    try:
+        # the demand list looks like: ["<database_name>", "<activity_key>"]
+        demand_list = json.loads(args.demand)
+        lcia_methods_list = json.loads(args.lcia_methods)
+    except json.JSONDecodeError as e:
+        print(f"Failed to decode JSON arguments: {e}", file=sys.stderr)
+        sys.exit(2)
+
+    # build the demand dictionary for the Monte Carlo LCA
+    demand = {bw.Database(demand_list[0]).get(demand_list[1]): 1}
+
+    # convert LCIA methods to tuples
+    lcia_methods = [tuple(method) for method in lcia_methods_list]
+
+    # concert run_parallel argument to boolean
+    run_parallel = args.run_parallel.lower() == "true"
+
+    # initialize the Monte Carlo LCA
+    mc_lca = MonteCarloLCA(
+        demand,
+        lcia_methods=lcia_methods,
+        num_cores=args.num_cores,
+        run_parallel=run_parallel,
+    )
+
+    # execute the Monte Carlo simulation
+    print(f"Running Monte Carlo LCA with {args.iterations} iterations...", flush=True)
+    mc_lca.execute_monte_carlo(iterations=args.iterations)
+
+    # write the results to a file
+    with open(args.output, "wb") as f:
+        pickle.dump(mc_lca.mc_results, f)
+    print(f"Results written to {args.output}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

moca_uncertainty_lca-1.0.0/tests/test.py

@@ -0,0 +1,64 @@
+# SPDX-FileCopyrightText: 2026 Maria Höller, German Aerospace Center (DLR)
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+# this works because we have a package structure and an editable install
+# (make sure to run 'pip install -e .' in the repository root first)
+import uncertainty_lca as ulca
+
+# import standard modules
+import time
+from datetime import timedelta
+
+import brightway2 as bw
+
+
+def test_lca_monte_carlo():
+    # start a timer for time-tracking
+    start_time = time.time()
+
+    assert (
+        "moca_test_project" in bw.projects
+    ), "Test project 'moca_test_project' does not exist. Please run 'create_test_project.py' first to create the test dataset."
+
+    # setting up Brightway
+    bw.projects.set_current("moca_test_project")
+
+    # specify the LCIA method / characterisation model
+    lcia_method_name = "EF v3.1"
+
+    # build the demand dictionary for the Monte Carlo LCA
+    demand = {bw.Database("foreground").get("fg_activity_0"): 1}
+
+    # initialize the Monte Carlo LCA
+    mc_lca = ulca.MonteCarloLCA(demand, lcia_method_name)
+
+    # Print uncertainty info for the exchange list using the new method
+    mc_lca.set_default_uncertainty()
+    mc_lca.print_uncertainty_info()
+
+    # export the exchange list
+    # mc_lca.exchange_list_to_excel(foreground_only=False)
+
+    # # execute the Monte Carlo simulation
+    mc_lca.execute_monte_carlo(iterations=100)
+
+    # # retrieve the results and write them to files
+    # mc_results = mc_lca.mc_results
+    mc_lca.print_stats(impcats=["climate change [kg CO2-Eq]"])
+    # mc_lca.results_to_json()
+    # mc_lca.stats_to_json()
+
+    # end the timer and print the time elapsed
+    end_time = time.time()
+    duration = end_time - start_time
+    dur_timedelta = timedelta(seconds=int(duration))
+
+    print(
+        f"Time elapsed: {duration:.2f} seconds = {duration // 60:.0f}:{int(duration % 60):02} minutes = {dur_timedelta}"
+    )
+
+
+# this is the main function that is called when you press run
+if __name__ == "__main__":
+    test_lca_monte_carlo()