Got it, let's tackle this problem head-on. The limitation of MultiMonteCarlo only supporting a single LCIA method is definitely a pain when you need to analyze multiple impact categories—here are two practical approaches to solve this, depending on whether you want to extend the core class or work with existing functionality.

The cleanest long-term fix is to create a subclass of MultiMonteCarlo that replicates the switch_method() and characterization matrix handling logic from MonteCarloLCA. This lets you calculate multiple impact categories in a single iteration without re-running the inventory sampling.

Here's a working implementation:

from brightway2 import MultiMonteCarlo, MonteCarloLCA

class MultiMethodMonteCarlo(MultiMonteCarlo):
    def __init__(self, functional_units, methods, seed=None):
        # Initialize with the first method to set up base infrastructure
        super().__init__(functional_units, methods[0], seed=seed)
        self.all_methods = methods
        self._characterization_cache = {}  # Cache to avoid reloading method data

    def switch_method(self, method):
        """Switch to a new LCIA method, caching the characterization matrix"""
        if method not in self._characterization_cache:
            # Replicate MonteCarloLCA's logic to load the characterization matrix
            temp_lca = MonteCarloLCA(self.functional_units[0], method)
            temp_lca.load_lcia_data()
            self._characterization_cache[method] = temp_lca.C.copy()
        
        self.method = method
        self.C = self._characterization_cache[method]
        self.redo_lcia_calculation()

    def run(self, iterations):
        """Run Monte Carlo iterations and collect results for all methods"""
        results = {method: [] for method in self.all_methods}
        
        for _ in range(iterations):
            # Generate the next random inventory sample
            self.next()
            
            # Calculate impact for each method using the same inventory sample
            for method in self.all_methods:
                self.switch_method(method)
                # Calculate results for all functional units
                iteration_results = self.calculate(self.functional_units)
                results[method].append(iteration_results)
        
        return results

How this works: #

• We initialize with one method to leverage MultiMonteCarlo's existing inventory sampling logic
• switch_method() caches characterization matrices to avoid redundant IO operations
• In each iteration, we generate one inventory sample, then switch between methods to compute all impact categories without re-sampling the inventory

If you don't want to modify the core class, you can first capture all inventory samples during a MultiMonteCarlo run, then retroactively compute results for multiple LCIA methods. This is simpler but uses more memory (since you're storing full inventory matrices).

Here's how to do it:

from brightway2 import MultiMonteCarlo, LCA

# Define your functional units and a placeholder method (we only need inventory data)
functional_units = {your_activity: 1}
placeholder_method = ('some', 'method', 'you', 'have', 'installed')
iterations = 1000

# Step 1: Collect all inventory samples
mmc = MultiMonteCarlo(functional_units, placeholder_method)
inventory_samples = []

for _ in range(iterations):
    mmc.next()
    # Store copies of the current inventory matrix (A) and demand vector (f)
    inventory_samples.append((mmc.A.copy(), mmc.demand.copy()))

# Step 2: Define all LCIA methods you want to calculate
target_methods = [
    ('IPCC 2013', 'climate change', 'GWP 100a'),
    ('ReCiPe Midpoint (H)', 'freshwater eutrophication'),
    # Add your other methods here
]

# Step 3: Compute impacts for each sample and method
results = {method: [] for method in target_methods}

for A, f in inventory_samples:
    for method in target_methods:
        lca = LCA(f, method)
        lca.load_lcia_data()
        # Skip inventory calculation by using the pre-stored A matrix
        lca.redo_inventory(A)
        lca.lcia()
        results[method].append(lca.score)

Key notes for this approach: #

• Use copy() when storing mmc.A and mmc.demand to avoid overwriting data in subsequent iterations
• This is better for smaller iteration counts (e.g., <1000) to avoid excessive memory usage
• You can parallelize the post-processing step if needed (Brightway plays nicely with multiprocessing)

• Cache characterization matrices: Both approaches avoid reloading LCIA method data multiple times, which saves a ton of time
• Memory management: If you're doing 10k+ iterations, use the subclass approach (方案1) to avoid storing thousands of large inventory matrices
• Functional units: Both methods work with multiple functional units, since MultiMonteCarlo and calculate() handle them natively

内容的提问来源于stack exchange，提问作者Davide Rovelli