goad-py 0.6.0__cp38-abi3-musllinux_1_2_aarch64.whl → 0.7.0__cp38-abi3-musllinux_1_2_aarch64.whl

goad_py/phips_convergence.py

@@ -6,14 +6,21 @@ which requires Custom binning with PHIPS detector geometry and post-processing
 to compute mean DSCS at each of the 20 PHIPS detectors.
 """
 
-from dataclasses import dataclass
-from typing import List, Dict, Optional, Tuple
-import numpy as np
 import os
 import random
+from dataclasses import dataclass
 from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+from rich.console import Console
+
 from . import _goad_py as goad
 from .convergence import ConvergenceResults
+from .convergence_display import (
+    ArrayConvergenceVariable,
+    ConvergenceDisplay,
+)
 
 
 @dataclass
@@ -76,6 +83,8 @@ class PHIPSConvergence:
             min_batches: Minimum number of batches before allowing convergence
         """
         self.settings = settings
+        # Enable quiet mode to suppress Rust progress bars
+        self.settings.quiet = True
         self.convergable = convergable
         self.batch_size = batch_size
         self.max_orientations = max_orientations
@@ -109,6 +118,26 @@ class PHIPSConvergence:
         # Accumulated PHIPS DSCS for final average
         self.phips_dscs_sum = None
 
+        # Rich console
+        self._console = Console()
+
+        # Create display variable for PHIPS DSCS
+        display_variable = ArrayConvergenceVariable(
+            name="phips_dscs",
+            tolerance=convergable.tolerance,
+            tolerance_type=convergable.tolerance_type,
+            indices=convergable.detector_indices,
+        )
+
+        # Initialize display system
+        self._display = ConvergenceDisplay(
+            variables=[display_variable],
+            batch_size=self.batch_size,
+            min_batches=self.min_batches,
+            convergence_type=self._get_convergence_type(),
+            console=self._console,
+        )
+
     def _compute_phips_dscs_from_mueller2d(self, results: goad.Results) -> np.ndarray:
         """
         Compute mean DSCS at each of 20 PHIPS detectors from Custom binning results.
@@ -262,59 +291,43 @@ class PHIPSConvergence:
 
         return converged
 
-    def _print_progress(self, converged: bool):
-        """Print convergence progress."""
-        mean_dscs, sem_dscs = self._calculate_phips_mean_and_sem()
-
-        # Determine which detectors to display
-        if self.convergable.detector_indices is not None:
-            check_indices = self.convergable.detector_indices
+    def _get_convergence_type(self) -> str:
+        """Get the convergence type name for display."""
+        class_name = self.__class__.__name__
+        if class_name == "PHIPSEnsembleConvergence":
+            return "PHIPS Ensemble"
+        elif class_name == "PHIPSConvergence":
+            return "PHIPS"
         else:
-            check_indices = np.where(~np.isnan(mean_dscs))[0]
-
-        if len(check_indices) == 0:
-            print(f"  PHIPS DSCS: No valid detectors")
-            return
-
-        # Find worst-case detector (highest relative SEM)
-        mean_subset = mean_dscs[check_indices]
-        sem_subset = sem_dscs[check_indices]
-
-        with np.errstate(divide="ignore", invalid="ignore"):
-            relative_sem = np.where(
-                mean_subset != 0, sem_subset / np.abs(mean_subset), np.inf
-            )
-
-        worst_idx_in_subset = np.argmax(relative_sem)
-        worst_detector_idx = check_indices[worst_idx_in_subset]
-        worst_theta = self.detector_centers[worst_detector_idx]
-        worst_mean = mean_subset[worst_idx_in_subset]
-        worst_sem = sem_subset[worst_idx_in_subset]
-        worst_rel_sem = relative_sem[worst_idx_in_subset]
+            return class_name
 
-        # Count converged detectors
-        if self.convergable.tolerance_type == "relative":
-            converged_mask = relative_sem < self.convergable.tolerance
-        else:
-            converged_mask = sem_subset < self.convergable.tolerance
+    def _get_detector_angles(self, variable: str) -> np.ndarray:
+        """Get detector angles for PHIPS detectors."""
+        return self.detector_centers
 
-        n_converged = np.sum(converged_mask)
-        n_total = len(check_indices)
+    def _get_phips_stats(self, variable: str) -> Tuple[float, float]:
+        """Get mean and SEM for a single PHIPS detector (not used for array display)."""
+        # This is not used since PHIPS uses array display, but required by interface
+        return 0.0, 0.0
 
-        status = "✓" if converged else "..."
+    def _update_convergence_history(self):
+        """Update convergence history with current worst-case SEM."""
+        mean_dscs, sem_dscs = self._calculate_phips_mean_and_sem()
 
-        if self.convergable.tolerance_type == "relative":
-            current_str = f"{worst_rel_sem * 100:.2f}%"
-            target_str = f"{self.convergable.tolerance * 100:.2f}%"
-        else:
-            current_str = f"{worst_sem:.4g}"
-            target_str = f"{self.convergable.tolerance:.4g}"
+        if len(mean_dscs) > 0:
+            # Find worst-case detector
+            if self.convergable.tolerance_type == "relative":
+                with np.errstate(divide="ignore", invalid="ignore"):
+                    relative_sem = np.where(
+                        mean_dscs != 0, sem_dscs / np.abs(mean_dscs), np.inf
+                    )
+                worst_sem = np.max(relative_sem)
+            else:
+                worst_sem = np.max(sem_dscs)
 
-        print(
-            f"  PHIPS DSCS: {n_converged}/{n_total} detectors converged | "
-            f"Worst θ={worst_theta:.1f}°: {worst_mean:.4g} | "
-            f"SEM: {current_str} (target: {target_str}) {status}"
-        )
+            self.convergence_history.append(
+                (self.n_orientations, "phips_dscs", worst_sem)
+            )
 
     def run(self) -> ConvergenceResults:
         """
@@ -323,54 +336,68 @@ class PHIPSConvergence:
         Returns:
             ConvergenceResults with PHIPS DSCS values
         """
-        print(f"\nStarting PHIPS convergence study:")
-        print(f"  Batch size: {self.batch_size}")
-        print(f"  Max orientations: {self.max_orientations}")
-        print(
-            f"  Tolerance: {self.convergable.tolerance * 100:.1f}% ({self.convergable.tolerance_type})"
-        )
-        print(f"  Min batches: {self.min_batches}")
-
+        iteration = 0
         converged = False
 
-        while not converged and self.n_orientations < self.max_orientations:
-            # Create orientations for this batch
-            orientations = goad.create_uniform_orientation(self.batch_size)
-            self.settings.orientation = orientations
-
-            # Run MultiProblem
-            mp = goad.MultiProblem(self.settings)
-            mp.py_solve()
-
-            # Update statistics
-            self._update_statistics(mp.results, self.batch_size)
-
-            # Check convergence
-            converged = self._check_convergence()
-
-            # Print progress
-            min_required = self.min_batches * self.batch_size
-            if self.n_orientations < min_required:
-                print(
-                    f"\nBatch {len(self.batch_data)} ({self.n_orientations}/{min_required} total orientations, min not reached):"
-                )
-            else:
-                print(
-                    f"\nBatch {len(self.batch_data)} ({self.n_orientations} total orientations, min {min_required} reached):"
-                )
-            self._print_progress(converged)
-
-            # Store history
-            mean_dscs, sem_dscs = self._calculate_phips_mean_and_sem()
-            # Use worst-case SEM for history
-            valid_mask = ~np.isnan(mean_dscs)
-            if np.any(valid_mask):
-                with np.errstate(divide="ignore", invalid="ignore"):
-                    relative_sem = sem_dscs[valid_mask] / np.abs(mean_dscs[valid_mask])
-                worst_sem = np.max(relative_sem)
-                self.convergence_history.append(
-                    (self.n_orientations, "phips_dscs", worst_sem)
+        # Create Live context for smooth updating display
+        with self._display.create_live_context() as live:
+            # Show initial display before first batch
+            initial_display = self._display.build_display(
+                iteration=0,
+                n_orientations=self.n_orientations,
+                get_stats=self._get_phips_stats,
+                get_array_stats=lambda var: self._calculate_phips_mean_and_sem(),
+                get_bin_labels=self._get_detector_angles,
+                power_ratio=None,
+                geom_info=None,
+            )
+            live.update(initial_display)
+
+            while not converged and self.n_orientations < self.max_orientations:
+                iteration += 1
+
+                # Create orientations for this batch
+                orientations = goad.create_uniform_orientation(self.batch_size)
+                self.settings.orientation = orientations
+
+                # Run MultiProblem with error handling for bad geometries
+                try:
+                    mp = goad.MultiProblem(self.settings)
+                    mp.py_solve()
+                except Exception as e:
+                    # Geometry loading failed (bad faces, degenerate geometry, etc.)
+                    # For single-geometry convergence, we can't skip - must raise error
+                    error_msg = (
+                        f"Failed to initialize MultiProblem with geometry '{self.settings.geom_path}': {e}\n"
+                        f"Please check geometry file for:\n"
+                        f"  - Degenerate faces (area = 0)\n"
+                        f"  - Non-planar geometry\n"
+                        f"  - Faces that are too small\n"
+                        f"  - Invalid mesh topology\n"
+                        f"  - Geometry file corruption"
+                    )
+                    raise type(e)(error_msg) from e
+
+                # Update statistics
+                self._update_statistics(mp.results, self.batch_size)
+
+                # Update convergence history
+                self._update_convergence_history()
+
+                # Check convergence
+                converged = self._check_convergence()
+
+                # Update live display
+                display = self._display.build_display(
+                    iteration=iteration,
+                    n_orientations=self.n_orientations,
+                    get_stats=self._get_phips_stats,
+                    get_array_stats=lambda var: self._calculate_phips_mean_and_sem(),
+                    get_bin_labels=self._get_detector_angles,
+                    power_ratio=None,
+                    geom_info=None,
                 )
+                live.update(display)
 
         # Compute final results
         mean_dscs, sem_dscs = self._calculate_phips_mean_and_sem()
@@ -389,28 +416,13 @@ class PHIPSConvergence:
             else f"Did not converge within {self.max_orientations} orientations",
         )
 
-        # Print summary
-        print(f"\n{'=' * 60}")
+        # Print final summary
         if converged:
-            print(f"✓ Converged after {self.n_orientations} orientations")
+            print(f"\nConverged after {self.n_orientations} orientations.")
         else:
-            print(f"✗ Did not converge (reached {self.n_orientations} orientations)")
-        print(f"{'=' * 60}")
-
-        # Print detector summary
-        print(f"\nPHIPS Detector DSCS Summary:")
-        valid_mask = ~np.isnan(mean_dscs)
-        for i in range(self.NUM_DETECTORS):
-            theta = self.detector_centers[i]
-            if valid_mask[i]:
-                mean_val = mean_dscs[i]
-                sem_val = sem_dscs[i]
-                rel_sem = sem_val / abs(mean_val) * 100
-                print(
-                    f"  Detector {i:2d} (θ={theta:6.1f}°): {mean_val:.6e} ± {sem_val:.6e} ({rel_sem:.2f}%)"
-                )
-            else:
-                print(f"  Detector {i:2d} (θ={theta:6.1f}°): No data")
+            print(
+                f"\nWarning: Did not converge within {self.max_orientations} orientations"
+            )
 
         return results
 
@@ -480,65 +492,93 @@ class PHIPSEnsembleConvergence(PHIPSConvergence):
         Returns:
             ConvergenceResults with ensemble-averaged PHIPS DSCS values
         """
-        print(f"\nStarting PHIPS Ensemble convergence study:")
-        print(f"  Geometry files: {len(self.geom_files)}")
-        print(f"  Batch size: {self.batch_size}")
-        print(f"  Max orientations: {self.max_orientations}")
-        print(
-            f"  Tolerance: {self.convergable.tolerance * 100:.1f}% ({self.convergable.tolerance_type})"
-        )
-        print(f"  Min batches: {self.min_batches}")
-
+        iteration = 0
         converged = False
-
-        while not converged and self.n_orientations < self.max_orientations:
-            # Randomly select a geometry file for this batch
-            geom_file = random.choice(self.geom_files)
-            geom_path = os.path.join(self.geom_dir, geom_file)
-
-            # Create orientations for this batch
-            orientations = goad.create_uniform_orientation(self.batch_size)
-
-            # Update settings with selected geometry and orientations
-            self.settings.geom_path = geom_path
-            self.settings.orientation = orientations
-
-            # Run MultiProblem
-            mp = goad.MultiProblem(self.settings)
-            mp.py_solve()
-
-            # Update statistics
-            self._update_statistics(mp.results, self.batch_size)
-
-            # Check convergence
-            converged = self._check_convergence()
-
-            # Print progress (with geometry info)
-            min_required = self.min_batches * self.batch_size
-            if self.n_orientations < min_required:
-                print(
-                    f"\nBatch {len(self.batch_data)} ({self.n_orientations}/{min_required} total orientations, min not reached) - Geometry: {geom_file}"
-                )
-            else:
-                print(
-                    f"\nBatch {len(self.batch_data)} ({self.n_orientations} total orientations, min {min_required} reached) - Geometry: {geom_file}"
-                )
-            self._print_progress(converged)
-
-            # Store history
-            mean_dscs, sem_dscs = self._calculate_phips_mean_and_sem()
-            valid_mask = ~np.isnan(mean_dscs)
-            if np.any(valid_mask):
-                with np.errstate(divide="ignore", invalid="ignore"):
-                    relative_sem = sem_dscs[valid_mask] / np.abs(mean_dscs[valid_mask])
-                worst_sem = np.max(relative_sem)
-                self.convergence_history.append(
-                    (self.n_orientations, "phips_dscs", worst_sem)
+        skipped_geometries = []  # Track skipped geometry files
+
+        # Create Live context for smooth updating display
+        with self._display.create_live_context() as live:
+            # Show initial display before first batch
+            initial_display = self._display.build_display(
+                iteration=0,
+                n_orientations=self.n_orientations,
+                get_stats=self._get_phips_stats,
+                get_array_stats=lambda var: self._calculate_phips_mean_and_sem(),
+                get_bin_labels=self._get_detector_angles,
+                power_ratio=None,
+                geom_info=None,
+            )
+            live.update(initial_display)
+
+            while not converged and self.n_orientations < self.max_orientations:
+                iteration += 1
+
+                # Randomly select a geometry file for this batch
+                geom_file = random.choice(self.geom_files)
+                geom_path = os.path.join(self.geom_dir, geom_file)
+
+                # Create orientations for this batch
+                orientations = goad.create_uniform_orientation(self.batch_size)
+
+                # Update settings with selected geometry and orientations
+                self.settings.geom_path = geom_path
+                self.settings.orientation = orientations
+
+                # Run MultiProblem
+                try:
+                    mp = goad.MultiProblem(self.settings)
+                    mp.py_solve()
+                except Exception as e:
+                    # Geometry loading failed (bad faces, degenerate geometry, etc.)
+                    print(f"\nWarning: Skipping geometry '{geom_file}': {e}")
+                    skipped_geometries.append(geom_file)
+
+                    # Check if all geometries have been skipped
+                    if len(skipped_geometries) >= len(self.geom_files):
+                        raise ValueError(
+                            f"All {len(self.geom_files)} geometry files failed to load. "
+                            "Please check geometry files for degenerate faces, non-planar geometry, "
+                            "or faces that are too small."
+                        )
+
+                    # Skip this iteration without updating statistics
+                    continue
+
+                # Update statistics
+                self._update_statistics(mp.results, self.batch_size)
+
+                # Update convergence history
+                self._update_convergence_history()
+
+                # Check convergence
+                converged = self._check_convergence()
+
+                # Update live display with geometry info
+                geom_info = f"Geom: {geom_file}"
+                display = self._display.build_display(
+                    iteration=iteration,
+                    n_orientations=self.n_orientations,
+                    get_stats=self._get_phips_stats,
+                    get_array_stats=lambda var: self._calculate_phips_mean_and_sem(),
+                    get_bin_labels=self._get_detector_angles,
+                    power_ratio=None,
+                    geom_info=geom_info,
                 )
+                live.update(display)
 
         # Compute final results
         mean_dscs, sem_dscs = self._calculate_phips_mean_and_sem()
 
+        # Prepare warning message
+        warning = None
+        if not converged:
+            warning = f"Did not converge within {self.max_orientations} orientations"
+
+        # Add skipped geometries info to warning
+        if skipped_geometries:
+            skipped_msg = f"Skipped {len(skipped_geometries)} bad geometries"
+            warning = f"{warning} | {skipped_msg}" if warning else skipped_msg
+
         # Create results
         results = ConvergenceResults(
             converged=converged,
@@ -548,33 +588,21 @@ class PHIPSEnsembleConvergence(PHIPSConvergence):
             mueller_1d=None,
             mueller_2d=None,
             convergence_history=self.convergence_history,
-            warning=None
-            if converged
-            else f"Did not converge within {self.max_orientations} orientations",
+            warning=warning,
         )
 
-        # Print summary
-        print(f"\n{'=' * 60}")
+        # Print final summary
         if converged:
-            print(f"✓ Ensemble Converged after {self.n_orientations} orientations")
+            print(f"\nEnsemble converged after {self.n_orientations} orientations.")
         else:
-            print(f"✗ Did not converge (reached {self.n_orientations} orientations)")
-        print(f"  Geometries sampled: {len(self.geom_files)}")
-        print(f"{'=' * 60}")
-
-        # Print detector summary
-        print(f"\nPHIPS Detector DSCS Summary (Ensemble-Averaged):")
-        valid_mask = ~np.isnan(mean_dscs)
-        for i in range(self.NUM_DETECTORS):
-            theta = self.detector_centers[i]
-            if valid_mask[i]:
-                mean_val = mean_dscs[i]
-                sem_val = sem_dscs[i]
-                rel_sem = sem_val / abs(mean_val) * 100
-                print(
-                    f"  Detector {i:2d} (θ={theta:6.1f}°): {mean_val:.6e} ± {sem_val:.6e} ({rel_sem:.2f}%)"
-                )
-            else:
-                print(f"  Detector {i:2d} (θ={theta:6.1f}°): No data")
+            print(
+                f"\nWarning: Did not converge within {self.max_orientations} orientations"
+            )
+
+        # Report skipped geometries if any
+        if skipped_geometries:
+            print(
+                f"Note: Skipped {len(skipped_geometries)} geometry file(s) due to errors"
+            )
 
         return results

goad_py/unified_convergence.py

@@ -217,11 +217,11 @@ class PHIPSMode(ConvergenceMode):
 class BeamTracingConfig:
     """Beam tracing performance and accuracy parameters."""
 
-    beam_power_threshold: float = 0.05
-    beam_area_threshold_fac: float = 4.0
-    cutoff: float = 0.001
-    max_rec: int = 100
-    max_tir: int = 100
+    beam_power_threshold: float = 0.005
+    beam_area_threshold_fac: float = 0.001
+    cutoff: float = 0.999
+    max_rec: int = 10
+    max_tir: int = 10
 
     def __post_init__(self):
         """Validate beam tracing parameters."""
@@ -283,7 +283,7 @@ class AdvancedConfig:
     mapping: Optional[Any] = (
         "ApertureDiffraction"  # String that will be converted to enum in __post_init__
     )
-    coherence: bool = False
+    coherence: bool = True
     fov_factor: Optional[float] = None
 
     def __post_init__(self):
@@ -1071,11 +1071,11 @@ def run_convergence(
             - n_phi: Number of phi bins for standard mode (default: 181)
 
             # Beam tracing parameters
-            - beam_power_threshold: Beam power threshold (default: 0.05)
-            - beam_area_threshold_fac: Beam area threshold factor (default: 4.0)
-            - cutoff: Ray power cutoff (default: 0.001)
-            - max_rec: Max recursion depth (default: 100)
-            - max_tir: Max TIR bounces (default: 100)
+            - beam_power_threshold: Beam power threshold (default: 0.005)
+            - beam_area_threshold_fac: Beam area threshold factor (default: 0.001)
+            - cutoff: Ray power cutoff (default: 0.999)
+            - max_rec: Max recursion depth (default: 10)
+            - max_tir: Max TIR bounces (default: 10)
 
             # Geometry transformations
             - scale: Problem scaling factor - scales entire problem including geometry,
@@ -1086,7 +1086,7 @@ def run_convergence(
 
             # Advanced configuration
             - mapping: DSCS mapping scheme (default: goad.Mapping.ApertureDiffraction)
-            - coherence: Enable coherent scattering (default: False)
+            - coherence: Enable coherent scattering (default: True)
             - fov_factor: Field of view factor (optional)
 
             # Reproducibility
@@ -1136,11 +1136,11 @@ def run_convergence(
     """
     # Extract beam tracing parameters from kwargs
     beam_tracing = BeamTracingConfig(
-        beam_power_threshold=kwargs.pop("beam_power_threshold", 0.05),
-        beam_area_threshold_fac=kwargs.pop("beam_area_threshold_fac", 4.0),
-        cutoff=kwargs.pop("cutoff", 0.001),
-        max_rec=kwargs.pop("max_rec", 100),
-        max_tir=kwargs.pop("max_tir", 100),
+        beam_power_threshold=kwargs.pop("beam_power_threshold", 0.005),
+        beam_area_threshold_fac=kwargs.pop("beam_area_threshold_fac", 0.001),
+        cutoff=kwargs.pop("cutoff", 0.999),
+        max_rec=kwargs.pop("max_rec", 10),
+        max_tir=kwargs.pop("max_tir", 10),
     )
 
     # Extract geometry transform parameters
@@ -1153,7 +1153,7 @@ def run_convergence(
     # Extract advanced configuration parameters
     advanced_config = AdvancedConfig(
         mapping=kwargs.pop("mapping", "ApertureDiffraction"),
-        coherence=kwargs.pop("coherence", False),
+        coherence=kwargs.pop("coherence", True),
         fov_factor=kwargs.pop("fov_factor", None),
     )
 

{goad_py-0.6.0.dist-info → goad_py-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: goad-py
-Version: 0.6.0
+Version: 0.7.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Physics
@@ -17,6 +17,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
 Requires-Dist: numpy>=1.20.0
 Requires-Dist: toml>=0.10.0
+Requires-Dist: rich>=13.0.0
 Summary: Physical optics light scattering computation
 Keywords: light-scattering,optics,simulation,scientific-computing,physics
 Home-Page: https://github.com/hballington12/goad

goad_py-0.7.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+goad_py-0.7.0.dist-info/METADATA,sha256=0_d3FTncDZ9MrOT3XWx-LpLlVW_kRzyVm8D3Bd2PH1Q,3266
+goad_py-0.7.0.dist-info/WHEEL,sha256=bITaocPl86jMm-S2cO-6dnFV3lXGZ1OL6ueZKGDGDMY,106
+goad_py.libs/libgcc_s-39080030.so.1,sha256=fIO6GHOh8Ft9CR0Geu7wSUb9Xnl122iTtrxQQ9TAkTQ,789673
+goad_py.libs/libstdc++-cedf4250.so.6,sha256=ahluTdjW3ViH_6W4-dRp01QgMtKg6f8XkwQdWeci4q8,22443689
+goad_py/__init__.py,sha256=iGJg-Oj9btk4I4GITkE7olNRm38uFRjENMJqXaDJmpM,1083
+goad_py/_goad_py.abi3.so,sha256=kJF-rqUjrRf1_UPBDCXHU5PJzQT9rzXhBEBJ4XEEGlQ,2297769
+goad_py/convergence.py,sha256=gbf8-uQTpCltCO3MrhVckobSP-uM2lxOiYocB6YSBTs,32682
+goad_py/convergence_display.py,sha256=2V_kyARZ504-pJNjiWO-Zqd5S1z8leTJ-A86c4r382w,16672
+goad_py/goad_py.pyi,sha256=7Y79-TV-NjEN8DWPEqSRGQ7alCrkylL6y1ZK8d6FYSg,14502
+goad_py/phips_convergence.py,sha256=U_2r40lDza6FO0VDo-FD6KxaKjo9gDdVfm01StqYKMU,22765
+goad_py/unified_convergence.py,sha256=3R4D_bVD-u-XbkaZ4R_BcVGZpwKoq8S0OZ-My-Nlxm0,49212
+goad_py-0.7.0.dist-info/RECORD,,

goad_py-0.6.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-goad_py-0.6.0.dist-info/METADATA,sha256=CtiEjICRynM820bMQscUyTLqIUx3XHtPhH-PE3_4kek,3238
-goad_py-0.6.0.dist-info/WHEEL,sha256=bITaocPl86jMm-S2cO-6dnFV3lXGZ1OL6ueZKGDGDMY,106
-goad_py.libs/libgcc_s-39080030.so.1,sha256=fIO6GHOh8Ft9CR0Geu7wSUb9Xnl122iTtrxQQ9TAkTQ,789673
-goad_py.libs/libstdc++-cedf4250.so.6,sha256=ahluTdjW3ViH_6W4-dRp01QgMtKg6f8XkwQdWeci4q8,22443689
-goad_py/__init__.py,sha256=iGJg-Oj9btk4I4GITkE7olNRm38uFRjENMJqXaDJmpM,1083
-goad_py/_goad_py.abi3.so,sha256=DYPrCyfGW4eulvzkbBcxecbDbA4Nezj7NbV2LYyaw3Q,2297745
-goad_py/convergence.py,sha256=hXVvlfjVEKpOlxoiJ_NGDzDlCoSqyo6V7g3OxNp2xUA,35209
-goad_py/goad_py.pyi,sha256=7Y79-TV-NjEN8DWPEqSRGQ7alCrkylL6y1ZK8d6FYSg,14502
-goad_py/phips_convergence.py,sha256=sA7XIjKRLaRTIDCTjgq0i6xFxYhTD1rcu6ZMYAetDPE,21803
-goad_py/unified_convergence.py,sha256=jC9z_YXX3za-nL5jdYxfw6G13moOCZT9Bp7bI9FIzCg,49212
-goad_py-0.6.0.dist-info/RECORD,,