mfai-viewer 0.1.0__tar.gz

mfai_viewer-0.1.0/.gitignore

@@ -0,0 +1,126 @@
+# Dependencies
+node_modules/
+.pnpm-debug.log*
+.yarn/*
+!.yarn/releases
+!.yarn/plugins
+.yarnrc.yml
+
+# Environment files - NEVER commit these!
+.env
+.env.local
+.env.*.local
+*.env
+**/.env
+**/.env.local
+
+# SSH keys - NEVER commit these!
+*.pem
+*.key
+id_rsa*
+id_ed25519*
+*.ppk
+
+# API tokens and secrets
+*secret*
+*token*
+*apikey*
+.secrets/
+
+# Build outputs
+dist/
+build/
+.next/
+.turbo/
+*.tsbuildinfo
+
+# Testing
+.playwright-mcp/
+playwright-report/
+test-results/
+coverage/
+
+# Archive and reference directories
+.archive/
+.references/
+.docs/
+
+# Local development
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Logs
+*.log
+logs/
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Cloudflare Wrangler
+.wrangler/
+.dev.vars
+
+# Compiled MCP tools
+.tools-compiled/
+stdio/dist/
+stdio/stdio/
+
+# Data directories
+data/
+examples/
+flopy-tutorials-*/
+scripts/modflow6_examples_data/
+scripts/plots/
+scripts/temp/
+scripts/*.tif
+scripts/*.json
+
+# Temporary files
+*.png
+!mfai-chat/public/**/*.png
+!assets/**/*.png
+deploy_to_vm.py
+deploy_to_vm.sh
+update_vm_packages.sh
+fix_*.py
+
+# Auto-generated
+next-env.d.ts
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+.venv/
+
+# Ignore tutorial outputs and runtime files
+examples/**/output/
+examples/**/plots/
+examples/**/*.png
+examples/**/*.jpg
+examples/**/*.csv
+examples/**/simulation/
+examples/**/__pycache__/
+examples/**/*.pyc
+
+# Ignore test/workspace directories
+workspace/
+test_tutorials/
+tutorial_test_env/
+fixed_tutorials/
+fixed_scripts/
+
+# But keep the Python files!
+!examples/**/*.py
+
+# Keep documentation
+!*.md
+python_executor/modflow-executor-with-tutorials.tar.gz

mfai_viewer-0.1.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.5
+Name: mfai-viewer
+Version: 0.1.0
+Summary: Write and upload the MODFLOW AI web viewer snapshot of a MODFLOW 6 model that was run with FloPy
+Project-URL: Homepage, https://www.modflow.ai
+Project-URL: Source, https://github.com/modflowai/modflowai-mcp
+Author-email: GWLab <admin@modflow.ai>
+License-Expression: MIT
+Keywords: flopy,groundwater,modflow,viewer
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Hydrology
+Requires-Python: >=3.10
+Requires-Dist: flatbuffers>=23.5
+Requires-Dist: flopy>=3.5
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: numpy>=1.24
+Requires-Dist: pydantic>=2.0
+Requires-Dist: scipy>=1.10
+Requires-Dist: shapely>=2.0
+Description-Content-Type: text/markdown
+
+# mfai-viewer
+
+The writer behind the `open_in_viewer` tool of the MODFLOW AI MCP
+(`https://mcp.modflow.ai`). It turns a MODFLOW 6 simulation that was built
+with FloPy and run on this machine into the snapshot the MODFLOW AI web
+viewer (`viewer.modflow.ai`) reads, and uploads that snapshot to the link
+the MCP tool created.
+
+```sh
+python -m pip install mfai-viewer
+mfai-viewer snapshot --workdir <model dir> --out <snapshot dir>
+mfai-viewer upload <snapshot dir> "<uploads url from open_in_viewer>"
+mfai-viewer version
+```
+
+`snapshot` refuses a model that has not been run (no head file). It writes
+`manifest.json` and a small `summary.json`; the MCP tool takes the summary
+and answers the one `upload` command to run. `upload` sends every file in
+parallel, retries, marks the link complete and prints the URL.
+
+Exit codes: 0 done, 2 the environment cannot run it (Python older than 3.10,
+missing packages, bad arguments), 3 the model has not been run, 4 files are
+still missing after the upload, 1 anything else.
+
+The writer code (`mfai_viewer/writer`) and the GWlink slice it vendors
+(`mfai_viewer/gwlink`) are copied byte for byte from the mfai-chat and gwlink
+repositories; `mfai_viewer/sources.json` records the commits and the sha256
+of every file. Nothing is edited here.

mfai_viewer-0.1.0/README.md

@@ -0,0 +1,28 @@
+# mfai-viewer
+
+The writer behind the `open_in_viewer` tool of the MODFLOW AI MCP
+(`https://mcp.modflow.ai`). It turns a MODFLOW 6 simulation that was built
+with FloPy and run on this machine into the snapshot the MODFLOW AI web
+viewer (`viewer.modflow.ai`) reads, and uploads that snapshot to the link
+the MCP tool created.
+
+```sh
+python -m pip install mfai-viewer
+mfai-viewer snapshot --workdir <model dir> --out <snapshot dir>
+mfai-viewer upload <snapshot dir> "<uploads url from open_in_viewer>"
+mfai-viewer version
+```
+
+`snapshot` refuses a model that has not been run (no head file). It writes
+`manifest.json` and a small `summary.json`; the MCP tool takes the summary
+and answers the one `upload` command to run. `upload` sends every file in
+parallel, retries, marks the link complete and prints the URL.
+
+Exit codes: 0 done, 2 the environment cannot run it (Python older than 3.10,
+missing packages, bad arguments), 3 the model has not been run, 4 files are
+still missing after the upload, 1 anything else.
+
+The writer code (`mfai_viewer/writer`) and the GWlink slice it vendors
+(`mfai_viewer/gwlink`) are copied byte for byte from the mfai-chat and gwlink
+repositories; `mfai_viewer/sources.json` records the commits and the sha256
+of every file. Nothing is edited here.

mfai_viewer-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "mfai-viewer"
+version = "0.1.0"
+description = "Write and upload the MODFLOW AI web viewer snapshot of a MODFLOW 6 model that was run with FloPy"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "GWLab", email = "admin@modflow.ai" }]
+keywords = ["modflow", "flopy", "groundwater", "viewer"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Operating System :: OS Independent",
+  "Topic :: Scientific/Engineering :: Hydrology",
+]
+dependencies = [
+  "numpy>=1.24",
+  "flopy>=3.5",
+  "flatbuffers>=23.5",
+  "pydantic>=2.0",
+  "scipy>=1.10",
+  "matplotlib>=3.7",
+  "shapely>=2.0",
+]
+
+[project.urls]
+Homepage = "https://www.modflow.ai"
+Source = "https://github.com/modflowai/modflowai-mcp"
+
+[project.scripts]
+mfai-viewer = "mfai_viewer.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mfai_viewer"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/mfai_viewer", "README.md", "pyproject.toml"]

mfai_viewer-0.1.0/src/mfai_viewer/__init__.py

@@ -0,0 +1,24 @@
+"""mfai-viewer: the MODFLOW AI web viewer snapshot of a MODFLOW 6 model run with FloPy.
+
+The writer itself is :mod:`mfai_viewer.writer`, a byte for byte copy of the
+browser writer in the mfai-chat repository, with the GWlink slice it vendors
+under :mod:`mfai_viewer.gwlink`. ``sources.json`` next to this file records
+the commits and the sha256 of every copied file. This package adds the
+version, the console script (``mfai-viewer snapshot | upload | version``)
+and the uploader; nothing in the writer is edited here.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from .writer import ModelNotRunError, write_snapshot  # noqa: F401
+
+__version__ = "0.1.0"
+__all__ = ["ModelNotRunError", "write_snapshot", "__version__", "sources"]
+
+
+def sources() -> dict:
+    """The commits and file hashes the package was built from."""
+    return json.loads((Path(__file__).parent / "sources.json").read_text())

mfai_viewer-0.1.0/src/mfai_viewer/__main__.py

@@ -0,0 +1,5 @@
+"""``python -m mfai_viewer`` behaves like the ``mfai-viewer`` console script."""
+
+from .cli import main
+
+raise SystemExit(main())

mfai_viewer-0.1.0/src/mfai_viewer/cli.py

@@ -0,0 +1,190 @@
+"""The ``mfai-viewer`` command: ``snapshot``, ``upload``, ``version``.
+
+    mfai-viewer snapshot --workdir <model dir> --out <snapshot dir>
+    mfai-viewer upload <snapshot dir> "<uploads url from open_in_viewer>"
+    mfai-viewer version
+
+``snapshot`` writes the viewer snapshot of a MODFLOW 6 simulation that was
+run (``mfsim.nam`` plus a head file) and a small ``summary.json`` the MCP
+tool ``open_in_viewer`` takes as its argument. ``upload`` sends the files to
+the link that tool created and prints the URL.
+
+Exit codes: 0 done, 2 the environment cannot run it (Python version, missing
+packages, bad arguments), 3 the model has not been run, 4 files are still
+missing after the upload, 1 anything else.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import sys
+from pathlib import Path
+
+from . import __version__
+
+PACKAGE = "mfai-viewer"
+REQUIRED = ["numpy", "flopy", "flatbuffers", "pydantic", "scipy", "matplotlib", "shapely"]
+MIN_PYTHON = (3, 10)
+SUMMARY_FILE = "summary.json"
+EXIT_ENVIRONMENT = 2
+EXIT_NOT_RUN = 3
+EXIT_INCOMPLETE = 4
+
+
+def check_environment() -> list[str]:
+    missing = []
+    for name in REQUIRED:
+        try:
+            __import__(name)
+        except ImportError:
+            missing.append(name)
+    return missing
+
+
+def version_info() -> dict:
+    from . import sources
+
+    src = sources()
+    return {
+        "name": PACKAGE,
+        "version": __version__,
+        "python": sys.version.split()[0],
+        "sources": src.get("sources", {}),
+    }
+
+
+def write_summary(out: Path, report: dict, workdir: Path) -> dict:
+    """Stamp the writer into ``manifest.json`` and write ``summary.json``.
+
+    The manifest gains ``writer: {name, version}`` (the link service and the
+    web build ignore keys they do not read). The summary is what the agent
+    hands to ``open_in_viewer``: a few KB, not the whole manifest. The link
+    service creates one upload slot per ``files`` entry plus one for the
+    manifest itself, whose sha256 it verifies on upload.
+    """
+    manifest_path = out / "manifest.json"
+    manifest = json.loads(manifest_path.read_text())
+    manifest["writer"] = {"name": PACKAGE, "version": __version__}
+    manifest_path.write_text(json.dumps(manifest, indent=1))
+    manifest_bytes = manifest_path.read_bytes()
+    files = [[f["key"], int(f["bytes"])] for f in manifest["files"]]
+    results = manifest.get("results") or {}
+    summary = {
+        "schemaVersion": manifest["schemaVersion"],
+        "writer": manifest["writer"],
+        "model": {k: manifest["model"].get(k) for k in ("name", "type", "ncpl", "nlay", "nper")},
+        "cells": report["cells"],
+        "results": {
+            "included": bool(results.get("included")),
+            "timestepsIncluded": len(results.get("timestepsIncluded") or []),
+            "timestepsTotal": int(results.get("timestepsTotal") or 0),
+        },
+        "manifest": {"bytes": len(manifest_bytes), "sha256": hashlib.sha256(manifest_bytes).hexdigest()},
+        "files": files,
+        "bytes": sum(b for _, b in files),
+        "snapshotDir": str(out),
+        "workdir": str(workdir),
+    }
+    (out / SUMMARY_FILE).write_text(json.dumps(summary, separators=(",", ":")) + "\n")
+    return summary
+
+
+def cmd_snapshot(args: argparse.Namespace) -> int:
+    if sys.version_info < MIN_PYTHON:
+        print(f"{PACKAGE} needs Python {MIN_PYTHON[0]}.{MIN_PYTHON[1]} or newer; this is {sys.version.split()[0]}. "
+              f"Install it in a newer interpreter: python3.12 -m pip install {PACKAGE}", file=sys.stderr)
+        return EXIT_ENVIRONMENT
+    missing = check_environment()
+    if missing:
+        print(f"Missing Python packages: {' '.join(missing)}. Reinstall {PACKAGE} in this interpreter so pip brings them:\n"
+              f"  {sys.executable} -m pip install --force-reinstall {PACKAGE}", file=sys.stderr)
+        return EXIT_ENVIRONMENT
+
+    workdir = Path(args.workdir).expanduser().resolve()
+    out = Path(args.out).expanduser().resolve()
+    if not workdir.is_dir():
+        print(f"no such directory: {workdir}", file=sys.stderr)
+        return EXIT_ENVIRONMENT
+    if not (workdir / "mfsim.nam").is_file():
+        print(f"{workdir} holds no mfsim.nam: pass the directory of the MODFLOW 6 simulation that was run.", file=sys.stderr)
+        return EXIT_ENVIRONMENT
+    if out.exists() and any(out.iterdir()):
+        print(f"{out} is not empty: pass a new or empty --out directory.", file=sys.stderr)
+        return EXIT_ENVIRONMENT
+
+    from .writer import ModelNotRunError, write_snapshot
+
+    kwargs = {"iso_surface_steps": args.iso_surfaces}
+    if args.max_head_files is not None:
+        kwargs["max_head_files"] = args.max_head_files
+    try:
+        report = write_snapshot(str(workdir), str(out), **kwargs)
+    except ModelNotRunError:
+        # The writer's own sentence names the browser's run_modflow; here the run is MODFLOW 6 on this machine.
+        print(f"This model has not been run yet: {workdir} holds no head file with timesteps. Run MODFLOW 6 on it first, then write the snapshot.", file=sys.stderr)
+        return EXIT_NOT_RUN
+
+    summary = write_summary(out, report, workdir)
+    print(json.dumps(summary, separators=(",", ":")))
+    print(f"snapshot written: {len(summary['files'])} files, {summary['bytes']} bytes, {summary['cells']} cells, "
+          f"{summary['results']['timestepsIncluded']}/{summary['results']['timestepsTotal']} timesteps, "
+          f"{report['write_seconds']:.1f} s. Next: call the MCP tool open_in_viewer with {out / SUMMARY_FILE}.", file=sys.stderr)
+    return 0
+
+
+def cmd_upload(args: argparse.Namespace) -> int:
+    from .upload import UploadError, upload_snapshot
+
+    snapshot = Path(args.snapshot).expanduser().resolve()
+    if not (snapshot / "manifest.json").is_file():
+        print(f"{snapshot} holds no manifest.json: pass the --out directory of mfai-viewer snapshot.", file=sys.stderr)
+        return EXIT_ENVIRONMENT
+    try:
+        result = upload_snapshot(snapshot, args.uploads_url, workers=args.workers, log=lambda line: print(line, file=sys.stderr))
+    except UploadError as err:
+        print(str(err), file=sys.stderr)
+        return EXIT_INCOMPLETE if err.missing else 1
+    print(json.dumps(result, indent=1))
+    return 0
+
+
+def cmd_version(_args: argparse.Namespace) -> int:
+    print(json.dumps(version_info(), indent=1))
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog=PACKAGE, description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--version", action="version", version=f"{PACKAGE} {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    snap = sub.add_parser("snapshot", help="write the viewer snapshot of a MODFLOW 6 simulation that was run")
+    snap.add_argument("--workdir", required=True, help="directory of the MODFLOW 6 simulation (mfsim.nam) after it ran")
+    snap.add_argument("--out", required=True, help="directory to write the snapshot into (created; must be empty or absent)")
+    snap.add_argument("--max-head-files", type=int, default=None, help="cap on heads files (layers x timesteps); default 90")
+    snap.add_argument("--iso-surfaces", choices=["last", "all", "none"], default="last", help="which timesteps get an iso-surface payload")
+    snap.set_defaults(func=cmd_snapshot)
+
+    up = sub.add_parser("upload", help="send a snapshot to the link open_in_viewer created and print the URL")
+    up.add_argument("snapshot", help="the snapshot directory (--out of mfai-viewer snapshot)")
+    up.add_argument("uploads_url", help="the uploads URL open_in_viewer answered")
+    up.add_argument("--workers", type=int, default=8, help="files in flight at once; default 8")
+    up.set_defaults(func=cmd_upload)
+
+    ver = sub.add_parser("version", help="print the package version and the source commits")
+    ver.set_defaults(func=cmd_version)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    try:
+        return int(args.func(args))
+    except KeyboardInterrupt:
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mfai_viewer-0.1.0/src/mfai_viewer/gwlink/backend/core/cln/types.py

@@ -0,0 +1,12 @@
+"""CLN type facade."""
+from .types_mesh import ClnConduitType, ClnGwConnection, ClnMesh, ClnNode
+from .types_params import AutoOr, ClnConduitParams, ClnWellParams
+from .types_source import ClnImportedData, ClnPackage, ClnSource, IMPORTED_CLN_SOURCE_ID
+from .types_targets import ClnBCTarget, ResolvedClnRecord, ResolvedClnTarget, SelectionMode
+
+__all__ = [
+    "AutoOr", "ClnWellParams", "ClnConduitParams", "ClnSource",
+    "ClnPackage", "ClnImportedData", "ClnNode", "ClnGwConnection",
+    "ClnConduitType", "ClnMesh", "ClnBCTarget", "ResolvedClnRecord",
+    "ResolvedClnTarget", "SelectionMode", "IMPORTED_CLN_SOURCE_ID",
+]

mfai_viewer-0.1.0/src/mfai_viewer/gwlink/backend/core/cln/types_mesh.py

@@ -0,0 +1,169 @@
+"""CLN mesh output models."""
+from __future__ import annotations
+
+from typing import Literal, Optional, Union
+from pydantic import BaseModel, Field
+
+ClnRawScalar = Union[int, float]
+
+class ClnNode(BaseModel):
+    """A single CLN node — one entry in the ``MfUsgCln`` ``node_prop`` table.
+
+    Example: a vertical well partially penetrating layers 0-2 produces
+    three :class:`ClnNode` entries (one per layer it intersects),
+    each with ``ifdir=0``, ``fangle=π/2``, and a ``fleng`` equal to
+    the screen length within that layer.
+
+    Attributes
+    ----------
+    index : int
+        1-based global IFNO (matches FloPy's ``MfUsgCln`` contract).
+    source_id : str
+        Which :class:`ClnSource` produced this node.
+    feature_index : int
+        0-based index of the originating feature within the source.
+    layer : int
+        0-based GWF layer hosting this node.
+    x, y : float
+        Horizontal coordinates in the model CRS.
+    z_top, z_bot : float
+        Top and bottom of the node's screen segment.
+    fleng : float
+        Screen length within this layer.
+    fangle : float
+        Inclination angle (rad). ``π/2`` for vertical wells.
+    ifdir : int
+        Direction flag — ``0=vertical``, ``1=horizontal``,
+        ``2=angled``.
+    iflin : int
+        Flow regime — ``0=laminar`` (default), ``-1=non-laminar``.
+    conduit_type : int
+        1-based index into :attr:`ClnMesh.conduit_types`.
+    gwf_cell_id : int
+        0-based host cell within its layer.
+    is_terminal, is_junction : bool
+        Network classification flags.
+    resolved_strt : float
+        Per-node starting head (defaults to ``z_bot`` / FELEV).
+    resolved_fskin : float
+        Per-node skin factor.
+    """
+    index: int
+    source_id: str
+    feature_index: int
+    layer: int
+    x: float
+    y: float
+    z_top: float
+    z_bot: float
+    fleng: float
+    fangle: float
+    ifdir: Literal[0, 1, 2]
+    iflin: Literal[-1, 0] = 0
+    conduit_type: int
+    gwf_cell_id: int
+    is_terminal: bool = False
+    is_junction: bool = False
+    resolved_strt: float
+    resolved_fskin: float
+
+
+class ClnGwConnection(BaseModel):
+    """One CLN-GWF coupling record in the ``cln_gwc`` table.
+
+    Each :class:`ClnNode` produces one connection per GWF cell it
+    intersects. The Thiem equation parameters live here, not on the
+    node itself, so a single node can couple to multiple cells with
+    different ``flengw`` and ``faniso`` values.
+
+    Attributes
+    ----------
+    cln_node_index : int
+        1-based, matches :attr:`ClnNode.index`.
+    gwf_node_index : int
+        1-based GWF node id, computed as
+        ``layer * ncpl + cell_id + 1``.
+    connection_type : int
+        ``0=Thiem``, ``1=Thiem+skin``. Default ``0``.
+    fskin : float
+        Skin factor (only consulted when
+        ``connection_type=1``). Default ``0.0``.
+    flengw : float
+        Wetted length (m).
+    faniso : float
+        Anisotropy factor for the surrounding cell. Default ``1.0``.
+    icgwadi : int
+        Adaptive-flow flag. Default ``0``.
+    """
+    cln_node_index: int
+    gwf_node_index: int
+    connection_type: int = 0
+    fskin: float = 0.0
+    flengw: float
+    faniso: float = 1.0
+    icgwadi: int = 0
+
+
+class ClnConduitType(BaseModel):
+    """Deduplicated conduit type table entry — one ``cln_circ`` row.
+
+    Identical (frad, conduitk) pairs are deduplicated so the
+    ``cln_circ`` table stays compact even when hundreds of nodes
+    share the same screen geometry.
+
+    Attributes
+    ----------
+    type_index : int
+        1-based row index.
+    frad : float
+        Effective radius (m).
+    conduitk : float
+        Conduit conductivity.
+    """
+    type_index: int
+    frad: float
+    conduitk: float
+
+
+class ClnMesh(BaseModel):
+    """Full CLN mesh ready for the FloPy adapter.
+
+    Example: a model with two well sources and one conduit source
+    produces a :class:`ClnMesh` whose ``len(nodes)`` is the total
+    node count, whose ``conduit_types`` deduplicates the screen
+    geometries, and whose ``nndcln`` records one entry per segment
+    (well or conduit).
+
+    Attributes
+    ----------
+    nodes : list[ClnNode]
+        Every CLN node, in IFNO order.
+    connections : list[ClnGwConnection]
+        Every CLN-GWF connection record.
+    conduit_types : list[ClnConduitType]
+        The deduplicated conduit type table.
+    nndcln : list[int]
+        Per-segment node counts, in segment order.
+    is_network : bool
+        Whether junction detection ran. Default ``False``.
+    clncon : list[list[int]], optional
+        Network connectivity table when :attr:`is_network` is ``True``.
+    """
+    nodes: list[ClnNode] = Field(default_factory=list)
+    connections: list[ClnGwConnection] = Field(default_factory=list)
+    conduit_types: list[ClnConduitType] = Field(default_factory=list)
+    nndcln: list[int] = Field(default_factory=list)
+    is_network: bool = False
+    clncon: Optional[list[list[int]]] = None
+    ncln: int = 0
+    nclnnds: int = 0
+    nja_cln: Optional[int] = None
+    iac_cln: Optional[list[int]] = None
+    ja_cln: Optional[list[int]] = None
+    node_prop: list[list[ClnRawScalar]] = Field(default_factory=list)
+    nclngwc: int = 0
+    cln_gwc: list[list[ClnRawScalar]] = Field(default_factory=list)
+    nconduityp: int = 1
+    cln_circ: list[list[ClnRawScalar]] = Field(default_factory=list)
+    ibound: list[int] = Field(default_factory=list)
+    strt: list[float] = Field(default_factory=list)