Fix capacity envelope calculations in CapacityEnvelope and CapacityEnvelopeAnalysis.

Author: networmix

ngraph/results_artifacts.py

@@ -271,18 +271,29 @@ def from_values(
         if not values:
             raise ValueError("Cannot create envelope from empty values list")
 
-        # Build frequency map
+        # Single pass to calculate everything efficiently
         frequencies = {}
+        total_sum = 0.0
+        sum_squares = 0.0
+        min_capacity = float("inf")
+        max_capacity = float("-inf")
+
         for value in values:
+            # Update frequency map
             frequencies[value] = frequencies.get(value, 0) + 1
 
-        # Calculate statistics
-        min_capacity = min(values)
-        max_capacity = max(values)
-        mean_capacity = sum(values) / len(values)
+            # Update statistics
+            total_sum += value
+            sum_squares += value * value
+            min_capacity = min(min_capacity, value)
+            max_capacity = max(max_capacity, value)
+
+        # Calculate derived statistics
+        n = len(values)
+        mean_capacity = total_sum / n
 
-        # Calculate standard deviation
-        variance = sum((x - mean_capacity) ** 2 for x in values) / len(values)
+        # Use computational formula for variance: Var(X) = E[X²] - (E[X])²
+        variance = (sum_squares / n) - (mean_capacity * mean_capacity)
         stdev_capacity = variance**0.5
 
         return cls(
@@ -294,7 +305,7 @@ def from_values(
             max_capacity=max_capacity,
             mean_capacity=mean_capacity,
             stdev_capacity=stdev_capacity,
-            total_samples=len(values),
+            total_samples=n,
         )
 
     def to_dict(self) -> Dict[str, Any]:

ngraph/workflow/capacity_envelope_analysis.py

@@ -441,14 +441,17 @@ def run(self, scenario: "Scenario") -> None:
                 if key not in pattern_map:
                     # Get capacity matrix for this pattern
                     capacity_matrix = {}
-                    for flow_key, envelope_data in envelopes.items():
+                    for flow_key, _envelope_data in envelopes.items():
                         # Find capacity value for this pattern's iteration
                         pattern_iter = pattern["iteration_index"]
-                        if pattern_iter < len(envelope_data["frequencies"]):
+                        flow_tuple = self._parse_flow_key(flow_key)
+                        if flow_tuple in samples and pattern_iter < len(
+                            samples[flow_tuple]
+                        ):
                             # Get capacity value from original samples
-                            capacity_matrix[flow_key] = samples[
-                                self._parse_flow_key(flow_key)
-                            ][pattern_iter]
+                            capacity_matrix[flow_key] = samples[flow_tuple][
+                                pattern_iter
+                            ]
 
                     pattern_map[key] = FailurePatternResult(
                         excluded_nodes=pattern["excluded_nodes"],
@@ -841,8 +844,14 @@ def _build_capacity_envelopes(
         Returns:
             Dictionary mapping flow keys to serialized CapacityEnvelope data.
         """
-        logger.debug(f"Building capacity envelopes from {len(samples)} flow pairs")
+        start_time = time.time()
+        total_samples = sum(len(values) for values in samples.values())
+        logger.info(
+            f"Building capacity envelopes from {len(samples)} flow pairs with {total_samples:,} total samples"
+        )
+
         envelopes = {}
+        processed_flows = 0
 
         for (src_label, dst_label), capacity_values in samples.items():
             if not capacity_values:
@@ -863,14 +872,26 @@ def _build_capacity_envelopes(
             )
             envelopes[flow_key] = envelope.to_dict()
 
+            processed_flows += 1
+
             # Detailed logging with statistics
             logger.debug(
                 f"Created frequency-based envelope for {flow_key}: {envelope.total_samples} samples, "
                 f"min={envelope.min_capacity:.2f}, max={envelope.max_capacity:.2f}, "
                 f"mean={envelope.mean_capacity:.2f}, unique_values={len(envelope.frequencies)}"
             )
 
-        logger.debug(f"Successfully created {len(envelopes)} capacity envelopes")
+            # Progress logging for large numbers of flows
+            if len(samples) > 100 and processed_flows % max(1, len(samples) // 10) == 0:
+                elapsed = time.time() - start_time
+                logger.info(
+                    f"Envelope building progress: {processed_flows}/{len(samples)} flows processed in {elapsed:.1f}s"
+                )
+
+        elapsed_time = time.time() - start_time
+        logger.info(
+            f"Generated {len(envelopes)} capacity envelopes in {elapsed_time:.2f} seconds"
+        )
         return envelopes