integrate_module 0.99.1__py3-none-any.whl

integrate/integrate_timing_cli.py

@@ -0,0 +1,407 @@
+#!/usr/bin/env python
+"""
+INTEGRATE Timing CLI
+
+Command-line interface for timing benchmarks of the INTEGRATE workflow.
+This module imports timing functions from the main integrate module.
+
+Author: Thomas Mejer Hansen
+Email: tmeha@geo.au.dk
+"""
+
+# Configure matplotlib for non-interactive plotting
+import matplotlib
+matplotlib.use('Agg')  # Use non-interactive backend
+import matplotlib.pyplot as plt
+
+# Import timing functions from integrate module
+try:
+    # Try relative import first (when run as module)
+    from . import integrate as ig
+    from .integrate import timing_compute, timing_plot, allocate_large_page
+except ImportError:
+    try:
+        # Try absolute import (when run directly)
+        import integrate as ig
+        from integrate import timing_compute, timing_plot, allocate_large_page
+    except ImportError:
+        print("Error: Could not import integrate module. Please ensure it is properly installed.")
+        import sys
+        sys.exit(1)
+
+
+def print_timing_summary(f_timing):
+    """Print a concise summary of timing benchmark results."""
+    import numpy as np
+
+    try:
+        data = np.load(f_timing)
+        T_prior = data['T_prior']
+        T_forward = data['T_forward']
+        T_rejection = data['T_rejection']
+        T_poststat = data['T_poststat']
+        N_arr = data['N_arr']
+        Nproc_arr = data['Nproc_arr']
+
+        try:
+            T_total = data['T_total']
+        except:
+            T_total = T_prior + T_forward + T_rejection + T_poststat
+            
+        try:
+            nobs = data['nobs']
+        except:
+            nobs = 11693  # Default fallback value
+
+        try:
+            backend = str(data['backend'])
+        except:
+            backend = 'numpy'
+
+        print(f"\n{'='*60}")
+        print(f"INTEGRATE Timing Summary: {f_timing}")
+        print(f"Rejection backend: {backend}")
+        print(f"{'='*60}")
+
+        print(f"\nDataset sizes tested: {N_arr.astype(int)}")
+        print(f"CPU counts tested: {Nproc_arr.astype(int)}")
+
+        # Calculate key performance metrics
+        T_forward_sounding_per_sec = N_arr[:,np.newaxis]/T_forward
+        T_forward_sounding_per_sec_per_cpu = T_forward_sounding_per_sec/Nproc_arr[np.newaxis,:]
+
+        # For rejection sampling, use correct metric: data soundings per second (not lookup table models per second)
+        T_rejection_per_data = nobs/T_rejection  # Data soundings per second
+        T_rejection_per_data_per_cpu = T_rejection_per_data/Nproc_arr[np.newaxis,:]
+
+        # Find best performance cases (remove NaN values)
+        forward_valid = ~np.isnan(T_forward_sounding_per_sec)
+        rejection_valid = ~np.isnan(T_rejection_per_data)
+
+        if np.any(forward_valid):
+            max_forward_total = np.nanmax(T_forward_sounding_per_sec)
+            max_forward_per_cpu = np.nanmax(T_forward_sounding_per_sec_per_cpu)
+
+            print(f"\n🚀 FORWARD MODELING PERFORMANCE:")
+            print(f"   Max soundings/sec (all CPUs): {max_forward_total:.1f}")
+            print(f"   Max soundings/sec/CPU:        {max_forward_per_cpu:.2f}")
+
+            # Show performance for different CPU counts
+            print(f"\n   Forward Performance by CPU Count:")
+            for j, ncpu in enumerate(Nproc_arr):
+                if np.any(~np.isnan(T_forward_sounding_per_sec[:, j])):
+                    best_perf = np.nanmax(T_forward_sounding_per_sec[:, j])
+                    best_perf_per_cpu = best_perf / ncpu
+                    print(f"     {int(ncpu):2d} CPUs: {best_perf:8.1f} sounds/sec ({best_perf_per_cpu:.2f} per CPU)")
+
+        if np.any(rejection_valid):
+            # Focus on largest lookup table (largest N value)
+            max_n_idx = np.argmax(N_arr)
+            
+            # Extract rejection performance for largest lookup table only
+            T_rejection_largest = T_rejection_per_data[max_n_idx, :]
+            T_rejection_largest_per_cpu = T_rejection_per_data_per_cpu[max_n_idx, :]
+            
+            # Check if we have valid data for the largest lookup table
+            if np.any(~np.isnan(T_rejection_largest)):
+                max_rejection_total = np.nanmax(T_rejection_largest)
+                max_rejection_per_cpu = np.nanmax(T_rejection_largest_per_cpu)
+                
+                # Find which CPU count achieved the maximum performance
+                max_total_cpu_idx = np.nanargmax(T_rejection_largest)
+                max_per_cpu_cpu_idx = np.nanargmax(T_rejection_largest_per_cpu)
+                max_total_cpus = int(Nproc_arr[max_total_cpu_idx])
+                max_per_cpu_cpus = int(Nproc_arr[max_per_cpu_cpu_idx])
+
+                print(f"\n⚡ REJECTION SAMPLING PERFORMANCE (Largest Lookup Table: {int(N_arr[max_n_idx]):,} models):")
+                print(f"   Max data soundings/sec (all CPUs): {max_rejection_total:.1f} (achieved with {max_total_cpus} CPUs)")
+                print(f"   Max data soundings/sec/CPU:       {max_rejection_per_cpu:.2f} (achieved with {max_per_cpu_cpus} CPUs)")
+
+                # Show performance for different CPU counts (largest lookup table only)
+                print(f"\n   Rejection Performance by CPU Count (Largest Lookup Table):")
+                for j, ncpu in enumerate(Nproc_arr):
+                    if not np.isnan(T_rejection_largest[j]):
+                        best_perf = T_rejection_largest[j]
+                        best_perf_per_cpu = best_perf / ncpu
+                        print(f"     {int(ncpu):2d} CPUs: {best_perf:8.1f} data sounds/sec ({best_perf_per_cpu:.2f} per CPU)")
+                    elif int(ncpu) == 1:
+                        # Always show 1 CPU entry even if data is NaN, for reference
+                        print(f"     {int(ncpu):2d} CPUs: No valid data")
+            else:
+                print(f"\n⚡ REJECTION SAMPLING PERFORMANCE: No valid data for largest lookup table ({int(N_arr[max_n_idx]):,} models)")
+
+        # Overall timing breakdown for best case using largest lookup table
+        if np.any(~np.isnan(T_total)):
+            # Focus on largest lookup table (largest N value)
+            max_n_idx = np.argmax(N_arr)
+            
+            # Extract timing data for largest lookup table only
+            T_total_largest = T_total[max_n_idx, :]
+            
+            # Check if we have valid data for the largest lookup table
+            if np.any(~np.isnan(T_total_largest)):
+                # Find best CPU count for the largest lookup table
+                best_cpu_idx = np.nanargmax(N_arr[max_n_idx]/T_total_largest)
+                best_cpu = Nproc_arr[best_cpu_idx]
+                best_n = N_arr[max_n_idx]
+
+                t_pri = T_prior[max_n_idx, best_cpu_idx]
+                t_fwd = T_forward[max_n_idx, best_cpu_idx]
+                t_rej = T_rejection[max_n_idx, best_cpu_idx]
+                t_post = T_poststat[max_n_idx, best_cpu_idx]
+                t_tot = t_pri + t_fwd + t_rej + t_post
+
+                print(f"\n📊 BEST OVERALL PERFORMANCE (Largest Lookup Table: {int(best_n):,} models):")
+                print(f"   Best CPU configuration: {int(best_cpu)} CPUs")
+                print(f"   Total throughput: {best_n/t_tot:.1f} models/sec")
+                print(f"\n   Time breakdown:")
+                print(f"     Prior generation: {t_pri:6.1f}s ({100*t_pri/t_tot:4.1f}%)")
+                print(f"     Forward modeling: {t_fwd:6.1f}s ({100*t_fwd/t_tot:4.1f}%)")
+                print(f"     Rejection sample: {t_rej:6.1f}s ({100*t_rej/t_tot:4.1f}%)")
+                print(f"     Post statistics:  {t_post:6.1f}s ({100*t_post/t_tot:4.1f}%)")
+                print(f"     Total time:       {t_tot:6.1f}s")
+            else:
+                print(f"\n📊 BEST OVERALL PERFORMANCE: No valid data for largest lookup table ({int(N_arr[max_n_idx]):,} models)")
+
+        print(f"\n{'='*60}")
+
+    except Exception as e:
+        print(f"Error reading timing summary from {f_timing}: {str(e)}")
+
+# %% The main function
+def main():
+    """Entry point for the integrate_timing command."""
+    import argparse
+    import sys
+    import os
+    import glob
+    import psutil
+    import numpy as np
+
+    import multiprocessing
+    multiprocessing.freeze_support()
+    
+    # Set a lower limit for processes to avoid handle limit issues on Windows
+    import platform
+    if platform.system() == 'Windows':
+        # On Windows, limit the max processes to avoid handle limit issues
+        multiprocessing.set_start_method('spawn')
+        
+        # Optional - can help with some multiprocessing issues
+        import os
+        os.environ['PYTHONWARNINGS'] = 'ignore:semaphore_tracker:UserWarning'
+    
+
+    # Create argument parser
+    parser = argparse.ArgumentParser(
+        description='INTEGRATE timing benchmark tool',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+INTEGRATE Timing Benchmark Tool
+
+This tool benchmarks the performance of the complete INTEGRATE workflow including:
+1. Prior model generation (layered geological models)
+2. Forward modeling using GA-AEM electromagnetic simulation  
+3. Rejection sampling for Bayesian inversion
+4. Posterior statistics computation
+
+USAGE EXAMPLES:
+
+Basic benchmarks:
+  integrate_timing time small                    # Quick test with default settings
+  integrate_timing time medium                   # Balanced benchmark  
+  integrate_timing time large                    # Comprehensive benchmark
+
+Custom dataset sizes:
+  integrate_timing time small --Nmin 5000        # Test with 5000 models
+  integrate_timing time small --N 100000         # Test with exactly 100000 models
+  integrate_timing time medium --Nmin 10000      # Medium test starting from 10000 models
+
+Custom CPU configurations:
+  integrate_timing time small --Ncpu 16          # Test with exactly 16 CPUs
+  integrate_timing time medium --cpu-scale linear # Test all CPU counts [1,2,3,...,64]
+  integrate_timing time large --cpu-scale log    # Test log scale [1,2,4,8,16,32,64]
+
+Combined options:
+  integrate_timing time small --Ncpu 32 --Nmin 50000    # 50k models on 32 CPUs
+  integrate_timing time medium --N 25000 --cpu-scale linear  # 25k models, all CPU counts
+
+Plotting results:
+  integrate_timing plot timing_results.npz       # Plot specific results file
+  integrate_timing plot --all                    # Plot all .npz files in directory
+
+PARAMETER PRIORITY:
+- Dataset sizes: --N (highest) > --Nmin > default
+- CPU counts: --Ncpu (highest) > --cpu-scale/--Nmin > default
+
+BENCHMARK SIZES:
+- small:  ~1,000 models, quick test
+- medium: 1,000-100,000 models, balanced test  
+- large:  10,000-1,000,000 models, comprehensive test
+
+Results are saved as .npz files and automatically plotted with performance analysis.
+        """
+    )
+    
+    # Create subparsers for different command groups
+    subparsers = parser.add_subparsers(dest='command', help='Command to run')
+    
+    # Plot command
+    plot_parser = subparsers.add_parser('plot', help='Plot timing results from benchmark files')
+    plot_parser.add_argument('file', nargs='?', default='time', 
+                           help='NPZ file containing timing results to plot')
+    plot_parser.add_argument('--all', action='store_true',
+                           help='Plot all NPZ timing files in the current directory')
+    plot_parser.add_argument('--no-summary', action='store_true',
+                           help='Disable timing summary output (enabled by default)')
+    
+    # Time command
+    time_parser = subparsers.add_parser('time', help='Run performance benchmark of INTEGRATE workflow')
+    time_parser.add_argument('size', choices=['small', 'medium', 'large'], 
+                            default='medium', nargs='?', 
+                            help='Benchmark size: small (~1k models, quick), medium (1k-100k models), large (10k-1M models)')
+    time_parser.add_argument('--cpu-scale', choices=['linear', 'log'], 
+                            default='log', 
+                            help='CPU scaling method: linear tests [1,2,3,...,Ncpu], log tests [1,2,4,8,...,Ncpu] (default: log)')
+    time_parser.add_argument('--Nmin', type=int, default=0,
+                            help='Dataset size control: For small benchmark, use exactly this many models. For medium/large, use as starting point in range (default: use benchmark defaults)')
+    time_parser.add_argument('--Ncpu', type=int, default=0,
+                            help='Use exactly this many CPU cores, overriding all other CPU options (default: 0, use scaling)')
+    time_parser.add_argument('--N', type=int, default=0,
+                            help='Use exactly this dataset size (number of models), overriding size and Nmin options (default: 0, use size-based defaults)')
+    time_parser.add_argument('--no-summary', action='store_true',
+                            help='Disable timing summary output (enabled by default)')
+    time_parser.add_argument('--backend', choices=['numpy', 'jax'], default='numpy',
+                            help='Rejection sampling backend: numpy (default) or jax')
+    time_parser.add_argument('--NcpuForward', type=int, default=0,
+                            help='Fix the number of CPUs used for forward modeling only. '
+                                 'When set, forward modeling always uses this many CPUs while '
+                                 'inversion (rejection sampling) varies over the usual CPU range. '
+                                 '(default: 0, forward uses same count as inversion)')
+    
+    # Add special case handling for '-time' without size argument
+    if '-time' in sys.argv and len(sys.argv) == 2:
+        print("Please specify a size for the timing benchmark:")
+        print("  small  - Quick test with minimal resources")
+        print("  medium - Balanced benchmark (default)")
+        print("  large  - Comprehensive benchmark (may take hours)")
+        print("\nExample: integrate_timing -time medium")
+        sys.exit(0)
+        
+    # Parse arguments
+    args = parser.parse_args()
+    
+    # Set default command if none is provided
+    if args.command is None:
+        # Show help when no command is specified
+        parser.print_help()
+        sys.exit(0)
+   
+    # Execute command
+    if args.command == 'plot':
+        if args.all:
+            # Plot all NPZ files in the current directory
+            files = glob.glob('*.npz')
+            for f in files:
+                try:
+                    # Show summary by default
+                    if not args.no_summary:
+                        print_timing_summary(f)
+
+                    timing_plot(f)
+                    plt.close('all')  # Close all figures after plotting
+                    print(f"Successfully plotted: {f}")
+                except Exception as e:
+                    print(f"Error plotting {f}: {str(e)}")
+                finally:
+                    plt.close('all')  # Ensure figures are closed even on error
+        elif args.file:
+            # Plot specified file
+            if not os.path.exists(args.file):
+                print(f"File not found: {args.file}")
+                sys.exit(1)
+            try:
+                # Show summary by default
+                if not args.no_summary:
+                    print_timing_summary(args.file)
+
+                timing_plot(args.file)
+                plt.close('all')  # Close all figures after plotting
+                print(f"Successfully plotted: {args.file}")
+            except Exception as e:
+                print(f"Error plotting {args.file}: {str(e)}")
+            finally:
+                plt.close('all')  # Ensure figures are closed even on error
+        else:
+            print("Please specify a file to plot or use --all")
+    
+    elif args.command == 'time':
+        Ncpu = psutil.cpu_count(logical=False)
+        
+        # Handle Ncpu option for processors
+        if args.Ncpu > 0:
+            # Use only the specified number of CPUs
+            Nproc_arr = np.array([args.Ncpu])
+        else:
+            # Determine CPU scaling based on command line option
+            if args.cpu_scale == 'linear':
+                Nproc_arr = np.arange(1, Ncpu+1)
+            else:  # log scaling
+                k = int(np.floor(np.log2(Ncpu)))
+                Nproc_arr = 2**np.linspace(0,k,(k)+1)
+                Nproc_arr = np.append(Nproc_arr, Ncpu)
+                Nproc_arr = np.unique(Nproc_arr)
+
+        # Handle dataset sizes
+        if args.N > 0:
+            # Use only the specified dataset size
+            N_arr = np.array([args.N])
+        elif args.Nmin > 0 and args.size == 'small':
+            # For small benchmark with Nmin: use only that value for dataset size
+            N_arr = np.array([args.Nmin])
+        elif args.size == 'small':
+            # Small benchmark default
+            N_arr = np.array([1000])
+        elif args.size == 'medium':
+            # Medium benchmark
+            if args.Nmin > 0:
+                # Use Nmin as starting point for medium benchmark
+                N_arr = np.ceil(np.logspace(np.log10(args.Nmin), 5, 9))
+            else:
+                N_arr = np.ceil(np.logspace(3,5,9))
+        elif args.size == 'large':
+            # Large benchmark
+            if args.Nmin > 0:
+                # Use Nmin as starting point for large benchmark
+                N_arr = np.ceil(np.logspace(np.log10(args.Nmin), 6, 7))
+            else:
+                N_arr = np.ceil(np.logspace(3,6,7))
+
+        # JAX doesn't use multiprocessing — default to a single "process" entry
+        # but respect an explicit --Ncpu value if the user provided one
+        if args.backend == 'jax' and args.Ncpu == 0:
+            Nproc_arr = np.array([1])
+
+        f_timing = timing_compute(
+            N_arr=N_arr,
+            Nproc_arr=Nproc_arr,
+            backend=args.backend,
+            NcpuForward=args.NcpuForward,
+        )
+
+        # Show summary and plot the results
+        try:
+            # Show summary by default
+            if not args.no_summary:
+                print_timing_summary(f_timing)
+
+            timing_plot(f_timing)
+            plt.close('all')  # Close all figures after plotting
+            print(f"Timing plots saved successfully.")
+        except Exception as e:
+            print(f"Error generating timing plots: {str(e)}")
+        finally:
+            plt.close('all')  # Ensure figures are closed even on error
+
+if __name__ == '__main__':
+    main()

integrate/integrate_www_cli.py

@@ -0,0 +1,8 @@
+import subprocess
+import sys
+from pathlib import Path
+
+
+def main():
+    app = Path(__file__).parent.parent / "streamlit" / "integrate_www.py"
+    sys.exit(subprocess.run(["streamlit", "run", str(app)] + sys.argv[1:]).returncode)

integrate_module-0.99.1.dist-info/METADATA

@@ -0,0 +1,229 @@
+Metadata-Version: 2.4
+Name: integrate_module
+Version: 0.99.1
+Summary: Localized probabilistic data integration
+Author-email: Thomas Mejer Hansen <tmeha@geo.au.dk>
+License: MIT
+Project-URL: Homepage, https://github.com/AUProbGeo/integrate_module
+Project-URL: Documentation, https://auprobgeo.github.io/integrate_module/
+Project-URL: Repository, https://github.com/AUProbGeo/integrate_module
+Project-URL: Issues, https://github.com/AUProbGeo/integrate_module/issues
+Keywords: inversion,electromagnetic,geophysics,geology,prior,tarantola
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: h5py
+Requires-Dist: scipy
+Requires-Dist: psutil
+Requires-Dist: tqdm
+Requires-Dist: requests
+Requires-Dist: geoprior1d>=0.9
+Requires-Dist: ga-aem-forward-win; platform_system == "Windows"
+Requires-Dist: jupyter>=1.0.0
+Requires-Dist: jupytext
+Requires-Dist: ipykernel
+Requires-Dist: pandas
+Requires-Dist: pyvista
+Requires-Dist: litellm
+Requires-Dist: streamlit
+Requires-Dist: libaarhusxyz
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: nbsphinx; extra == "docs"
+Requires-Dist: sphinx-gallery; extra == "docs"
+Requires-Dist: pandoc; extra == "docs"
+Requires-Dist: myst-parser; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
+Requires-Dist: furo; extra == "docs"
+Requires-Dist: tomli; python_version < "3.11" and extra == "docs"
+Dynamic: license-file
+
+# INTEGRATE Python Module
+
+[![Build Status](https://github.com/AUProbGeo/integrate_module/actions/workflows/docs.yml/badge.svg?branch=main)](https://github.com/AUProbGeo/integrate_module/actions/workflows/docs.yml)
+[![PyPI](https://badge.fury.io/py/integrate-module.svg)](https://badge.fury.io/py/integrate-module)
+[![Documentation](https://img.shields.io/badge/docs-latest-blue.svg)](https://auprobgeo.github.io/integrate_module/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+
+This repository contains the INTEGRATE Python module for localized probabilistic data integration in geophysics.
+
+
+## Installation
+
+Assuming you already have Python 3.10+ installed:
+
+    pip install integrate_module
+
+On Windows, this will also install the Python wrapper for GA-AEM (1D EM forward modeling - GPL v2 code): [ga-aem-forward-win](https://pypi.org/project/ga-aem-forward-win/)
+
+On Linux/macOS, you will need to install GA-AEM manually.
+
+### Using uv (recommended, from PyPI)
+
+[uv](https://github.com/astral-sh/uv) is a fast Python package manager. Install it first if needed:
+
+    # Install uv (Linux/macOS)
+    curl -LsSf https://astral.sh/uv/install.sh | sh
+    # or: pip install uv
+
+    # Create virtual environment in .venv/ inside the module root
+    cd path/to/integrate_module
+    uv venv .venv --python 3.11
+
+    # Activate
+    source .venv/bin/activate      # Linux/macOS
+    .venv\Scripts\activate         # Windows
+
+    # Install integrate module
+    uv pip install integrate_module
+
+### Using uv (from source)
+
+    # Install uv (Linux/macOS)
+    curl -LsSf https://astral.sh/uv/install.sh | sh
+    # or: pip install uv
+
+    # Create .venv and install all dependencies in one step (recommended for development)
+    cd path/to/integrate_module
+    uv sync
+
+    # Activate
+    source .venv/bin/activate      # Linux/macOS
+    .venv\Scripts\activate         # Windows
+
+### Using pip + venv (from PyPI, on Ubuntu)
+
+    # Install python3-venv
+    sudo apt install python3-venv
+
+    # Create virtual environment in .venv/ inside the module root
+    cd path/to/integrate_module
+    python3 -m venv .venv
+    source .venv/bin/activate
+    pip install --upgrade pip
+
+    # Install integrate module
+    pip install integrate_module
+
+### Using pip + venv (from source, on Ubuntu)
+
+    # Install python3-venv
+    sudo apt install python3-venv
+
+    # Create virtual environment in .venv/ inside the module root
+    cd path/to/integrate_module
+    python3 -m venv .venv
+    source .venv/bin/activate
+    pip install --upgrade pip
+
+    # Install integrate module from source
+    pip install -e .
+
+### Installing documentation dependencies
+
+To also install the packages needed to build the Sphinx documentation, use the `docs` extra:
+
+    # With uv (from source)
+    uv sync --extra docs
+
+    # With uv pip (from source)
+    uv pip install -e ".[docs]"
+
+    # With pip (from source)
+    pip install -e ".[docs]"
+
+### Using Conda + pip (from PyPI)
+
+Create a Conda environment (called integrate) and install the required modules: 
+
+    conda create --name integrate python=3.10 numpy pandas matplotlib scipy tqdm requests h5py psutil
+    conda activate integrate
+    pip install integrate_module
+    
+    
+### Using Conda + pip (from source)
+
+Create a Conda environment (called integrate) and install the required modules: 
+
+    conda create --name integrate python=3.10 numpy pandas matplotlib scipy tqdm requests h5py psutil
+    conda activate integrate
+    pip install -e .
+
+
+## GA-AEM
+
+In order to use GA-AEM for forward EM modeling, the 'gatdaem1d' Python module must be installed. Follow instructions at [https://github.com/GeoscienceAustralia/ga-aem](https://github.com/GeoscienceAustralia/ga-aem) or use the information below.
+
+
+### PyPI package for Windows
+
+On Windows, the [ga-aem-forward-win](https://pypi.org/project/ga-aem-forward-win/) package will be automatically installed, providing access to the GA-AEM forward code. It can be installed manually using:
+
+    pip install ga-aem-forward-win
+
+### Pre-compiled Python module for Windows
+
+1. Download the pre-compiled version of GA-AEM for Windows from the latest release: https://github.com/GeoscienceAustralia/ga-aem/releases (GA-AEM.zip)
+
+2. Download precompiled FFTW3 Windows DLLs from https://www.fftw.org/install/windows.html (fftw-3.3.5-dll64.zip)
+
+3. Extract both archives:
+   - `unzip GA-AEM.zip` to get GA-AEM
+   - `unzip fftw-3.3.5-dll64.zip` to get fftw-3.3.5-dll64
+
+4. Copy FFTW3 DLLs to GA-AEM Python directory:
+
+    cp fftw-3.3.5-dll64/*.dll GA-AEM/python/gatdaem1d/
+
+5. Install the Python gatdaem1d module:
+
+```
+cd GA-AEM/python/
+pip install -e .
+
+# Test the installation
+cd examples
+python integrate_skytem.py
+```
+
+
+### Compile GA-AEM Python module on Debian/Ubuntu/Linux
+
+A script that downloads and installs GA-AEM is located in `scripts/cmake_build_script_DebianUbuntu_gatdaem1d.sh`. This script has been tested and confirmed to work on both Debian and Ubuntu distributions. Be sure to use the appropriate Python environment and then run:
+
+    sh scripts/cmake_build_script_DebianUbuntu_gatdaem1d.sh
+    cd ga-aem/install-ubuntu/python
+    pip install .
+    
+### Compile GA-AEM Python module on macOS/Homebrew
+
+First install Homebrew, then run: 
+
+    sh ./scripts/cmake_build_script_homebrew_gatdaem1d.sh
+    cd ga-aem/install-homebrew/python
+    pip install .
+
+
+## Development
+
+The `main` branch is the most stable, with less frequent updates but larger changes.
+
+The `develop` branch contains the current development code and may be updated frequently. Some functions and examples may be broken.
+
+An extra set of tests and examples are located in the ``experimental`` sub-branch `https://github.com/cultpenguin/integrate_module_experimental/ <https://github.com/cultpenguin/integrate_module_experimental/>`_.
+Please ask the developers for access to this branch if needed. To clone the main repository with the experimental branch, use:
+
+    git clone --recurse-submodules git@github.com:AUProbGeo/integrate_module.git
+
+You may need to run the following command to update the submodules:
+
+    cd experimental
+    git submodule update --init --recursive
+

integrate_module-0.99.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+integrate/__init__.py,sha256=kk6NhOnQ0A5pHB-7ZNDVum1ur_xIjH-B-TZ_LVRCFMY,7436
+integrate/gex.py,sha256=aKbHDomn0MYr8bEh7zNdM0xuqN0O6tqJ4Y2J2vXEz5k,14884
+integrate/integrate.py,sha256=AYD6Iy2oM9xf6q3QDfDUZTQaS5DRKidCXPWTyiawR3A,154088
+integrate/integrate_borehole.py,sha256=Xg7qWLBooQQnAvKWOTwHtQsPyvlQUsUaa4VwIjVucfM,47867
+integrate/integrate_hdf5_info_cli.py,sha256=kZlmvBdPfYFQz2TSB9cXUWeSLZqqd_BeGRVliN6H5eE,3626
+integrate/integrate_io.py,sha256=YrlgBhVhLjCISDXqpwj0pdL6NWnocL392GF2CUGVfKA,210753
+integrate/integrate_plot.py,sha256=F95D5Agie8BnknxFKgEjmPcSy0MsYM_MNNPlXqA41eA,231645
+integrate/integrate_query.py,sha256=-i6aE42ampBF8rrlUtxH4HJtp_0uO5JtxQ-EU5secYM,62376
+integrate/integrate_rejection.py,sha256=QyK_X_WKqkMzBzdbUR7wO7qGCOnFu6vs2Dr7nZAHq2M,71681
+integrate/integrate_rejection_cli.py,sha256=4eKIuEJ98gmf9mLh67u4EE6o23k0H_wS6tczirf6olY,7209
+integrate/integrate_rejection_jax.py,sha256=1YZpANJfr4Fn82MdA6HGRorD3E4tewEaHfKEplWjpYc,20334
+integrate/integrate_timing_cli.py,sha256=-wjKHguPSmyKfn-SGI12Rqbw2iQy_j7bw0sGvgYd8EY,18352
+integrate/integrate_www_cli.py,sha256=p628dV7rPgdci9xJqxP4_fYThkHLf1KJyaO3o1p3cnQ,229
+integrate_module-0.99.1.dist-info/licenses/LICENSE,sha256=xHDEkdbQBsz88r_VgzuhyDYogRg-np2_KfPrJ3clT24,1108
+integrate_module-0.99.1.dist-info/METADATA,sha256=GqTYNlZXmSliwIJlGtSfMsON-M1sdtd1sV3-apqdiTM,7909
+integrate_module-0.99.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+integrate_module-0.99.1.dist-info/entry_points.txt,sha256=w-KqeDaAv6vV4UwT5t1SQ2IwtCEofTJOGZjsjCOuycc,230
+integrate_module-0.99.1.dist-info/top_level.txt,sha256=MALr2Hqk_f1nuZOLr0uhce4jtKD7dPLSuRXD3Plchtc,10
+integrate_module-0.99.1.dist-info/RECORD,,

integrate_module-0.99.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

integrate_module-0.99.1.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+hdf5_info = integrate.integrate_hdf5_info_cli:main
+integrate = integrate.integrate_www_cli:main
+integrate_rejection = integrate.integrate_rejection_cli:main
+integrate_timing = integrate.integrate_timing_cli:main