symfluence 0.7.7__tar.gz → 0.7.9__tar.gz

{symfluence-0.7.7 → symfluence-0.7.9}/.gitignore

@@ -28,6 +28,9 @@ examples/*/data/
 mpi_*
 
 
+# Pixi
+.pixi/
+
 # Virtual Environment
 venv/
 ENV/
@@ -44,6 +47,9 @@ env/
 !0_config_files/README.md
 
 
+# Claude Code
+CLAUDE.md
+
 # IDE
 .idea/
 .vscode/

{symfluence-0.7.7 → symfluence-0.7.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: symfluence
-Version: 0.7.7
+Version: 0.7.9
 Summary: SYnergistic Modelling Framework for Linking and Unifying Earth-system Nexii for Computational Exploration
 Project-URL: Homepage, https://symfluence.org
 Project-URL: Source, https://github.com/DarriEy/SYMFLUENCE

{symfluence-0.7.7 → symfluence-0.7.9}/symfluence/cli/commands/binary_commands.py

@@ -386,13 +386,96 @@ class BinaryCommands(BaseCommand):
         """
         cmd = [str(binary_path)] + args
         try:
-            result = subprocess.run(
+            # Use a pseudo-tty for stdout so C/C++ child processes use
+            # line-buffered output.  Without this, completion messages
+            # (e.g. ngen's "Finished N timesteps") are lost when the
+            # process segfaults during cleanup before flushing its buffer.
+            # stderr is piped separately so we can filter noisy WARN lines.
+            pty_master_fd = None
+            stdout_target = sys.stdout
+
+            if sys.platform != "win32":
+                try:
+                    import os as _os
+                    import pty as _pty
+                    pty_master_fd, pty_slave_fd = _pty.openpty()
+                    stdout_target = pty_slave_fd
+                except (OSError, ImportError):
+                    pass
+
+            proc = subprocess.Popen(
                 cmd,
                 stdin=sys.stdin,
-                stdout=sys.stdout,
-                stderr=sys.stderr,
+                stdout=stdout_target,
+                stderr=subprocess.PIPE,
             )
-            return result.returncode
+
+            # Close the slave end in the parent — only the child writes to it
+            if pty_master_fd is not None:
+                import os as _os
+                _os.close(pty_slave_fd)
+
+                # Read from pty master and forward to real stdout
+                import threading
+
+                def _forward_pty():
+                    try:
+                        while True:
+                            data = _os.read(pty_master_fd, 8192)
+                            if not data:
+                                break
+                            sys.stdout.buffer.write(data)
+                            sys.stdout.buffer.flush()
+                    except OSError:
+                        pass  # pty closed when child exits
+                    finally:
+                        _os.close(pty_master_fd)
+
+                pty_thread = threading.Thread(target=_forward_pty, daemon=True)
+                pty_thread.start()
+
+            # Stream stderr but filter out repetitive WARN lines
+            # (e.g. ngen emits thousands of unit-conversion warnings per timestep)
+            warn_count = 0
+            for raw_line in proc.stderr:
+                line = raw_line.decode("utf-8", errors="replace")
+                if line.startswith("WARN:"):
+                    warn_count += 1
+                    continue
+                sys.stderr.write(line)
+                sys.stderr.flush()
+
+            proc.wait()
+
+            if pty_master_fd is not None:
+                pty_thread.join(timeout=2)
+
+            if warn_count > 0:
+                sys.stderr.write(f"[suppressed {warn_count:,} repetitive warnings]\n")
+                sys.stderr.flush()
+
+            # Ensure terminal gets a clean newline after binary output
+            try:
+                sys.stdout.write("\n")
+                sys.stdout.flush()
+            except (OSError, ValueError):
+                pass
+
+            rc = proc.returncode
+            # Treat SIGSEGV during cleanup as success if the binary name
+            # is known to crash on teardown (e.g. ngen with Fortran BMI modules).
+            # Signal 11 (SIGSEGV) maps to exit code -11 or 128+11=139 or 256-11=245.
+            if rc in (-11, 139, 245):
+                tool_name = binary_path.name
+                print(
+                    f"Note: {tool_name} exited with signal 11 (SIGSEGV) during cleanup. "
+                    f"This is a known issue with Fortran BMI module teardown and does not "
+                    f"affect simulation results.",
+                    file=sys.stderr,
+                )
+                rc = 0
+
+            return rc
         except FileNotFoundError:
             print(f"Binary not found: {binary_path}", file=sys.stderr)
             return ExitCode.BINARY_ERROR

{symfluence-0.7.7 → symfluence-0.7.9}/symfluence/cli/services/build_snippets.py

@@ -1068,6 +1068,25 @@ detect_or_build_flex() {
         return 0
     fi
 
+    # Prefer Homebrew flex on macOS — Apple's /usr/bin/flex calls /usr/bin/gm4
+    # which was removed in macOS Sequoia (15.x)
+    if [ -x /opt/homebrew/opt/flex/bin/flex ]; then
+        echo "Found Homebrew flex: /opt/homebrew/opt/flex/bin/flex"
+        export PATH="/opt/homebrew/opt/flex/bin:$PATH"
+        flex --version | head -1
+        FLEX_FOUND=true
+        # Homebrew flex includes libfl
+        local brew_flex_lib="/opt/homebrew/opt/flex/lib"
+        if [ -f "$brew_flex_lib/libfl.a" ] || [ -f "$brew_flex_lib/libfl.dylib" ]; then
+            echo "Found Homebrew libfl"
+            LIBFL_FOUND=true
+            export FLEX_LIB_DIR="$brew_flex_lib"
+            export LDFLAGS="${LDFLAGS:-} -L${FLEX_LIB_DIR}"
+            export LIBRARY_PATH="${FLEX_LIB_DIR}:${LIBRARY_PATH:-}"
+        fi
+        return 0
+    fi
+
     # Check if flex binary is available in PATH
     if command -v flex >/dev/null 2>&1; then
         echo "Found flex: $(command -v flex)"

{symfluence-0.7.7 → symfluence-0.7.9}/symfluence/cli/services/tool_installer.py

@@ -572,6 +572,7 @@ class ToolInstaller(BaseService):
                 # Check required tools
                 if tool_info.get("requires"):
                     required_tools = tool_info.get("requires", [])
+                    missing_required_tool = False
                     for req_tool in required_tools:
                         req_tool_info = self.external_tools.get(req_tool, {})
                         req_tool_dir = install_base_dir / req_tool_info.get(
@@ -584,7 +585,10 @@ class ToolInstaller(BaseService):
                             self._console.error(error_msg)
                             installation_results["errors"].append(error_msg)
                             installation_results["failed"].append(tool_name)
-                            continue
+                            missing_required_tool = True
+                            break
+                    if missing_required_tool:
+                        continue
 
                 # Run build commands
                 if tool_info.get("build_commands"):
@@ -601,7 +605,17 @@ class ToolInstaller(BaseService):
                     installation_results["successful"].append(tool_name)
 
                 # Verify installation
-                self._verify_installation(tool_name, tool_info, tool_install_dir)
+                verified = self._verify_installation(tool_name, tool_info, tool_install_dir)
+                if not verified:
+                    installation_results["errors"].append(
+                        f"{tool_name}: installation verification failed"
+                    )
+                    if tool_name in installation_results["successful"]:
+                        installation_results["successful"] = [
+                            t for t in installation_results["successful"] if t != tool_name
+                        ]
+                    if tool_name not in installation_results["failed"]:
+                        installation_results["failed"].append(tool_name)
 
             except subprocess.CalledProcessError as e:
                 if repository_url:

{symfluence-0.7.7 → symfluence-0.7.9}/symfluence/core/config/models/model_configs.py

@@ -205,6 +205,23 @@ class ModelConfig(BaseModel):
                 if values.get(field_name) is None:
                     values[field_name] = config_cls()
 
+        # Forward deprecated ENABLE_* keys into the ngen sub-dict so
+        # NGENConfig._migrate_enable_flags can pick them up (handles flat
+        # configs where these land at the ModelConfig level).
+        _enable_keys = ('ENABLE_SLOTH', 'ENABLE_PET', 'ENABLE_NOAH', 'ENABLE_CFE')
+        found = {k: values[k] for k in _enable_keys if k in values}
+        if found:
+            ngen_dict = values.get('ngen')
+            if ngen_dict is None:
+                ngen_dict = {}
+                values['ngen'] = ngen_dict
+            if isinstance(ngen_dict, dict):
+                for k, v in found.items():
+                    ngen_dict.setdefault(k, v)
+            # Remove from top level so Pydantic doesn't reject them
+            for k in found:
+                values.pop(k, None)
+
         return values
 
 __all__ = [

{symfluence-0.7.7 → symfluence-0.7.9}/symfluence/core/config/models/model_configs_hydrology.py

@@ -3,9 +3,10 @@
 
 """Hydrological model configuration classes."""
 
+import warnings
 from typing import Any, Dict, List, Literal, Optional, Union
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 
 from .base import FROZEN_CONFIG
 from .model_config_types import SpatialModeType
@@ -283,12 +284,79 @@ class NGENConfig(BaseModel):
         alias='NGEN_PET_PARAMS_TO_CALIBRATE'
     )
     active_catchment_id: Optional[str] = Field(default=None, alias='NGEN_ACTIVE_CATCHMENT_ID')
-    # Module enable flags
-    enable_sloth: bool = Field(default=True, alias='ENABLE_SLOTH')
-    enable_pet: bool = Field(default=True, alias='ENABLE_PET')
-    enable_noah: bool = Field(default=False, alias='ENABLE_NOAH')
-    enable_cfe: bool = Field(default=True, alias='ENABLE_CFE')
+    # Parameter bounds overrides (per-module)
+    cfe_param_bounds: Optional[Dict[str, Any]] = Field(default=None, alias='NGEN_CFE_PARAM_BOUNDS')
+    noah_param_bounds: Optional[Dict[str, Any]] = Field(default=None, alias='NGEN_NOAH_PARAM_BOUNDS')
+    pet_param_bounds: Optional[Dict[str, Any]] = Field(default=None, alias='NGEN_PET_PARAM_BOUNDS')
+    # Module selection (replaces individual ENABLE_* flags)
+    modules_selected: str = Field(default='SLOTH,PET,CFE', alias='NGEN_MODULES_SELECTED')
     noah_et_fallback: str = Field(default='ETRAN', alias='NGEN_NOAH_ET_FALLBACK')
+
+    @model_validator(mode='before')
+    @classmethod
+    def _migrate_enable_flags(cls, values: Any) -> Any:
+        """Auto-migrate deprecated ENABLE_* flags to NGEN_MODULES_SELECTED."""
+        if not isinstance(values, dict):
+            return values
+
+        # Check for any legacy ENABLE_* keys
+        enable_keys = {
+            'ENABLE_SLOTH': ('SLOTH', True),
+            'ENABLE_PET': ('PET', True),
+            'ENABLE_NOAH': ('NOAH', False),
+            'ENABLE_CFE': ('CFE', True),
+        }
+        found_legacy = {k: v for k, v in enable_keys.items() if k in values}
+
+        if not found_legacy:
+            return values
+
+        # Only migrate if NGEN_MODULES_SELECTED is not already explicitly set
+        if 'NGEN_MODULES_SELECTED' in values or 'modules_selected' in values:
+            # Remove stale legacy keys so they don't cause Pydantic errors
+            for k in found_legacy:
+                values.pop(k, None)
+            return values
+
+        # Build modules list from legacy flags
+        modules = []
+        for key, (mod_name, default_on) in enable_keys.items():
+            raw = values.get(key, default_on)
+            # Handle string booleans from YAML
+            if isinstance(raw, str):
+                enabled = raw.lower() in ('true', '1', 'yes')
+            else:
+                enabled = bool(raw)
+            if enabled:
+                modules.append(mod_name)
+
+        values['NGEN_MODULES_SELECTED'] = ','.join(modules)
+
+        # Remove legacy keys
+        for k in found_legacy:
+            values.pop(k, None)
+
+        warnings.warn(
+            "ENABLE_SLOTH/ENABLE_PET/ENABLE_NOAH/ENABLE_CFE are deprecated. "
+            f"Use NGEN_MODULES_SELECTED: '{values['NGEN_MODULES_SELECTED']}' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return values
+
+    @model_validator(mode='after')
+    def _validate_calibrate_subset(self) -> 'NGENConfig':
+        """Ensure modules_to_calibrate is a subset of modules_selected."""
+        selected = {m.strip().upper() for m in self.modules_selected.split(',') if m.strip()}
+        calibrate = {m.strip().upper() for m in self.modules_to_calibrate.split(',') if m.strip()}
+        not_selected = calibrate - selected
+        if not_selected:
+            raise ValueError(
+                f"NGEN_MODULES_TO_CALIBRATE contains modules not in NGEN_MODULES_SELECTED: "
+                f"{not_selected}. Either add them to NGEN_MODULES_SELECTED or remove them "
+                f"from NGEN_MODULES_TO_CALIBRATE."
+            )
+        return self
     run_troute: bool = Field(default=True, alias='NGEN_RUN_TROUTE')
 
 

{symfluence-0.7.7 → symfluence-0.7.9}/symfluence/core/hdf5_safety.py

@@ -28,8 +28,12 @@ Usage:
 """
 
 import gc
+import logging
 import os
-from typing import Dict
+from pathlib import Path
+from typing import Dict, Optional
+
+logger = logging.getLogger(__name__)
 
 # =============================================================================
 # Environment Variable Constants
@@ -53,6 +57,12 @@ THREAD_ENV_VARS: Dict[str, str] = {
 }
 """Environment variables to force single-threaded execution in numerical libraries."""
 
+# Module-level flag: set to True when h5py and netCDF4 link against different
+# libhdf5 builds.  When True, the h5netcdf engine fallback in
+# BaseDatasetHandler.open_dataset() must be skipped because importing h5py
+# would corrupt netcdf4's HDF5 state for the rest of the process.
+hdf5_library_conflict: bool = False
+
 
 # =============================================================================
 # Configuration Functions
@@ -84,22 +94,20 @@ def configure_hdf5_safety(disable_tqdm_monitor: bool = True) -> None:
         else:
             os.environ.setdefault(key, value)
 
-    # Configure xarray to minimize file caching and prefer h5netcdf backend
-    # h5netcdf is more stable than netCDF4 for concurrent access
+    # Configure xarray to minimize file caching
     try:
         import xarray as xr
         xr.set_options(
             file_cache_maxsize=1,  # Minimal file cache
         )
-        # Try to set h5netcdf as default backend if available
-        try:
-            import h5netcdf  # noqa: F401
-            # h5netcdf is available, will be used when backend='h5netcdf'
-        except ImportError:
-            pass  # h5netcdf not available, will fall back to netCDF4
     except (ImportError, AttributeError):
         pass  # xarray not yet imported or doesn't support this option
 
+    # Check for conflicting HDF5 library builds (e.g. pip h5py + pip netCDF4
+    # each bundling their own libhdf5).  Must run BEFORE any h5py/h5netcdf
+    # import to avoid poisoning the process.
+    _check_hdf5_library_conflict()
+
     # Disable tqdm monitor thread to prevent segfaults
     if disable_tqdm_monitor:
         _disable_tqdm_monitor()
@@ -212,6 +220,94 @@ def clear_xarray_cache() -> None:
 # Internal Helpers
 # =============================================================================
 
+def _find_bundled_libhdf5(pkg_name: str) -> Optional[Path]:
+    """Find a bundled libhdf5 shipped inside a pip wheel for *pkg_name*.
+
+    Pip wheels for h5py and netCDF4 vendor their own private copy of
+    libhdf5 into a ``<pkg>.libs/`` (Linux) or ``<pkg>/.dylibs/``
+    (macOS) directory next to the package.  Conda-installed packages
+    instead link against a single shared ``$CONDA_PREFIX/lib/libhdf5``
+    and have no bundled copy.
+
+    Returns the resolved path to the bundled libhdf5, or None if the
+    package is not installed or does not bundle its own copy.
+    """
+    try:
+        import importlib.util
+        spec = importlib.util.find_spec(pkg_name)
+        if spec is None or spec.origin is None:
+            return None
+        pkg_dir = Path(spec.origin).parent
+
+        # Linux pip wheels: <site-packages>/<pkg>.libs/libhdf5-*.so*
+        # macOS pip wheels: <site-packages>/<pkg>/.dylibs/libhdf5*.dylib
+        search_dirs = [
+            pkg_dir.parent / f"{pkg_name}.libs",      # Linux
+            pkg_dir / ".dylibs",                       # macOS (inside pkg)
+        ]
+        # netCDF4 pip wheel uses the distribution name "netcdf4" (lowercase)
+        if pkg_name == "netCDF4":
+            search_dirs.append(pkg_dir.parent / "netcdf4.libs")
+
+        for d in search_dirs:
+            if not d.is_dir():
+                continue
+            for f in d.iterdir():
+                name = f.name.lower()
+                if 'libhdf5' in name and 'libhdf5_hl' not in name:
+                    return f.resolve()
+    except Exception:  # noqa: BLE001
+        pass
+    return None
+
+
+def _check_hdf5_library_conflict() -> None:
+    """Detect conflicting libhdf5 builds between h5py and netCDF4.
+
+    When both packages are pip-installed, each bundles its own private
+    copy of ``libhdf5`` (with different build hashes).  If h5py is
+    imported first, its libhdf5 symbols shadow netCDF4's, corrupting
+    HDF5 global state and causing ``NetCDF: HDF error`` on every
+    subsequent netcdf4 operation — even reads.
+
+    This check runs at startup (before any h5py import) by looking for
+    bundled libhdf5 files in pip wheel vendor directories — no Python
+    HDF5 modules are imported.
+
+    Sets the module-level ``hdf5_library_conflict`` flag and logs a
+    warning with clear fix instructions.
+    """
+    global hdf5_library_conflict
+
+    h5py_lib = _find_bundled_libhdf5('h5py')
+    nc4_lib = _find_bundled_libhdf5('netCDF4')
+
+    if h5py_lib is None or nc4_lib is None:
+        # At least one package doesn't bundle its own libhdf5 (likely
+        # conda-installed or not present at all).  No conflict.
+        return
+
+    if h5py_lib == nc4_lib:
+        return  # Same file — no conflict
+
+    hdf5_library_conflict = True
+    logger.warning(
+        "h5py and netCDF4 bundle DIFFERENT libhdf5 builds:\n"
+        "  h5py    → %s\n"
+        "  netCDF4 → %s\n"
+        "Importing h5py will corrupt netcdf4's HDF5 state, causing "
+        "'NetCDF: HDF error' on all subsequent operations.\n"
+        "Fix: install both from the same package manager:\n"
+        "  conda:  pip uninstall h5py netCDF4 -y && conda install h5py netcdf4\n"
+        "  pip:    pip install --force-reinstall --no-binary h5py --no-binary "
+        "netCDF4 h5py netCDF4\n"
+        "The h5netcdf engine fallback will be DISABLED for this session to "
+        "prevent the conflict from being triggered.",
+        h5py_lib,
+        nc4_lib,
+    )
+
+
 def _disable_tqdm_monitor() -> None:
     """Disable tqdm's background monitor thread."""
     try:

{symfluence-0.7.7 → symfluence-0.7.9}/symfluence/coupling/adapters/process_adapters.py

@@ -97,10 +97,7 @@ class SUMMAProcessComponent(ProcessComponent):
             return {"runoff": runoff, "soil_drainage": drainage}
         except Exception as e:  # noqa: BLE001 — must-not-raise contract
             logger.error(f"Failed to read SUMMA outputs: {e}")
-            return {
-                "runoff": torch.zeros(1),
-                "soil_drainage": torch.zeros(1),
-            }
+            raise RuntimeError("Failed to read SUMMA outputs") from e
 
 
 class MizuRouteProcessComponent(ProcessComponent):
@@ -171,7 +168,7 @@ class MizuRouteProcessComponent(ProcessComponent):
             return {"discharge": discharge}
         except Exception as e:  # noqa: BLE001 — must-not-raise contract
             logger.error(f"Failed to read mizuRoute outputs: {e}")
-            return {"discharge": torch.zeros(1)}
+            raise RuntimeError("Failed to read mizuRoute outputs") from e
 
 
 class ParFlowProcessComponent(ProcessComponent):
@@ -254,7 +251,7 @@ class ParFlowProcessComponent(ProcessComponent):
             )}
         except Exception as e:  # noqa: BLE001 — must-not-raise contract
             logger.error(f"Failed to read ParFlow outputs: {e}")
-            return {"baseflow": torch.zeros(1)}
+            raise RuntimeError("Failed to read ParFlow outputs") from e
 
 
 class MODFLOWProcessComponent(ProcessComponent):
@@ -336,7 +333,7 @@ class MODFLOWProcessComponent(ProcessComponent):
             )}
         except Exception as e:  # noqa: BLE001 — must-not-raise contract
             logger.error(f"Failed to read MODFLOW outputs: {e}")
-            return {"drain_discharge": torch.zeros(1)}
+            raise RuntimeError("Failed to read MODFLOW outputs") from e
 
 
 class MESHProcessComponent(ProcessComponent):
@@ -410,7 +407,7 @@ class MESHProcessComponent(ProcessComponent):
             )}
         except Exception as e:  # noqa: BLE001 — must-not-raise contract
             logger.error(f"Failed to read MESH outputs: {e}")
-            return {"discharge": torch.zeros(1)}
+            raise RuntimeError("Failed to read MESH outputs") from e
 
 
 class TRouteProcessComponent(ProcessComponent):
@@ -485,10 +482,13 @@ class TRouteProcessComponent(ProcessComponent):
                     ds.close()
                     return {"discharge": discharge}
             ds.close()
-            return {"discharge": torch.zeros(1)}
+            raise KeyError(
+                "No supported discharge variable found in t-route output "
+                "(expected one of flow, streamflow, discharge, q_lateral)"
+            )
         except Exception as e:  # noqa: BLE001 — must-not-raise contract
             logger.error(f"Failed to read t-route outputs: {e}")
-            return {"discharge": torch.zeros(1)}
+            raise RuntimeError("Failed to read t-route outputs") from e
 
 
 class CLMProcessComponent(ProcessComponent):
@@ -578,7 +578,4 @@ class CLMProcessComponent(ProcessComponent):
             }
         except Exception as e:  # noqa: BLE001 — must-not-raise contract
             logger.error(f"Failed to read CLM outputs: {e}")
-            return {
-                "runoff": torch.zeros(1),
-                "evapotranspiration": torch.zeros(1),
-            }
+            raise RuntimeError("Failed to read CLM outputs") from e

{symfluence-0.7.7 → symfluence-0.7.9}/symfluence/data/preprocessing/dataset_handlers/base_dataset.py

@@ -481,6 +481,10 @@ class BaseDatasetHandler(ABC, ConfigMixin):
         or the parallel filesystem does not support POSIX file locking),
         retries with h5netcdf using ``lock=False``.
 
+        If a libhdf5 build conflict between h5py and netCDF4 was detected at
+        startup, the h5netcdf fallback is skipped (importing h5py would
+        corrupt the netcdf4 backend for the rest of the process).
+
         Args:
             path: Path to the NetCDF file
             **kwargs: Additional arguments passed to xr.open_dataset
@@ -494,6 +498,21 @@ class BaseDatasetHandler(ABC, ConfigMixin):
             msg = str(e).lower()
             if not any(pat.lower() in msg for pat in self._HDF_ERROR_PATTERNS):
                 raise
+
+            # If h5py and netCDF4 bundle different libhdf5 builds, falling
+            # back to h5netcdf would import h5py and poison the netcdf4
+            # backend for the rest of the process.  Fail fast with a
+            # clear message instead.
+            from symfluence.core.hdf5_safety import hdf5_library_conflict
+            if hdf5_library_conflict:
+                raise OSError(
+                    f"netcdf4 engine failed on {Path(path).name} and the "
+                    f"h5netcdf fallback is disabled because h5py and netCDF4 "
+                    f"link against different libhdf5 builds. Fix: "
+                    f"pip uninstall h5py netCDF4 -y && "
+                    f"conda install h5py netcdf4"
+                ) from e
+
             self.logger.warning(
                 f"netcdf4 engine failed on {Path(path).name} (likely HDF5 "
                 f"library conflict or file-locking issue), retrying with "

{symfluence-0.7.7 → symfluence-0.7.9}/symfluence/geospatial/geofabric/processors/taudem_executor.py

@@ -92,18 +92,28 @@ class TauDEMExecutor:
         Detect the best available MPI launcher.
 
         Respects MPI_LAUNCHER config override. Otherwise uses smart detection:
+        - Checks for bundled mpirun in taudem_dir (npm dist/bin/ layout)
         - If OpenMPI is detected, always use mpirun (OpenMPI's own launcher)
           since srun requires SLURM PMI support that OpenMPI often lacks.
         - If srun is available AND has PMI support, use srun (Intel MPI, MPICH).
         - Falls back to mpirun, then None.
 
         Returns:
-            'srun', 'mpirun', or None if no MPI launcher found
+            Path to mpirun, 'srun', 'mpirun', or None if no MPI launcher found
         """
         override = self.config.get('MPI_LAUNCHER')
         if override and shutil.which(override):
             return override
 
+        # Check for bundled mpirun next to TauDEM tools (npm layout)
+        bundled = os.path.join(self.taudem_dir, 'mpirun')
+        if os.path.isfile(bundled) and os.access(bundled, os.X_OK):
+            self.logger.debug("Using bundled MPI launcher: %s", bundled)
+            # Set OPAL_PREFIX so OpenMPI finds its data files
+            prefix = os.path.dirname(self.taudem_dir)
+            os.environ.setdefault('OPAL_PREFIX', prefix)
+            return bundled
+
         has_srun = shutil.which("srun") is not None
         has_mpirun = shutil.which("mpirun") is not None
 

{symfluence-0.7.7 → symfluence-0.7.9}/symfluence/models/clm/build_instructions.py

@@ -516,6 +516,15 @@ if [ $? -ne 0 ]; then
     exit 1
 fi
 
+# Export NetCDF paths so PIO's CMake can find NetCDF C/Fortran libraries.
+# CIME injects these into XML but PIO's CMakeLists.txt needs them as env vars
+# or in CMAKE_PREFIX_PATH for find_package(NetCDF) to work.
+if [ -n "${NETCDF_C:-}" ]; then
+  export NetCDF_C_PATH="${NETCDF_C}"
+  export CMAKE_PREFIX_PATH="${NETCDF_C}:${NETCDF_FORTRAN:-$NETCDF_C}:${CMAKE_PREFIX_PATH:-}"
+  echo "Exported NetCDF_C_PATH=$NETCDF_C for PIO CMake discovery"
+fi
+
 # Build (CIME case.build uses GMAKE_J for parallelism, not --parallel)
 echo "Running case.build..."
 NCORES=$(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 2)

{symfluence-0.7.7 → symfluence-0.7.9}/symfluence/models/clmparflow/runner.py

@@ -18,6 +18,7 @@ from typing import Optional
 
 from symfluence.core.exceptions import ModelExecutionError, symfluence_error_handler
 from symfluence.core.mixins.project import resolve_data_subdir
+from symfluence.core.mpi_utils import find_mpirun
 from symfluence.models.base.base_runner import BaseModelRunner
 from symfluence.models.registry import ModelRegistry
 
@@ -140,7 +141,13 @@ class CLMParFlowRunner(BaseModelRunner):
 
             num_procs = self._get_num_procs()
             if num_procs > 1:
-                cmd = ['mpirun', '-np', str(num_procs), str(pf_exe), runname]
+                mpirun = find_mpirun(pf_exe)
+                if mpirun is None:
+                    raise ModelExecutionError(
+                        "MPI launcher (mpirun/mpiexec) not found. "
+                        "Install OpenMPI or use the npm package which bundles it."
+                    )
+                cmd = [mpirun, '-np', str(num_procs), str(pf_exe), runname]
             else:
                 cmd = [str(pf_exe), runname]