diff --git a/.github/workflows/julia-test-version.yaml b/.github/workflows/julia-test-version.yaml new file mode 100644 index 000000000..3d4be823a --- /dev/null +++ b/.github/workflows/julia-test-version.yaml @@ -0,0 +1,303 @@ +name: Test one Julia version + +on: + workflow_call: + inputs: + version: + required: true + type: string + +permissions: + contents: read + +jobs: + precompile: + name: Precompile ${{ inputs.version }} + runs-on: ubuntu-latest + timeout-minutes: 30 + outputs: + julia-version: ${{ steps.julia.outputs.julia-version }} + depot-key: ${{ steps.cache-keys.outputs.depot }} + gpec-key: ${{ steps.cache-keys.outputs.gpec }} + local-cache: ${{ steps.cache-keys.outputs.local }} + env: + GPEC_LOCAL_CACHE_DIR: ${{ vars.GPEC_LOCAL_CACHE_DIR }} + JULIA_CPU_TARGET: 'generic' + JULIA_NUM_THREADS: '2' + OPENBLAS_NUM_THREADS: '1' + DEPOT_PATHS: | + ~/.julia/artifacts + ~/.julia/packages + ~/.julia/registries + ~/.julia/compiled + ~/.julia/scratchspaces + ~/.julia/logs + + steps: + - name: Checkout repository + uses: actions/checkout@v6 + + - name: Fingerprint tracked package inputs + id: inputs + shell: bash + run: | + set -euo pipefail + fingerprint=$( + git ls-files -z -- Project.toml 'ci/manifests/Manifest-v*.toml' src | + sort -z | + while IFS= read -r -d '' file; do + sha256sum "$file" | cut -d ' ' -f 1 | xxd -r -p + done | + sha256sum | cut -d ' ' -f 1 + ) + echo "gpec=$fingerprint" >> "$GITHUB_OUTPUT" + echo "Tracked package fingerprint: $fingerprint" + + - name: Set up Julia + id: julia + uses: julia-actions/setup-julia@v2 + with: + version: ${{ inputs.version }} + + - name: Select cache keys and storage + id: cache-keys + env: + DEPOT_KEY: julia-depot-v3-generic-aot-ubuntu-latest-${{ runner.arch }}-${{ inputs.version }}-${{ steps.julia.outputs.julia-version }}-${{ hashFiles('Project.toml', 'ci/manifests/Manifest-v*.toml') }} + GPEC_KEY: gpec-images-v5-generic-aot-o2-bounds-yes-${{ runner.os }}-${{ runner.arch }}-${{ steps.julia.outputs.julia-version }}-${{ steps.inputs.outputs.gpec }} + RUNNER_ENVIRONMENT: ${{ runner.environment }} + run: | + echo "depot=$DEPOT_KEY" >> "$GITHUB_OUTPUT" + echo "gpec=$GPEC_KEY" >> "$GITHUB_OUTPUT" + if [ "$RUNNER_ENVIRONMENT" = self-hosted ] && [ -n "$GPEC_LOCAL_CACHE_DIR" ]; then + echo "local=true" >> "$GITHUB_OUTPUT" + else + echo "local=false" >> "$GITHUB_OUTPUT" + fi + + - name: Restore the local Julia snapshot + if: steps.cache-keys.outputs.local == 'true' + run: bash ci/local-julia-cache.sh restore "$CACHE_KEY" + env: + CACHE_KEY: ${{ steps.cache-keys.outputs.gpec }} + + # The prefix identifies compatible dependencies; a unique write key avoids stale reservations. + - name: Restore the Julia depot + id: depot + if: steps.cache-keys.outputs.local != 'true' + uses: actions/cache/restore@v4 + with: + path: ${{ env.DEPOT_PATHS }} + key: ${{ steps.cache-keys.outputs.depot }}-${{ github.run_id }}-${{ github.run_attempt }} + restore-keys: | + ${{ steps.cache-keys.outputs.depot }} + julia-depot-v3-generic-aot-ubuntu-latest-${{ runner.arch }}-${{ inputs.version }}-${{ steps.julia.outputs.julia-version }}- + julia-depot-v3-generic-aot-ubuntu-latest-${{ runner.arch }}-${{ inputs.version }}- + julia-depot-v4-generic-jit-ubuntu-latest-${{ runner.arch }}-${{ inputs.version }}-${{ steps.julia.outputs.julia-version }}- + + # The dependency cache is immutable and intentionally independent of src/. Layer + # a small source-keyed package cache over it so source changes can refresh GPEC + # without uploading another copy of the entire depot. Test-only PR updates reuse it. + - name: Restore GPEC compilation + id: gpec-cache + if: steps.cache-keys.outputs.local != 'true' + uses: actions/cache/restore@v4 + with: + path: ~/.julia/compiled/v*/GeneralizedPerturbedEquilibrium + key: ${{ steps.cache-keys.outputs.gpec }}-${{ github.run_id }}-${{ github.run_attempt }} + restore-keys: ${{ steps.cache-keys.outputs.gpec }} + + - name: Pin the CI dependency set + run: | + set -euo pipefail + + minor=$(julia -e 'print(VERSION.major, ".", VERSION.minor)') + pinned="ci/manifests/Manifest-v${minor}.toml" + + if [ ! -f "$pinned" ]; then + echo "::warning::No pinned dependency set for Julia ${minor}; resolving fresh. Generate one with 'julia +${minor} ci/manifests/update.jl'." + exit 0 + fi + + cp "$pinned" Manifest.toml + echo "Pinned dependency set: ${pinned}" + + recorded=$(cat ci/manifests/project.sha256) + actual=$(shasum -a 256 Project.toml | cut -d ' ' -f 1) + if [ "$recorded" != "$actual" ]; then + echo "::warning::Project.toml has changed since the pinned dependency sets were generated, so ${pinned} may be stale. Regenerate with ci/manifests/update.jl." + fi + + - name: Instantiate pinned dependencies + env: + JULIA_PKG_PRECOMPILE_AUTO: '0' + run: julia --project=. -e 'using Pkg; Pkg.instantiate()' + + # Coverage instrumentation is off: nothing consumes the .cov files (they are + # gitignored and never uploaded), and instrumenting slows compute-heavy + # numerical code noticeably. Set coverage: true and add a Codecov upload + # step together if coverage reporting is ever wanted. + - name: Check the production precompile workload + run: julia --check-bounds=yes --depwarn=yes --project=. -e 'using Pkg; Pkg.precompile(; strict=true); using GeneralizedPerturbedEquilibrium' + + - name: Save GPEC compilation + timeout-minutes: 3 + continue-on-error: true + if: success() && steps.cache-keys.outputs.local != 'true' && !startsWith(steps.gpec-cache.outputs.cache-matched-key, steps.cache-keys.outputs.gpec) + uses: actions/cache/save@v4 + with: + path: ~/.julia/compiled/v*/GeneralizedPerturbedEquilibrium + key: ${{ steps.gpec-cache.outputs.cache-primary-key }} + + # Refresh missing or incompatible dependency snapshots; reuse a matching prefix unchanged. + - name: Prune the depot before caching + if: success() && steps.cache-keys.outputs.local != 'true' && !startsWith(steps.depot.outputs.cache-matched-key, steps.cache-keys.outputs.depot) + run: julia --project=. -e 'using Pkg; Pkg.gc()' + + - name: Save the Julia depot + timeout-minutes: 3 + continue-on-error: true + if: success() && steps.cache-keys.outputs.local != 'true' && !startsWith(steps.depot.outputs.cache-matched-key, steps.cache-keys.outputs.depot) + uses: actions/cache/save@v4 + with: + path: ${{ env.DEPOT_PATHS }} + key: ${{ steps.depot.outputs.cache-primary-key }} + + - name: Publish the local Julia snapshot + if: steps.cache-keys.outputs.local == 'true' + run: bash ci/local-julia-cache.sh save "$CACHE_KEY" + env: + CACHE_KEY: ${{ steps.cache-keys.outputs.gpec }} + + # Caches are optional acceleration; this artifact is the required job handoff. + - name: Package the compiled test environment + if: steps.cache-keys.outputs.local != 'true' + run: | + set -euo pipefail + handoff="$RUNNER_TEMP/julia-test-environment" + mkdir -p "$handoff" + cp Manifest.toml "$handoff/Manifest.toml" + entries=() + for path in artifacts packages registries compiled scratchspaces logs; do + if [ -d "$HOME/.julia/$path" ]; then + entries+=(".julia/$path") + fi + done + tar -cf - -C "$HOME" "${entries[@]}" | zstd -T2 -3 -f -o "$handoff/depot.tar.zst" + + - name: Share the compiled test environment + if: steps.cache-keys.outputs.local != 'true' + uses: actions/upload-artifact@v4 + with: + name: julia-test-environment-${{ inputs.version }} + path: ${{ runner.temp }}/julia-test-environment/ + compression-level: 0 + retention-days: 1 + overwrite: true + if-no-files-found: error + + - name: Share the resolved dependency set + if: steps.cache-keys.outputs.local != 'true' + uses: actions/upload-artifact@v4 + with: + name: julia-test-manifest-${{ inputs.version }} + path: Manifest.toml + retention-days: 1 + overwrite: true + if-no-files-found: error + + test: + name: ${{ matrix.group }} + needs: precompile + runs-on: ubuntu-latest + timeout-minutes: 30 + strategy: + fail-fast: false + matrix: + group: [core, api, errorfields] + env: + GPEC_LOCAL_CACHE_DIR: ${{ vars.GPEC_LOCAL_CACHE_DIR }} + JULIA_CPU_TARGET: 'generic' + JULIA_NUM_THREADS: '2' + OPENBLAS_NUM_THREADS: '1' + GPEC_TEST_GROUP: ${{ matrix.group }} + steps: + - name: Checkout repository + uses: actions/checkout@v6 + + - name: Set up the precompiled Julia version + uses: julia-actions/setup-julia@v2 + with: + version: ${{ needs.precompile.outputs.julia-version }} + + - name: Try the compatible dependency cache + id: test-depot + if: needs.precompile.outputs.local-cache != 'true' + timeout-minutes: 2 + continue-on-error: true + uses: actions/cache/restore@v4 + with: + path: | + ~/.julia/artifacts + ~/.julia/packages + ~/.julia/registries + ~/.julia/compiled + ~/.julia/scratchspaces + ~/.julia/logs + key: ${{ needs.precompile.outputs.depot-key }} + restore-keys: ${{ needs.precompile.outputs.depot-key }} + + - name: Try the matching GPEC image + id: test-gpec + if: needs.precompile.outputs.local-cache != 'true' && steps.test-depot.outcome == 'success' && steps.test-depot.outputs.cache-matched-key != '' + timeout-minutes: 2 + continue-on-error: true + uses: actions/cache/restore@v4 + with: + path: ~/.julia/compiled/v*/GeneralizedPerturbedEquilibrium + key: ${{ needs.precompile.outputs.gpec-key }} + restore-keys: ${{ needs.precompile.outputs.gpec-key }} + + - name: Select the environment handoff + id: handoff + if: needs.precompile.outputs.local-cache != 'true' + env: + USE_ARTIFACT: ${{ steps.test-depot.outcome != 'success' || steps.test-depot.outputs.cache-matched-key == '' || steps.test-gpec.outcome != 'success' || steps.test-gpec.outputs.cache-matched-key == '' }} + run: echo "artifact=$USE_ARTIFACT" >> "$GITHUB_OUTPUT" + + - name: Restore the resolved dependency set + if: needs.precompile.outputs.local-cache != 'true' + uses: actions/download-artifact@v4 + with: + name: julia-test-manifest-${{ inputs.version }} + + - name: Download the compiled test environment + if: steps.handoff.outputs.artifact == 'true' + uses: actions/download-artifact@v4 + with: + name: julia-test-environment-${{ inputs.version }} + path: ${{ runner.temp }}/julia-test-environment/ + + - name: Restore the compiled test environment + if: steps.handoff.outputs.artifact == 'true' + run: | + set -euo pipefail + handoff="$RUNNER_TEMP/julia-test-environment" + depot=$(mktemp -d "$RUNNER_TEMP/julia-test-depot.XXXXXXXX") + zstd -dc "$handoff/depot.tar.zst" | tar -xf - -C "$depot" + echo "JULIA_DEPOT_PATH=$depot/.julia:" >> "$GITHUB_ENV" + cp "$handoff/Manifest.toml" Manifest.toml + + - name: Restore the local precompiled snapshot + if: needs.precompile.outputs.local-cache == 'true' + run: bash ci/local-julia-cache.sh require "$CACHE_KEY" + env: + CACHE_KEY: ${{ needs.precompile.outputs.gpec-key }} + + # Level 1 can reuse the higher-optimization production package images. + - name: Run tests + uses: julia-actions/julia-runtest@v1 + with: + coverage: false + check_bounds: 'yes' + optimize: '1' + allow_reresolve: false diff --git a/.github/workflows/make_docs.yaml b/.github/workflows/make_docs.yaml index f74f52f18..d73029abe 100644 --- a/.github/workflows/make_docs.yaml +++ b/.github/workflows/make_docs.yaml @@ -8,6 +8,8 @@ on: tags: - '*' pull_request: + merge_group: + types: [checks_requested] concurrency: # Skip intermediate builds: always. @@ -28,6 +30,10 @@ jobs: - name: Checkout repository uses: actions/checkout@v6 + - name: Disable the solver precompile workload + run: | + printf '[GeneralizedPerturbedEquilibrium]\nprecompile_workload = false\n' > docs/LocalPreferences.toml + - name: Set up Julia uses: julia-actions/setup-julia@v2 with: @@ -39,7 +45,7 @@ jobs: - name: Prepare docs environment (develop local package, then instantiate) run: julia --project=docs -e 'using Pkg; Pkg.activate("docs"); Pkg.develop(PackageSpec(path=".")); Pkg.instantiate(update_registry=false)' - - name: Build and deploy documentation + - name: Build documentation env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} run: julia --project=docs docs/make.jl diff --git a/.github/workflows/pr-conventions.yaml b/.github/workflows/pr-conventions.yaml index 7e688b103..ab7964843 100644 --- a/.github/workflows/pr-conventions.yaml +++ b/.github/workflows/pr-conventions.yaml @@ -25,7 +25,7 @@ permissions: jobs: validate: name: Title and release note - runs-on: ubuntu-latest + runs-on: ubuntu-slim steps: - uses: actions/checkout@v4 with: @@ -102,7 +102,7 @@ jobs: metadata: name: Label and metadata - runs-on: ubuntu-latest + runs-on: ubuntu-slim # Forked PRs get a read-only token, so these steps cannot run there. if: github.event.pull_request.head.repo.full_name == github.repository permissions: diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml index 596e565de..ee2a1eff1 100644 --- a/.github/workflows/test.yaml +++ b/.github/workflows/test.yaml @@ -4,6 +4,8 @@ on: # Every pull request, whatever its base, so a PR stacked on another feature branch # is tested too; it is tested again once retargeted, when it syncs with develop. pull_request: + merge_group: + types: [checks_requested] push: branches: - main @@ -14,14 +16,14 @@ permissions: concurrency: # One in-flight run per branch/PR. Superseded pull request runs are cancelled; - # runs on main/develop are allowed to finish so every merged commit is verified. + # Push and queue runs finish independently on their own refs. group: ${{ github.workflow }}-${{ github.ref }} cancel-in-progress: ${{ github.event_name == 'pull_request' }} jobs: changes: name: Detect Julia changes - runs-on: ubuntu-latest + runs-on: ubuntu-slim timeout-minutes: 5 permissions: contents: read @@ -35,6 +37,7 @@ jobs: GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} REPO: ${{ github.repository }} PR_NUMBER: ${{ github.event.pull_request.number }} + EVENT_NAME: ${{ github.event_name }} run: | set -euo pipefail @@ -42,10 +45,10 @@ jobs: # `why did/didn't this run?` is answerable from either one. say() { echo "$1"; echo "$1" >> "$GITHUB_STEP_SUMMARY"; } - # Pushes to main/develop always run: every merged commit gets verified. - if [ "${{ github.event_name }}" != "pull_request" ]; then + # Pushes and queue candidates always run the full battery. + if [ "$EVENT_NAME" != "pull_request" ]; then echo "julia=true" >> "$GITHUB_OUTPUT" - say "Not a pull request — running the full test suite." + say "Event $EVENT_NAME — running the full test suite." exit 0 fi @@ -58,7 +61,7 @@ jobs: # trigger a run, so new untested Julia (benchmarks, docs scripts, a # future tools/ directory) is excluded by default rather than by # remembering to exclude it. - tested='(^src/|^test/|^examples/|^ci/manifests/|^Project\.toml$|^\.github/workflows/test\.yaml$)' + tested='(^src/|^test/|^examples/|^ci/manifests/|^ci/local-julia-cache\.sh$|^Project\.toml$|^\.github/workflows/(test|julia-test-version)\.yaml$)' relevant=$(printf '%s\n' "$files" | grep -E "$tested" || true) @@ -85,108 +88,16 @@ jobs: fi test: - name: runtests ${{ matrix.version }} - ${{ matrix.os }} + name: Julia ${{ matrix.version }} needs: changes if: needs.changes.outputs.julia == 'true' - runs-on: ${{ matrix.os }} - timeout-minutes: 90 strategy: fail-fast: false matrix: - version: - - '1.11' - - '1.x' # latest (currently 1.12) - os: - - ubuntu-latest - - env: - DEPOT_PATHS: | - ~/.julia/artifacts - ~/.julia/packages - ~/.julia/registries - ~/.julia/compiled - ~/.julia/scratchspaces - ~/.julia/logs - - steps: - - name: Checkout repository - uses: actions/checkout@v6 - - - name: Set up Julia - id: julia - uses: julia-actions/setup-julia@v2 - with: - version: ${{ matrix.version }} - - # Keyed on the resolved Julia version, not the matrix label: precompiled .ji - # files are tied to the exact Julia build, so a patch release invalidates - # every one of them. Cache entries are immutable, so were the key not to - # rotate the run would recompile the whole tree, hit the unchanged key, skip - # the save as having nothing new, and repeat that forever. The version-only - # fallback still reuses packages, artifacts and registries across a bump; the - # next push to the default branch repopulates under the new key. - - name: Restore the Julia depot - id: depot - uses: actions/cache/restore@v4 - with: - path: ${{ env.DEPOT_PATHS }} - key: julia-depot-${{ matrix.os }}-${{ matrix.version }}-${{ steps.julia.outputs.julia-version }}-${{ hashFiles('Project.toml', 'ci/manifests/Manifest-v*.toml') }} - restore-keys: | - julia-depot-${{ matrix.os }}-${{ matrix.version }}-${{ steps.julia.outputs.julia-version }}- - julia-depot-${{ matrix.os }}-${{ matrix.version }}- - - - name: Pin the CI dependency set - run: | - set -euo pipefail - - minor=$(julia -e 'print(VERSION.major, ".", VERSION.minor)') - pinned="ci/manifests/Manifest-v${minor}.toml" - - if [ ! -f "$pinned" ]; then - echo "::warning::No pinned dependency set for Julia ${minor}; resolving fresh. Generate one with 'julia +${minor} ci/manifests/update.jl'." - exit 0 - fi - - cp "$pinned" Manifest.toml - echo "Pinned dependency set: ${pinned}" - - recorded=$(cat ci/manifests/project.sha256) - actual=$(shasum -a 256 Project.toml | cut -d ' ' -f 1) - if [ "$recorded" != "$actual" ]; then - echo "::warning::Project.toml has changed since the pinned dependency sets were generated, so ${pinned} may be stale. Regenerate with ci/manifests/update.jl." - fi - - - name: Build Julia packages - uses: julia-actions/julia-buildpkg@v1 - with: - ignore-no-cache: true - - # Coverage instrumentation is off: nothing consumes the .cov files (they are - # gitignored and never uploaded), and instrumenting slows compute-heavy - # numerical code noticeably. Set coverage: true and add a Codecov upload - # step together if coverage reporting is ever wanted. - - name: Run tests - uses: julia-actions/julia-runtest@v1 - with: - coverage: false - - # An exact hit has nothing new to store. Otherwise pushes refresh the shared - # default-branch entry, and a pull request writes one only when it restored - # nothing at all -- which happens when this key prefix is cold, as it is the - # first time this runs, after a matrix version is added, or once entries age - # out. That entry is scoped to the pull request's own ref and so cannot be - # reused by another, but seeding it beats discarding a full compile; once the - # default branch has an entry, pull requests always prefix-match and skip. - - name: Prune the depot before caching - if: always() && steps.depot.outputs.cache-hit != 'true' && (github.event_name == 'push' || steps.depot.outputs.cache-matched-key == '') - run: julia --project=. -e 'using Pkg; Pkg.gc()' - - - name: Save the Julia depot - if: always() && steps.depot.outputs.cache-hit != 'true' && (github.event_name == 'push' || steps.depot.outputs.cache-matched-key == '') - uses: actions/cache/save@v4 - with: - path: ${{ env.DEPOT_PATHS }} - key: julia-depot-${{ matrix.os }}-${{ matrix.version }}-${{ steps.julia.outputs.julia-version }}-${{ hashFiles('Project.toml', 'ci/manifests/Manifest-v*.toml') }} + version: ['1.11', '1.x'] + uses: ./.github/workflows/julia-test-version.yaml + with: + version: ${{ matrix.version }} # Stable check that is present on every pull request, whether or not the suite # ran. Point branch protection at this job so skipped runs do not block merges. @@ -194,7 +105,7 @@ jobs: name: Tests needs: [changes, test] if: always() - runs-on: ubuntu-latest + runs-on: ubuntu-slim timeout-minutes: 5 steps: - name: Report suite result diff --git a/ci/local-julia-cache.sh b/ci/local-julia-cache.sh new file mode 100644 index 000000000..2282e9a44 --- /dev/null +++ b/ci/local-julia-cache.sh @@ -0,0 +1,55 @@ +#!/usr/bin/env bash +# Publish immutable depot snapshots; restore into each runner's private depot. +set -euo pipefail + +operation=${1:?Expected restore, require, or save} +key=${2:?Expected a cache key} +: "${GPEC_LOCAL_CACHE_DIR:?Set the shared local cache directory}" +[[ "$key" =~ ^[a-zA-Z0-9._-]+$ ]] || { echo 'Invalid cache key' >&2; exit 1; } +entry="$GPEC_LOCAL_CACHE_DIR/$key" +paths=(artifacts packages registries compiled scratchspaces logs) + +case "$operation" in + restore|require) + if [[ ! -f "$entry/complete" ]]; then + echo "Local Julia cache miss: $key" + if [[ "$operation" == require ]]; then + echo 'The precompile job did not publish a usable local cache.' >&2 + exit 1 + fi + exit 0 + fi + mkdir -p "$HOME/.julia" + for path in "${paths[@]}"; do + if [[ -d "$entry/depot/$path" ]]; then + mkdir -p "$HOME/.julia/$path" + rsync -a "$entry/depot/$path/" "$HOME/.julia/$path/" + fi + done + cp "$entry/Manifest.toml" Manifest.toml + echo "Local Julia cache restored: $key" + ;; + save) + mkdir -p "$GPEC_LOCAL_CACHE_DIR" + # Readers only see complete snapshots; concurrent publishers reuse the winner. + exec 9>"$GPEC_LOCAL_CACHE_DIR/.publish.lock" + flock 9 + if [[ -f "$entry/complete" ]]; then + echo "Local Julia cache already published: $key" + exit 0 + fi + staging=$(mktemp -d "$GPEC_LOCAL_CACHE_DIR/.staging.XXXXXXXX") + trap 'rm -rf -- "$staging"' EXIT + mkdir "$staging/depot" + for path in "${paths[@]}"; do + if [[ -d "$HOME/.julia/$path" ]]; then + cp -a --reflink=auto "$HOME/.julia/$path" "$staging/depot/" + fi + done + cp Manifest.toml "$staging/Manifest.toml" + touch "$staging/complete" + mv -T "$staging" "$entry" + echo "Local Julia cache published: $key" + ;; + *) echo "Unknown operation: $operation" >&2; exit 1 ;; +esac diff --git a/ci/manifests/Manifest-v1.13.toml b/ci/manifests/Manifest-v1.13.toml new file mode 100644 index 000000000..459066e96 --- /dev/null +++ b/ci/manifests/Manifest-v1.13.toml @@ -0,0 +1,3501 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.13.3" +manifest_format = "2.1" +project_hash = "46cc8ae34afcb7a4b038db845711846a1cfd9266" + +[[deps.ADTypes]] +deps = ["PrecompileTools"] +git-tree-sha1 = "629de23e1c16911b439dabd2303c08af9575b226" +registries = "General" +uuid = "47edcb42-4c32-4615-8424-f2b9edc5f35b" +version = "1.24.0" + + [deps.ADTypes.extensions] + ADTypesChainRulesCoreExt = "ChainRulesCore" + ADTypesConstructionBaseExt = "ConstructionBase" + ADTypesEnzymeCoreExt = "EnzymeCore" + + [deps.ADTypes.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + +[[deps.AMD]] +deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse_jll"] +git-tree-sha1 = "344f3d221a6bee75925b5c97a30cfd870f12a138" +registries = "General" +uuid = "14f7f29c-3bd6-536c-9a0b-7339e30b5a3e" +version = "0.5.4" + +[[deps.ANSIColoredPrinters]] +git-tree-sha1 = "574baf8110975760d391c710b6341da1afa48d8c" +registries = "General" +uuid = "a4c015fc-c6ff-483c-b24f-f7ea428134e9" +version = "0.0.1" + +[[deps.AbstractFFTs]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "d92ad398961a3ed262d8bf04a1a2b8340f915fef" +registries = "General" +uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c" +version = "1.5.0" + + [deps.AbstractFFTs.extensions] + AbstractFFTsChainRulesCoreExt = "ChainRulesCore" + AbstractFFTsTestExt = "Test" + + [deps.AbstractFFTs.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.AbstractTrees]] +git-tree-sha1 = "2d9c9a55f9c93e8887ad391fbae72f8ef55e1177" +registries = "General" +uuid = "1520ce14-60c1-5f80-bbc7-55ef81b5835c" +version = "0.4.5" + +[[deps.Accessors]] +deps = ["CompositionsBase", "ConstructionBase", "Dates", "InverseFunctions", "MacroTools"] +git-tree-sha1 = "8c0bc12397dabf5d2dfc4b5763ec463854cc44d3" +registries = "General" +uuid = "7d9f7c33-5ae7-4f3b-8dc6-eff91059b697" +version = "0.1.46" + + [deps.Accessors.extensions] + AxisKeysExt = "AxisKeys" + IntervalSetsExt = "IntervalSets" + LinearAlgebraExt = "LinearAlgebra" + StaticArraysExt = "StaticArrays" + StructArraysExt = "StructArrays" + TestExt = "Test" + UnitfulExt = "Unitful" + + [deps.Accessors.weakdeps] + AxisKeys = "94b1ba4f-4ee9-5380-92f1-94cde586c3c5" + IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.Adapt]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "dee8388a9bec89c8713ad176f96960ae2f98598a" +registries = "General" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "4.7.4" +weakdeps = ["SparseArrays", "StaticArrays"] + + [deps.Adapt.extensions] + AdaptSparseArraysExt = "SparseArrays" + AdaptStaticArraysExt = "StaticArrays" + +[[deps.AdaptiveArrayPools]] +deps = ["Preferences", "Printf", "Random"] +git-tree-sha1 = "5feaa5055572e809b69b62f06826b1c1c8d3ebf3" +registries = "General" +uuid = "4f381ef7-9af0-4cbe-99d4-cf36d7b0f233" +version = "0.3.11" + + [deps.AdaptiveArrayPools.extensions] + AdaptiveArrayPoolsCUDAExt = "CUDA" + AdaptiveArrayPoolsMetalExt = "Metal" + + [deps.AdaptiveArrayPools.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + +[[deps.AdaptivePredicates]] +git-tree-sha1 = "7e651ea8d262d2d74ce75fdf47c4d63c07dba7a6" +registries = "General" +uuid = "35492f91-a3bd-45ad-95db-fcad7dcfedb7" +version = "1.2.0" + +[[deps.AliasTables]] +deps = ["PtrArrays", "Random"] +git-tree-sha1 = "9876e1e164b144ca45e9e3198d0b689cadfed9ff" +registries = "General" +uuid = "66dad0bd-aa9a-41b7-9441-69ab47430ed8" +version = "1.1.3" + +[[deps.ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.2" + +[[deps.ArrayInterface]] +deps = ["Adapt", "LinearAlgebra"] +git-tree-sha1 = "1aec1ff0dcaa83a484e7f72097562fa3102c6722" +registries = "General" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "7.30.2" + + [deps.ArrayInterface.extensions] + ArrayInterfaceAMDGPUExt = "AMDGPU" + ArrayInterfaceBandedMatricesExt = "BandedMatrices" + ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" + ArrayInterfaceCUDAExt = "CUDA" + ArrayInterfaceCUDSSExt = ["CUDSS", "CUDA"] + ArrayInterfaceChainRulesCoreExt = "ChainRulesCore" + ArrayInterfaceChainRulesExt = "ChainRules" + ArrayInterfaceFillArraysExt = "FillArrays" + ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceGPUArraysCoreTrackerExt = ["GPUArraysCore", "Tracker"] + ArrayInterfaceMetalExt = "Metal" + ArrayInterfaceReverseDiffExt = "ReverseDiff" + ArrayInterfaceSparseArraysExt = "SparseArrays" + ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" + ArrayInterfaceTrackerExt = "Tracker" + + [deps.ArrayInterface.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.ArrayLayouts]] +deps = ["FillArrays", "LinearAlgebra", "StaticArrays"] +git-tree-sha1 = "8fde25d92e917350570f1203e47c933d16b77dce" +registries = "General" +uuid = "4c555306-a7a7-4459-81d9-ec55ddd5c99a" +version = "1.16.0" +weakdeps = ["SparseArrays"] + + [deps.ArrayLayouts.extensions] + ArrayLayoutsSparseArraysExt = "SparseArrays" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" +version = "1.11.0" + +[[deps.AssetRegistry]] +deps = ["JSON", "Pidfile", "SHA"] +git-tree-sha1 = "902b85010203830d4bc02259f5450d2e16b316d8" +registries = "General" +uuid = "bf4720bc-e11a-5d0c-854e-bdca1663c893" +version = "0.1.1" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" +version = "1.11.0" + +[[deps.BitFlags]] +git-tree-sha1 = "bbe1079eecf9c9fbb52765193ad2bae27ae09bc8" +registries = "General" +uuid = "d1d4a3ce-64b1-5f1a-9ba4-7e7e69966f35" +version = "0.1.10" + +[[deps.BitTwiddlingConvenienceFunctions]] +deps = ["Static"] +git-tree-sha1 = "f21cfd4950cb9f0587d5067e69405ad2acd27b87" +registries = "General" +uuid = "62783981-4cbd-42fc-bca8-16325de8dc4b" +version = "0.1.6" + +[[deps.Blink]] +deps = ["Base64", "Distributed", "HTTP", "JSExpr", "JSON", "Lazy", "Logging", "MacroTools", "Mustache", "Mux", "Pkg", "Reexport", "Sockets", "WebIO"] +git-tree-sha1 = "bc93511973d1f949d45b0ea17878e6cb0ad484a1" +registries = "General" +uuid = "ad839575-38b3-5650-b840-f874b8c74a25" +version = "0.12.9" + +[[deps.BracketingNonlinearSolve]] +deps = ["CommonSolve", "ConcreteStructs", "NonlinearSolveBase", "PrecompileTools", "Reexport", "SciMLBase"] +git-tree-sha1 = "7ad7171d693ae5552ac43862e7f6b61df4471c2b" +registries = "General" +uuid = "70df07ce-3d50-431d-a3e7-ca6ddb60ac1e" +version = "1.12.1" + + [deps.BracketingNonlinearSolve.extensions] + BracketingNonlinearSolveChainRulesCoreExt = ["ChainRulesCore", "ForwardDiff"] + BracketingNonlinearSolveForwardDiffExt = "ForwardDiff" + + [deps.BracketingNonlinearSolve.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + +[[deps.Bzip2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1b96ea4a01afe0ea4090c5c8039690672dd13f2e" +registries = "General" +uuid = "6e34b625-4abd-537c-b88f-471c36dfa7a0" +version = "1.0.9+0" + +[[deps.CPUSummary]] +deps = ["CpuId", "IfElse", "PrecompileTools", "Preferences", "Static"] +git-tree-sha1 = "f3a21d7fc84ba618a779d1ed2fcca2e682865bab" +registries = "General" +uuid = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9" +version = "0.2.7" + +[[deps.CRlibm]] +deps = ["CRlibm_jll"] +git-tree-sha1 = "66188d9d103b92b6cd705214242e27f5737a1e5e" +registries = "General" +uuid = "96374032-68de-5a5b-8d9e-752f78720389" +version = "1.0.2" + +[[deps.CRlibm_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "e329286945d0cfc04456972ea732551869af1cfc" +registries = "General" +uuid = "4e9b3aee-d8a1-5a3d-ad8b-7d824db253f0" +version = "1.0.1+0" + +[[deps.Cairo_jll]] +deps = ["Artifacts", "Bzip2_jll", "CompilerSupportLibraries_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "JLLWrappers", "Libdl", "Pixman_jll", "Xorg_libXext_jll", "Xorg_libXrender_jll", "Zlib_jll", "libpng_jll"] +git-tree-sha1 = "0cfb779e24fdced77a05df1dbe99200821a9f563" +registries = "General" +uuid = "83423d85-b0ee-5818-9007-b63ccbeb887a" +version = "1.18.8+1" + +[[deps.ChunkCodecCore]] +git-tree-sha1 = "3496e2b359c27793d12bec54ec94be7983a6ceb2" +registries = "General" +uuid = "0b6fb165-00bc-4d37-ab8b-79f91016dbe1" +version = "1.0.2" + +[[deps.ChunkCodecLibZlib]] +deps = ["ChunkCodecCore", "Zlib_jll"] +git-tree-sha1 = "d4101e848e8d3f585d61d244c2fe0c80a70e6b3b" +registries = "General" +uuid = "4c0bbee4-addc-4d73-81a0-b6caacae83c8" +version = "1.1.0" + +[[deps.ChunkCodecLibZstd]] +deps = ["ChunkCodecCore", "Zstd_jll"] +git-tree-sha1 = "34d9873079e4cb3d0c62926a225136824677073f" +registries = "General" +uuid = "55437552-ac27-4d47-9aa3-63184e8fd398" +version = "1.0.0" + +[[deps.CloseOpenIntervals]] +deps = ["Static", "StaticArrayInterface"] +git-tree-sha1 = "05ba0d07cd4fd8b7a39541e31a7b0254704ea581" +registries = "General" +uuid = "fb6a15b2-703c-40df-9091-08a04967cfa9" +version = "0.1.13" + +[[deps.CodecZlib]] +deps = ["TranscodingStreams", "Zlib_jll"] +git-tree-sha1 = "970758a3d591a2a5c2a907c53f2e2f8c1b1d3537" +registries = "General" +uuid = "944b1d66-785c-5afd-91f1-9de20f533193" +version = "0.7.9" + +[[deps.ColorSchemes]] +deps = ["ColorTypes", "ColorVectorSpace", "Colors", "FixedPointNumbers", "PrecompileTools", "Random"] +git-tree-sha1 = "b0fd3f56fa442f81e0a47815c92245acfaaa4e34" +registries = "General" +uuid = "35d6a980-a343-548e-a6ea-1d62b119f2f4" +version = "3.31.0" + +[[deps.ColorTypes]] +deps = ["FixedPointNumbers", "Random"] +git-tree-sha1 = "a7cf827a79b378a381e31e5c7feca853ec19cb94" +registries = "General" +uuid = "3da002f7-5984-5a60-b8a6-cbb66c0b333f" +version = "0.12.4" +weakdeps = ["StyledStrings"] + + [deps.ColorTypes.extensions] + StyledStringsExt = "StyledStrings" + +[[deps.ColorVectorSpace]] +deps = ["ColorTypes", "FixedPointNumbers", "LinearAlgebra", "Requires", "Statistics", "TensorCore"] +git-tree-sha1 = "a4e53eb7a1779254f92c1cc1302c2bc6acdba560" +registries = "General" +uuid = "c3611d14-8923-5661-9e6a-0046d554d3a4" +version = "0.11.1" +weakdeps = ["SpecialFunctions"] + + [deps.ColorVectorSpace.extensions] + SpecialFunctionsExt = "SpecialFunctions" + +[[deps.Colors]] +deps = ["ColorTypes", "FixedPointNumbers", "LinearAlgebra", "Reexport"] +git-tree-sha1 = "a633156e74096f90b3b5e833529292b651b5671a" +registries = "General" +uuid = "5ae59095-9a9b-59fe-a467-6f913c188581" +version = "0.13.3" + +[[deps.CommonSolve]] +deps = ["PrecompileTools"] +git-tree-sha1 = "6c389fa857f6ca5a95474b52a52023fd77f24cb7" +registries = "General" +uuid = "38540f10-b2f7-11e9-35d8-d573e4eb0ff2" +version = "0.2.14" + +[[deps.CommonSubexpressions]] +deps = ["MacroTools"] +git-tree-sha1 = "cda2cfaebb4be89c9084adaca7dd7333369715c5" +registries = "General" +uuid = "bbf7d656-a473-5ed7-a52c-81e309532950" +version = "0.3.1" + +[[deps.CommonWorldInvalidations]] +deps = ["PrecompileTools"] +git-tree-sha1 = "7c4ea0adfb7238bf4678aa36325863fab6163f6f" +registries = "General" +uuid = "f70d9fcc-98c5-4d4a-abd7-e4cdeebd8ca8" +version = "1.2.2" + +[[deps.Compat]] +deps = ["TOML", "UUIDs"] +git-tree-sha1 = "9d8a54ce4b17aa5bdce0ea5c34bc5e7c340d16ad" +registries = "General" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "4.18.1" +weakdeps = ["Dates", "LinearAlgebra"] + + [deps.Compat.extensions] + CompatLinearAlgebraExt = "LinearAlgebra" + +[[deps.CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "1.5.5+2" + +[[deps.CompositionsBase]] +git-tree-sha1 = "802bb88cd69dfd1509f6670416bd4434015693ad" +registries = "General" +uuid = "a33af91c-f02d-484b-be07-31d278c5ca2b" +version = "0.1.2" +weakdeps = ["InverseFunctions"] + + [deps.CompositionsBase.extensions] + CompositionsBaseInverseFunctionsExt = "InverseFunctions" + +[[deps.ConcreteStructs]] +deps = ["PrecompileTools"] +git-tree-sha1 = "a72c3b5ce6d2a477f55b5c9b8756e91e695c67f6" +registries = "General" +uuid = "2569d6c7-a4a2-43d3-a901-331e8e4be471" +version = "0.2.8" + +[[deps.ConcurrentUtilities]] +deps = ["Serialization", "Sockets"] +git-tree-sha1 = "d5e5fa1f0d6ca517edbbcd734efa93c6639405b0" +registries = "General" +uuid = "f0e56b4a-5159-44fe-b623-3e5288b988bb" +version = "2.7.1" + +[[deps.ConstructionBase]] +git-tree-sha1 = "b4b092499347b18a015186eae3042f72267106cb" +registries = "General" +uuid = "187b0558-2788-49d3-abe0-74a17ed4e7c9" +version = "1.6.0" + + [deps.ConstructionBase.extensions] + ConstructionBaseIntervalSetsExt = "IntervalSets" + ConstructionBaseLinearAlgebraExt = "LinearAlgebra" + ConstructionBaseStaticArraysExt = "StaticArrays" + + [deps.ConstructionBase.weakdeps] + IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.Contour]] +git-tree-sha1 = "439e35b0b36e2e5881738abc8857bd92ad6ff9a8" +registries = "General" +uuid = "d38c429a-6771-53c6-b99e-75d170b6e991" +version = "0.6.3" + +[[deps.CoordinateConventions]] +git-tree-sha1 = "10832be51679db21271faac5bad7779a4320ca4b" +registries = "General" +uuid = "7204ce3a-f536-43d2-be4a-fbed74e90d86" +version = "1.0.5" + +[[deps.CoreMath]] +deps = ["CoreMath_jll"] +git-tree-sha1 = "8c0480f92b1b1796239156a1b9b1bfb1b39499b4" +registries = "General" +uuid = "b7a15901-be09-4a0e-87d2-2e66b0e09b5a" +version = "0.1.0" + +[[deps.CoreMath_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "a692a4c1dc59a4b8bc0b6403876eb3250fde2bc3" +registries = "General" +uuid = "a38c48d9-6df1-5ac9-9223-b6ada3b5572b" +version = "0.1.0+0" + +[[deps.CpuId]] +deps = ["Markdown", "PrecompileTools"] +git-tree-sha1 = "5dbd5150b96f29553fc3b553c6bfb0eadf7ac204" +registries = "General" +uuid = "adafc99b-e345-5852-983c-f28acb93d879" +version = "0.3.3" + +[[deps.Crayons]] +git-tree-sha1 = "54b76cbb40d9a0f5368c880725b2f141da77c94f" +registries = "General" +uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f" +version = "4.2.0" + +[[deps.DataAPI]] +git-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe" +registries = "General" +uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" +version = "1.16.0" + +[[deps.DataFrames]] +deps = ["Compat", "DataAPI", "DataStructures", "Future", "InlineStrings", "InvertedIndices", "IteratorInterfaceExtensions", "LinearAlgebra", "Markdown", "Missings", "PooledArrays", "PrecompileTools", "PrettyTables", "Printf", "Random", "Reexport", "SentinelArrays", "SortingAlgorithms", "Statistics", "TableTraits", "Tables", "Unicode"] +git-tree-sha1 = "5fab31e2e01e70ad66e3e24c968c264d1cf166d6" +registries = "General" +uuid = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" +version = "1.8.2" + +[[deps.DataInterpolations]] +deps = ["EnumX", "FindFirstFunctions", "ForwardDiff", "LinearAlgebra", "PrettyTables", "RecipesBase", "Reexport"] +git-tree-sha1 = "4d50e83772222ce023efb7d30632198828ea56a6" +registries = "General" +uuid = "82cc6244-b520-54b8-b5a6-8a565e85f1d0" +version = "8.10.0" + + [deps.DataInterpolations.extensions] + DataInterpolationsChainRulesCoreExt = "ChainRulesCore" + DataInterpolationsMakieExt = "Makie" + DataInterpolationsMooncakeExt = ["Mooncake", "ChainRulesCore"] + DataInterpolationsOptimExt = "Optim" + DataInterpolationsRegularizationToolsExt = "RegularizationTools" + DataInterpolationsSparseConnectivityTracerExt = ["SparseConnectivityTracer", "FillArrays"] + DataInterpolationsSymbolicsExt = "Symbolics" + + [deps.DataInterpolations.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b" + Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + Optim = "429524aa-4258-5aef-a3af-852621145aeb" + RegularizationTools = "29dad682-9a27-4bc3-9c72-016788665182" + SparseConnectivityTracer = "9f842d2f-2579-4b1d-911e-f412cf18a3f5" + Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.DataStructures]] +deps = ["OrderedCollections"] +git-tree-sha1 = "b0bc6d2cad1fed8b7fd59a1551a991cb3d2809e6" +registries = "General" +uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" +version = "0.19.6" + +[[deps.DataValueInterfaces]] +git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" +registries = "General" +uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464" +version = "1.0.0" + +[[deps.Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" +version = "1.11.0" + +[[deps.Dbus_jll]] +deps = ["Artifacts", "Expat_jll", "JLLWrappers", "Libdl"] +git-tree-sha1 = "473e9afc9cf30814eb67ffa5f2db7df82c3ad9fd" +registries = "General" +uuid = "ee1fde0b-3d02-5ea6-8484-8dfef6360eab" +version = "1.16.2+0" + +[[deps.DelaunayTriangulation]] +deps = ["AdaptivePredicates", "EnumX", "ExactPredicates", "Random"] +git-tree-sha1 = "e1e28f37cbdca4b594ad86ecfe2ee8f25796ebff" +registries = "General" +uuid = "927a84f5-c5f4-47a5-9785-b46e178433df" +version = "1.7.0" + +[[deps.DelimitedFiles]] +deps = ["Mmap"] +git-tree-sha1 = "9e2f36d3c96a820c678f2f1f1782582fcf685bae" +registries = "General" +uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab" +version = "1.9.1" + +[[deps.DiffEqBase]] +deps = ["ArrayInterface", "BracketingNonlinearSolve", "ConcreteStructs", "DocStringExtensions", "FastBroadcast", "FastClosures", "FastPower", "FunctionWrappers", "FunctionWrappersWrappers", "LinearAlgebra", "Logging", "Markdown", "MuladdMacro", "PrecompileTools", "Printf", "RecursiveArrayTools", "Reexport", "SciMLBase", "SciMLLogging", "SciMLOperators", "SciMLStructures", "Setfield", "Static", "StaticArraysCore", "SymbolicIndexingInterface", "TruncatedStacktraces"] +git-tree-sha1 = "9d333db14895e8c7d4857ed228eb1e72d3b302ec" +registries = "General" +uuid = "2b5f629d-d688-5b77-993f-72d75c75574e" +version = "6.218.0" + + [deps.DiffEqBase.extensions] + DiffEqBaseCUDAExt = "CUDA" + DiffEqBaseChainRulesCoreExt = "ChainRulesCore" + DiffEqBaseDynamicQuantitiesExt = "DynamicQuantities" + DiffEqBaseEnzymeExt = ["ChainRulesCore", "Enzyme"] + DiffEqBaseFlexUnitsExt = "FlexUnits" + DiffEqBaseForwardDiffExt = ["ForwardDiff"] + DiffEqBaseGTPSAExt = "GTPSA" + DiffEqBaseGeneralizedGeneratedExt = "GeneralizedGenerated" + DiffEqBaseMPIExt = "MPI" + DiffEqBaseMeasurementsExt = "Measurements" + DiffEqBaseMonteCarloMeasurementsExt = "MonteCarloMeasurements" + DiffEqBaseMooncakeExt = "Mooncake" + DiffEqBaseReverseDiffExt = "ReverseDiff" + DiffEqBaseSparseArraysExt = "SparseArrays" + DiffEqBaseTrackerExt = "Tracker" + DiffEqBaseUnitfulExt = "Unitful" + + [deps.DiffEqBase.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" + DynamicQuantities = "06fc5a27-2a28-4c7c-a15d-362465fb6821" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + FlexUnits = "76e01b6b-c995-4ce6-8559-91e72a3d4e95" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + GTPSA = "b27dd330-f138-47c5-815b-40db9dd9b6e8" + GeneralizedGenerated = "6b9d7cbe-bcb9-11e9-073f-15a7a543e2eb" + MPI = "da04e1cc-30fd-572f-bb4f-1f8673147195" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.DiffEqCallbacks]] +deps = ["ConcreteStructs", "DataStructures", "DiffEqBase", "DifferentiationInterface", "LinearAlgebra", "Markdown", "PrecompileTools", "RecipesBase", "RecursiveArrayTools", "SciMLBase", "StaticArraysCore"] +git-tree-sha1 = "88cdec45374d53393bf88268102a2b018c897178" +registries = "General" +uuid = "459566f4-90b8-5000-8ac3-15dfb0a30def" +version = "4.19.2" + + [deps.DiffEqCallbacks.extensions] + DiffEqCallbacksFunctorsExt = "Functors" + + [deps.DiffEqCallbacks.weakdeps] + Functors = "d9f16b24-f501-4c13-a1f2-28368ffc5196" + +[[deps.DiffResults]] +deps = ["StaticArraysCore"] +git-tree-sha1 = "782dd5f4561f5d267313f23853baaaa4c52ea621" +registries = "General" +uuid = "163ba53b-c6d8-5494-b064-1a9d43ac40c5" +version = "1.1.0" + +[[deps.DiffRules]] +deps = ["IrrationalConstants", "LogExpFunctions", "NaNMath", "Random", "SpecialFunctions"] +git-tree-sha1 = "79a2aca180a85c690c58a020d47b426954b590f8" +registries = "General" +uuid = "b552c78f-8df3-52c6-915a-8e097449b14b" +version = "1.16.0" + +[[deps.DifferentiationInterface]] +deps = ["ADTypes", "LinearAlgebra"] +git-tree-sha1 = "0693d8b0a4608ff289d228ab4c598df5894845cd" +registries = "General" +uuid = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63" +version = "0.7.21" + + [deps.DifferentiationInterface.extensions] + DifferentiationInterfaceChainRulesCoreExt = "ChainRulesCore" + DifferentiationInterfaceDiffractorExt = "Diffractor" + DifferentiationInterfaceEnzymeExt = ["EnzymeCore", "Enzyme"] + DifferentiationInterfaceFastDifferentiationExt = "FastDifferentiation" + DifferentiationInterfaceFiniteDiffExt = "FiniteDiff" + DifferentiationInterfaceFiniteDifferencesExt = "FiniteDifferences" + DifferentiationInterfaceForwardDiffExt = ["ForwardDiff", "DiffResults"] + DifferentiationInterfaceGPUArraysCoreExt = ["GPUArraysCore", "Adapt"] + DifferentiationInterfaceGTPSAExt = "GTPSA" + DifferentiationInterfaceHyperHessiansExt = "HyperHessians" + DifferentiationInterfaceMooncakeExt = "Mooncake" + DifferentiationInterfacePolyesterForwardDiffExt = ["PolyesterForwardDiff", "ForwardDiff", "DiffResults"] + DifferentiationInterfaceReverseDiffExt = ["ReverseDiff", "DiffResults"] + DifferentiationInterfaceSparseArraysExt = "SparseArrays" + DifferentiationInterfaceSparseConnectivityTracerExt = "SparseConnectivityTracer" + DifferentiationInterfaceSparseMatrixColoringsExt = "SparseMatrixColorings" + DifferentiationInterfaceStaticArraysExt = "StaticArrays" + DifferentiationInterfaceSymbolicsExt = "Symbolics" + DifferentiationInterfaceTrackerExt = "Tracker" + DifferentiationInterfaceZygoteExt = ["Zygote", "ForwardDiff"] + + [deps.DifferentiationInterface.weakdeps] + Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + DiffResults = "163ba53b-c6d8-5494-b064-1a9d43ac40c5" + Diffractor = "9f5e2b26-1114-432f-b630-d3fe2085c51c" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + FastDifferentiation = "eb9bf01b-bf85-4b60-bf87-ee5de06c00be" + FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41" + FiniteDifferences = "26cc04aa-876d-5657-8c51-4c34ba976000" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + GTPSA = "b27dd330-f138-47c5-815b-40db9dd9b6e8" + HyperHessians = "06b494a0-c8e0-40cc-ad32-d99506a00a6c" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + PolyesterForwardDiff = "98d1487c-24ca-40b6-b7ab-df2af84e126b" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + SparseConnectivityTracer = "9f842d2f-2579-4b1d-911e-f412cf18a3f5" + SparseMatrixColorings = "0a514795-09f3-496d-8182-132a7b665d35" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.Distributed]] +deps = ["Random", "Serialization", "Sockets"] +uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b" +version = "1.11.0" + +[[deps.DocStringExtensions]] +git-tree-sha1 = "7442a5dfe1ebb773c29cc2962a8980f47221d76c" +registries = "General" +uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae" +version = "0.9.5" + +[[deps.Documenter]] +deps = ["ANSIColoredPrinters", "AbstractTrees", "Base64", "CodecZlib", "Dates", "DocStringExtensions", "Downloads", "Git", "IOCapture", "InteractiveUtils", "JSON", "Logging", "Markdown", "MarkdownAST", "Pkg", "PrecompileTools", "REPL", "RegistryInstances", "SHA", "TOML", "Test", "Unicode"] +git-tree-sha1 = "191e6bef0cf32cac3a3913cd4787d851715254c2" +registries = "General" +uuid = "e30172f5-a6a5-5a46-863b-614d45cd2de4" +version = "1.19.0" + +[[deps.DoubleFloats]] +deps = ["GenericLinearAlgebra", "GenericSchur", "LinearAlgebra", "Printf", "Quadmath", "Random", "SpecialFunctions"] +git-tree-sha1 = "00720e467f998dc28d6bd3ec2fe33b1d04155f6c" +registries = "General" +uuid = "497a8b3b-efae-58df-a0af-a86822472b78" +version = "1.12.0" + +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.7.0" + +[[deps.EnumX]] +git-tree-sha1 = "c49898e8438c828577f04b92fc9368c388ac783c" +registries = "General" +uuid = "4e289a0a-7415-4d19-859d-a7e5c4648b56" +version = "1.0.7" + +[[deps.EnzymeCore]] +git-tree-sha1 = "04c4269956f90d8f5c9acc73b774c5293481f4d7" +registries = "General" +uuid = "f151be2c-9106-41f4-ab19-57ee4f262869" +version = "0.8.26" + + [deps.EnzymeCore.extensions] + AdaptExt = "Adapt" + EnzymeCoreChainRulesCoreExt = "ChainRulesCore" + + [deps.EnzymeCore.weakdeps] + Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + +[[deps.EpollShim_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "8a4be429317c42cfae6a7fc03c31bad1970c310d" +registries = "General" +uuid = "2702e6a9-849d-5ed8-8c21-79e8b8f9ee43" +version = "0.0.20230411+1" + +[[deps.ExactPredicates]] +deps = ["IntervalArithmetic", "Random", "StaticArrays"] +git-tree-sha1 = "83231673ea4d3d6008ac74dc5079e77ab2209d8f" +registries = "General" +uuid = "429591f6-91af-11e9-00e2-59fbe8cec110" +version = "2.2.9" + +[[deps.ExceptionUnwrapping]] +deps = ["Test"] +git-tree-sha1 = "4e468f521e1f9f86891cb07186de5df90360a666" +registries = "General" +uuid = "460bff9d-24e4-43bc-9d9f-a8973cb893f4" +version = "0.1.12" + +[[deps.Expat_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d0f666deaf8099a7d7ac229a74402ada88898be1" +registries = "General" +uuid = "2e619515-83b5-522b-bb60-26c02a35a201" +version = "2.9.0+0" + +[[deps.ExponentialUtilities]] +deps = ["Adapt", "ArrayInterface", "GPUArraysCore", "GenericSchur", "LinearAlgebra", "PrecompileTools", "Printf", "SparseArrays", "libblastrampoline_jll"] +git-tree-sha1 = "a3c8b66f8813b721a45bfe3cf32acf793aed78bb" +registries = "General" +uuid = "d4d017d3-3776-5f7e-afef-a10c40355c18" +version = "1.31.0" +weakdeps = ["StaticArrays"] + + [deps.ExponentialUtilities.extensions] + ExponentialUtilitiesStaticArraysExt = "StaticArrays" + +[[deps.ExprTools]] +git-tree-sha1 = "d2e49e7efd29719d6f28b891b0e0e159daa9d2b4" +registries = "General" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.11" + +[[deps.ExproniconLite]] +git-tree-sha1 = "c13f0b150373771b0fdc1713c97860f8df12e6c2" +registries = "General" +uuid = "55351af7-c7e9-48d6-89ff-24e801d99491" +version = "0.10.14" + +[[deps.FFMPEG]] +deps = ["FFMPEG_jll"] +git-tree-sha1 = "7bd13840b4148949e290748071bbe6826b3eabcd" +registries = "General" +uuid = "c87230d0-a227-11e9-1b43-d7ebe4e7570a" +version = "0.4.6" + +[[deps.FFMPEG_jll]] +deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "JLLWrappers", "LAME_jll", "Libdl", "Ogg_jll", "OpenSSL_jll", "Opus_jll", "PCRE2_jll", "Zlib_jll", "libaom_jll", "libass_jll", "libfdk_aac_jll", "libva_jll", "libvorbis_jll", "x264_jll", "x265_jll"] +git-tree-sha1 = "d9d3cd382f2c999f684e6bfa4039fcc16c153b6f" +registries = "General" +uuid = "b22a6f82-2f65-5046-a5b2-351ab43fb4e5" +version = "9.0.2+0" + +[[deps.FFTW]] +deps = ["AbstractFFTs", "FFTW_jll", "Libdl", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"] +git-tree-sha1 = "97f08406df914023af55ade2f843c39e99c5d969" +registries = "General" +uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +version = "1.10.0" + +[[deps.FFTW_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6866aec60ef98e3164cd8d6855225684207e9dff" +registries = "General" +uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a" +version = "3.3.12+0" + +[[deps.FastBroadcast]] +deps = ["ArrayInterface", "LinearAlgebra", "PrecompileTools"] +git-tree-sha1 = "b90aee4f191474eeda3dfa0cb588635f80820cf1" +registries = "General" +uuid = "7034ab61-46d4-4ed7-9d0f-46aef9175898" +version = "1.5.0" + + [deps.FastBroadcast.extensions] + FastBroadcastPolyesterExt = "Polyester" + FastBroadcastStaticExt = "Static" + FixedSizeArraysExt = "FixedSizeArrays" + + [deps.FastBroadcast.weakdeps] + FixedSizeArrays = "3821ddf9-e5b5-40d5-8e25-6813ab96b5e2" + Polyester = "f517fe37-dbe3-4b94-8317-1923a5111588" + Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" + +[[deps.FastClosures]] +git-tree-sha1 = "acebe244d53ee1b461970f8910c235b259e772ef" +registries = "General" +uuid = "9aa1b823-49e4-5ca5-8b0f-3971ec8bab6a" +version = "0.3.2" + +[[deps.FastGaussQuadrature]] +deps = ["LinearAlgebra", "SpecialFunctions", "StaticArrays"] +git-tree-sha1 = "4916117dd032ec5959b7633aedbbac408ca5ddeb" +registries = "General" +uuid = "442a2c76-b920-505d-bb47-c5924d526838" +version = "1.3.0" + +[[deps.FastInterpolations]] +deps = ["AdaptiveArrayPools", "HelpPlots", "LinearAlgebra", "Preferences", "Printf"] +git-tree-sha1 = "f7bcd496f0a2e4e1174e7e1f667f27fb671fd7df" +registries = "General" +uuid = "9ea80cae-fc13-4c00-8066-6eaedb12f34b" +version = "0.4.20" + + [deps.FastInterpolations.extensions] + FastInterpolationsChainRulesCoreExt = "ChainRulesCore" + FastInterpolationsColorVectorSpaceExt = ["ColorTypes", "ColorVectorSpace"] + FastInterpolationsEnzymeExt = "Enzyme" + FastInterpolationsForwardDiffExt = "ForwardDiff" + FastInterpolationsRecipesBaseExt = "RecipesBase" + FastInterpolationsSymbolicsExt = ["Symbolics", "SymbolicUtils"] + + [deps.FastInterpolations.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ColorTypes = "3da002f7-5984-5a60-b8a6-cbb66c0b333f" + ColorVectorSpace = "c3611d14-8923-5661-9e6a-0046d554d3a4" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" + SymbolicUtils = "d1185830-fcd6-423d-90d6-eec64667417b" + Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7" + +[[deps.FastPower]] +deps = ["PrecompileTools"] +git-tree-sha1 = "a6bcbd090fc6b6f022fc0ad96f77ba31b9577282" +registries = "General" +uuid = "a4df4552-cc26-4903-aec0-212e50a0e84b" +version = "1.5.1" + + [deps.FastPower.extensions] + FastPowerEnzymeExt = "Enzyme" + FastPowerForwardDiffExt = "ForwardDiff" + FastPowerMeasurementsExt = "Measurements" + FastPowerMonteCarloMeasurementsExt = "MonteCarloMeasurements" + FastPowerMooncakeExt = "Mooncake" + FastPowerReverseDiffExt = "ReverseDiff" + FastPowerTrackerExt = "Tracker" + + [deps.FastPower.weakdeps] + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.FileIO]] +deps = ["Pkg", "Requires", "UUIDs"] +git-tree-sha1 = "6621fef488e496356c9c9625d0562c12a6070819" +registries = "General" +uuid = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549" +version = "1.20.0" +weakdeps = ["HTTP"] + + [deps.FileIO.extensions] + HTTPExt = "HTTP" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" +version = "1.11.0" + +[[deps.FillArrays]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "831f86fde78ab7f6470d6ba4d1161a11fb6b4ec0" +registries = "General" +uuid = "1a297f60-69ca-5386-bcde-b61e274b549b" +version = "1.18.2" + + [deps.FillArrays.extensions] + FillArraysPDMatsExt = "PDMats" + FillArraysSparseArraysExt = "SparseArrays" + FillArraysStaticArraysExt = "StaticArrays" + FillArraysStatisticsExt = "Statistics" + + [deps.FillArrays.weakdeps] + PDMats = "90014a1f-27ba-587c-ab20-58faa44d9150" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" + +[[deps.FindFirstFunctions]] +deps = ["PrecompileTools"] +git-tree-sha1 = "27b495de668ccea58de6b06d6d13181396598ea0" +registries = "General" +uuid = "64ca27bc-2ba2-4a57-88aa-44e436879224" +version = "1.8.0" + +[[deps.FiniteDiff]] +deps = ["ArrayInterface", "LinearAlgebra", "Setfield"] +git-tree-sha1 = "5031f23e040bf17082e5b52422d77b5e844eefb1" +registries = "General" +uuid = "6a86dc24-6348-571c-b903-95158fe2bd41" +version = "2.33.0" + + [deps.FiniteDiff.extensions] + FiniteDiffBandedMatricesExt = "BandedMatrices" + FiniteDiffBlockBandedMatricesExt = "BlockBandedMatrices" + FiniteDiffSparseArraysExt = "SparseArrays" + FiniteDiffStaticArraysExt = "StaticArrays" + + [deps.FiniteDiff.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.FixedPointNumbers]] +deps = ["Random", "Statistics"] +git-tree-sha1 = "59af96b98217c6ef4ae0dfe065ac7c20831d1a84" +registries = "General" +uuid = "53c48c17-4a7d-5ca2-90c5-79b7896eea93" +version = "0.8.6" + +[[deps.Fontconfig_jll]] +deps = ["Artifacts", "Bzip2_jll", "Expat_jll", "FreeType2_jll", "JLLWrappers", "Libdl", "Libuuid_jll", "Zlib_jll"] +git-tree-sha1 = "e1e9ba3a8f5d71e6ae698f138a1362aeabb42e9f" +registries = "General" +uuid = "a3f928ae-7b40-5064-980b-68af3947d34b" +version = "2.18.3+0" + +[[deps.Format]] +git-tree-sha1 = "9c68794ef81b08086aeb32eeaf33531668d5f5fc" +registries = "General" +uuid = "1fa38f19-a742-5d3f-a2b9-30dd87b9d5f8" +version = "1.3.7" + +[[deps.ForwardDiff]] +deps = ["CommonSubexpressions", "DiffResults", "DiffRules", "LinearAlgebra", "LogExpFunctions", "NaNMath", "Preferences", "Printf", "Random", "SpecialFunctions"] +git-tree-sha1 = "3b0f72e2ffef1a139ac450725c9ecd01c0a3c050" +registries = "General" +uuid = "f6369f11-7733-5829-9624-2563aa707210" +version = "1.4.6" +weakdeps = ["StaticArrays"] + + [deps.ForwardDiff.extensions] + ForwardDiffStaticArraysExt = "StaticArrays" + +[[deps.FreeType2_jll]] +deps = ["Artifacts", "Bzip2_jll", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "d95a7a3a7e0f2fffc6291bd33035830aab01310b" +registries = "General" +uuid = "d7e528f0-a631-5988-bf34-fe36492bcfd7" +version = "2.15.0+0" + +[[deps.FriBidi_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "f3f50c8001bdfa84f312234fa86715b7c9243771" +registries = "General" +uuid = "559328eb-81f9-559d-9380-de523a88c83c" +version = "1.0.18+0" + +[[deps.FunctionWrappers]] +git-tree-sha1 = "d62485945ce5ae9c0c48f124a84998d755bae00e" +registries = "General" +uuid = "069b7b12-0de2-55c6-9aab-29f3d0a68a2e" +version = "1.1.3" + +[[deps.FunctionWrappersWrappers]] +deps = ["FunctionWrappers", "PrecompileTools", "SciMLPublic"] +git-tree-sha1 = "2bcce3ad6f6977d617928d7707fdc86ac83cce03" +registries = "General" +uuid = "77dc65aa-8811-40c2-897b-53d922fa7daf" +version = "1.13.0" + + [deps.FunctionWrappersWrappers.extensions] + FunctionWrappersWrappersEnzymeExt = ["Enzyme", "EnzymeCore"] + FunctionWrappersWrappersMooncakeExt = "Mooncake" + + [deps.FunctionWrappersWrappers.weakdeps] + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + +[[deps.FunctionalCollections]] +deps = ["Test"] +git-tree-sha1 = "04cb9cfaa6ba5311973994fe3496ddec19b6292a" +registries = "General" +uuid = "de31a74c-ac4f-5751-b3fd-e18cd04993ca" +version = "0.5.0" + +[[deps.Future]] +deps = ["Random"] +uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820" +version = "1.11.0" + +[[deps.GLFW_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libglvnd_jll", "Xorg_libXcursor_jll", "Xorg_libXi_jll", "Xorg_libXinerama_jll", "Xorg_libXrandr_jll", "libdecor_jll", "xkbcommon_jll"] +git-tree-sha1 = "64bbbb7d1499297751b536dd39c58b20750ab1db" +registries = "General" +uuid = "0656b61e-2033-5cc2-a64a-77c0f6c09b89" +version = "3.5.1+0" + +[[deps.GPUArraysCore]] +deps = ["Adapt"] +git-tree-sha1 = "0b2b3e8b8fb7c1f5ddbf498be2eb2b3b37c9c0ed" +registries = "General" +uuid = "46192b85-c4d5-4398-a991-12ede77f4527" +version = "0.2.1" + +[[deps.GR]] +deps = ["Artifacts", "Base64", "DelimitedFiles", "Downloads", "GR_jll", "JSON", "Libdl", "LinearAlgebra", "Preferences", "Printf", "Qt6Wayland_jll", "Random", "Serialization", "Sockets", "TOML", "Tar", "Test", "p7zip_jll"] +git-tree-sha1 = "4d777f73c46b46b8b5276206059cf8a195499314" +registries = "General" +uuid = "28b8d3ca-fb5f-59d9-8090-bfdbd6d07a71" +version = "0.73.27" + + [deps.GR.extensions] + IJuliaExt = "IJulia" + + [deps.GR.weakdeps] + IJulia = "7073ff75-c697-5162-941a-fcdaad2a7d2a" + +[[deps.GR_jll]] +deps = ["Artifacts", "Bzip2_jll", "Cairo_jll", "FFMPEG_jll", "Fontconfig_jll", "FreeType2_jll", "GLFW_jll", "JLLWrappers", "JpegTurbo_jll", "Libdl", "Libtiff_jll", "Pixman_jll", "Qt6Base_jll", "Zlib_jll", "libpng_jll"] +git-tree-sha1 = "f8eb8f7ba13ea75083531647fc8faeda8d541f07" +registries = "General" +uuid = "d2c73de3-f751-5644-a686-071e5b155ba9" +version = "0.73.27+0" + +[[deps.GeneralizedPerturbedEquilibrium]] +deps = ["AdaptiveArrayPools", "CommonSolve", "Contour", "Dates", "DelaunayTriangulation", "DelimitedFiles", "DiffEqCallbacks", "Documenter", "DoubleFloats", "FFTW", "FastGaussQuadrature", "FastInterpolations", "HDF5", "IMASdd", "JLD2", "LaTeXStrings", "LinearAlgebra", "Logging", "OrdinaryDiffEq", "Pkg", "PlotlyJS", "Plots", "PrecompileTools", "Printf", "QuadGK", "Random", "Roots", "SparseArrays", "SpecialFunctions", "StaticArrays", "Statistics", "TOML", "Test"] +path = "." +uuid = "462872dd-e066-4d2e-b993-6468b5239634" +version = "0.1.0" + +[[deps.GenericLinearAlgebra]] +deps = ["LinearAlgebra", "Printf", "Random", "libblastrampoline_jll"] +git-tree-sha1 = "961f8a5d33f043e02cdf2b8020e3a7b0aae78474" +registries = "General" +uuid = "14197337-ba66-59df-a3e3-ca00e7dcff7a" +version = "0.4.1" + +[[deps.GenericSchur]] +deps = ["LinearAlgebra", "MatrixFactorizations", "Preferences", "Printf", "UUIDs"] +git-tree-sha1 = "e3d1202ab9ae72edd4c46134ecbb6746ec420486" +registries = "General" +uuid = "c145ed77-6b09-5dd9-b285-bf645a82121e" +version = "0.5.8" + +[[deps.GettextRuntime_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Libiconv_jll"] +git-tree-sha1 = "45288942190db7c5f760f59c04495064eedf9340" +registries = "General" +uuid = "b0724c58-0f36-5564-988d-3bb0596ebc4a" +version = "0.22.4+0" + +[[deps.Ghostscript_jll]] +deps = ["Artifacts", "JLLWrappers", "JpegTurbo_jll", "Libdl", "Zlib_jll"] +git-tree-sha1 = "38044a04637976140074d0b0621c1edf0eb531fd" +registries = "General" +uuid = "61579ee1-b43e-5ca0-a5da-69d92c66a64b" +version = "9.55.1+0" + +[[deps.Git]] +deps = ["Git_LFS_jll", "Git_jll", "JLLWrappers", "OpenSSH_jll"] +git-tree-sha1 = "824a1890086880696fc908fe12a17bcf61738bd8" +registries = "General" +uuid = "d7ba0133-e1db-5d97-8f8c-041e4b3a1eb2" +version = "1.5.0" + +[[deps.Git_LFS_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d310b22511a51569401e975194cc76077bcd3786" +registries = "General" +uuid = "020c3dae-16b3-5ae5-87b3-4cb189e250b2" +version = "3.8.1+0" + +[[deps.Git_jll]] +deps = ["Artifacts", "Expat_jll", "JLLWrappers", "LibCURL_jll", "Libdl", "Libiconv_jll", "OpenSSL_jll", "PCRE2_jll", "Zlib_jll"] +git-tree-sha1 = "3842d761162baf8efce819cdfb5ea070fe44ac40" +registries = "General" +uuid = "f8c6e375-362e-5223-8a59-34ff63f689eb" +version = "2.56.0+0" + +[[deps.Glib_jll]] +deps = ["Artifacts", "GettextRuntime_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Libiconv_jll", "Libmount_jll", "PCRE2_jll", "Zlib_jll"] +git-tree-sha1 = "ea9f1fb37ff10597353b56f3ba0ebd525acef6e0" +registries = "General" +uuid = "7746bdde-850d-59dc-9ae8-88ece973131d" +version = "2.90.1+0" + +[[deps.Graphite2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "69ffb934a5c5b7e086a0b4fee3427db2556fba6e" +registries = "General" +uuid = "3b182d85-2403-5c21-9c21-1e1f0cc25472" +version = "1.3.16+0" + +[[deps.HDF5]] +deps = ["Compat", "HDF5_jll", "Libdl", "MPIPreferences", "Mmap", "Preferences", "Printf", "Random", "Requires", "UUIDs"] +git-tree-sha1 = "26e37af34e8ccb7a8358bd8de1619c7bcb526738" +registries = "General" +uuid = "f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f" +version = "0.17.4" + + [deps.HDF5.extensions] + MPIExt = "MPI" + + [deps.HDF5.weakdeps] + MPI = "da04e1cc-30fd-572f-bb4f-1f8673147195" + +[[deps.HDF5_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LibCURL_jll", "Libdl", "MPIABI_jll", "MPICH_jll", "MPIPreferences", "MPItrampoline_jll", "MicrosoftMPI_jll", "OpenMPI_jll", "OpenSSL_jll", "TOML", "Zlib_jll", "aws_c_s3_jll", "dlfcn_win32_jll", "libaec_jll", "mpif_jll"] +git-tree-sha1 = "58d79d3a61d2fdeda667fead57546ae22a20b27a" +registries = "General" +uuid = "0234f1f7-429e-5d53-9886-15a909be8d59" +version = "2.2.3+0" + +[[deps.HTTP]] +deps = ["Base64", "CodecZlib", "ConcurrentUtilities", "Dates", "ExceptionUnwrapping", "Logging", "LoggingExtras", "MbedTLS", "NetworkOptions", "OpenSSL", "PrecompileTools", "Random", "SimpleBufferStream", "Sockets", "URIs", "UUIDs"] +git-tree-sha1 = "49a7885f0e1c0ecabd51b25f2fd14f26357777e0" +registries = "General" +uuid = "cd3eb016-35fb-5094-929b-558a96fad6f3" +version = "1.11.1" + +[[deps.HarfBuzz_jll]] +deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "Graphite2_jll", "JLLWrappers", "Libdl", "Libffi_jll"] +git-tree-sha1 = "f700c32c1e9e11b576592043f270e6b33868a56f" +registries = "General" +uuid = "2e76f6c2-a576-52d4-95c1-20adfe4de566" +version = "100.15000.0+0" + +[[deps.HashArrayMappedTries]] +git-tree-sha1 = "2eaa69a7cab70a52b9687c8bf950a5a93ec895ae" +registries = "General" +uuid = "076d061b-32b6-4027-95e0-9a2c6f6d7e74" +version = "0.2.0" + +[[deps.HelpPlots]] +git-tree-sha1 = "07d389d81ca31e42d68bd88cfa1e900a63b7d378" +registries = "General" +uuid = "5880b2e8-ad0a-48c9-bacd-30dc9c1357e0" +version = "1.1.0" +weakdeps = ["Plots"] + + [deps.HelpPlots.extensions] + HelpPlotsExt = "Plots" + +[[deps.Hiccup]] +deps = ["MacroTools", "Test"] +git-tree-sha1 = "6187bb2d5fcbb2007c39e7ac53308b0d371124bd" +registries = "General" +uuid = "9fb69e20-1954-56bb-a84f-559cc56a8ff7" +version = "0.2.2" + +[[deps.Hwloc_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "XML2_jll", "Xorg_libpciaccess_jll"] +git-tree-sha1 = "cbbd99d516990d05c02aa132aa077b2bf50ae323" +registries = "General" +uuid = "e33a78d0-f292-5ffc-b300-72abe9b543c8" +version = "2.15.0+0" + +[[deps.IMASdd]] +deps = ["AbstractTrees", "AdaptiveArrayPools", "CoordinateConventions", "DataInterpolations", "Dates", "FastInterpolations", "HDF5", "InteractiveUtils", "JSON", "Memoization", "OrderedCollections", "PrecompileTools", "Preferences", "Printf", "StaticArraysCore", "ThreadSafeDicts", "TimerOutputs"] +git-tree-sha1 = "2284c64e11d8fb6225971bcc367c67bae51923f5" +registries = "General" +uuid = "c5a45a97-b3f9-491c-b9a7-aa88c3bc0067" +version = "8.6.2" + +[[deps.IOCapture]] +deps = ["Logging", "Random"] +git-tree-sha1 = "0ee181ec08df7d7c911901ea38baf16f755114dc" +registries = "General" +uuid = "b5f81e59-6552-4d32-b1f0-c071b021bf89" +version = "1.0.0" + +[[deps.IfElse]] +git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1" +registries = "General" +uuid = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173" +version = "0.1.1" + +[[deps.InlineStrings]] +git-tree-sha1 = "06b65886c7577a3784d616e29f1302c2e36e389d" +registries = "General" +uuid = "842dd82b-1e85-43dc-bf29-5d0ee9dffc48" +version = "1.4.6" + + [deps.InlineStrings.extensions] + ArrowTypesExt = "ArrowTypes" + ParsersExt = "Parsers" + + [deps.InlineStrings.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + Parsers = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" + +[[deps.IntelOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ec1debd61c300961f98064cfb21287613ad7f303" +registries = "General" +uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" +version = "2025.2.0+0" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" +version = "1.11.0" + +[[deps.IntervalArithmetic]] +deps = ["CRlibm", "CoreMath", "MacroTools", "OpenBLASConsistentFPCSR_jll", "Printf", "Random", "RoundingEmulator"] +git-tree-sha1 = "1c531bf0f8a5c60a340926e058fd3f209b5eef5d" +registries = "General" +uuid = "d1acc4aa-44c8-5952-acd4-ba5d80a2a253" +version = "1.0.12" + + [deps.IntervalArithmetic.extensions] + IntervalArithmeticArblibExt = "Arblib" + IntervalArithmeticDiffRulesExt = "DiffRules" + IntervalArithmeticForwardDiffExt = "ForwardDiff" + IntervalArithmeticIntervalSetsExt = "IntervalSets" + IntervalArithmeticIrrationalConstantsExt = "IrrationalConstants" + IntervalArithmeticLinearAlgebraExt = "LinearAlgebra" + IntervalArithmeticMakieExt = "Makie" + IntervalArithmeticRecipesBaseExt = "RecipesBase" + IntervalArithmeticSparseArraysExt = "SparseArrays" + + [deps.IntervalArithmetic.weakdeps] + Arblib = "fb37089c-8514-4489-9461-98f9c8763369" + DiffRules = "b552c78f-8df3-52c6-915a-8e097449b14b" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953" + IrrationalConstants = "92d709cd-6900-40b7-9082-c6be49f344b6" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a" + RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + +[[deps.InverseFunctions]] +git-tree-sha1 = "5cc6ad3e2bfc75a11eed92632ee341d37f4a4536" +registries = "General" +uuid = "3587e190-3f89-42d0-90ee-14403ec27112" +version = "0.1.18" +weakdeps = ["Dates", "Test"] + + [deps.InverseFunctions.extensions] + InverseFunctionsDatesExt = "Dates" + InverseFunctionsTestExt = "Test" + +[[deps.InvertedIndices]] +git-tree-sha1 = "6da3c4316095de0f5ee2ebd875df8721e7e0bdbe" +registries = "General" +uuid = "41ab1584-1d38-5bbf-9106-f11c6c58b48f" +version = "1.3.1" + +[[deps.IrrationalConstants]] +git-tree-sha1 = "d22e8bdb3f03c300a103ff23c0dd5a654c6701de" +registries = "General" +uuid = "92d709cd-6900-40b7-9082-c6be49f344b6" +version = "0.2.7" + +[[deps.IteratorInterfaceExtensions]] +git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" +registries = "General" +uuid = "82899510-4779-5014-852e-03e436cf321d" +version = "1.0.0" + +[[deps.JLD2]] +deps = ["ChunkCodecCore", "ChunkCodecLibZlib", "ChunkCodecLibZstd", "FileIO", "MacroTools", "Mmap", "OrderedCollections", "PrecompileTools", "ScopedValues"] +git-tree-sha1 = "9ce2e7c49ae4a7035b7d60db3a553b1f6c16875d" +registries = "General" +uuid = "033835bb-8acc-5ee8-8aae-3f567f8a3819" +version = "0.6.7" +weakdeps = ["UnPack"] + + [deps.JLD2.extensions] + UnPackExt = "UnPack" + +[[deps.JLFzf]] +deps = ["REPL", "Random", "fzf_jll"] +git-tree-sha1 = "82f7acdc599b65e0f8ccd270ffa1467c21cb647b" +registries = "General" +uuid = "1019f520-868f-41f5-a6de-eb00f4b6a39c" +version = "0.1.11" + +[[deps.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "7204148362dafe5fe6a273f855b8ccbe4df8173e" +registries = "General" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.8.0" + +[[deps.JSExpr]] +deps = ["JSON", "MacroTools", "Observables", "WebIO"] +git-tree-sha1 = "b413a73785b98474d8af24fd4c8a975e31df3658" +registries = "General" +uuid = "97c1335a-c9c5-57fe-bc5d-ec35cebe8660" +version = "0.5.4" + +[[deps.JSON]] +deps = ["Dates", "Mmap", "Parsers", "Unicode"] +git-tree-sha1 = "31e996f0a15c7b280ba9f76636b3ff9e2ae58c9a" +registries = "General" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "0.21.4" + +[[deps.Jieko]] +deps = ["ExproniconLite"] +git-tree-sha1 = "2f05ed29618da60c06a87e9c033982d4f71d0b6c" +registries = "General" +uuid = "ae98c720-c025-4a4a-838c-29b094483192" +version = "0.2.1" + +[[deps.JpegTurbo_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "037babc10853eeb8e585418922246cb97b8e5b74" +registries = "General" +uuid = "aacddb02-875f-59d6-b918-886e6ef4fbf8" +version = "3.2.0+1" + +[[deps.JuliaSyntaxHighlighting]] +deps = ["StyledStrings"] +uuid = "ac6e5ff7-fb65-4e79-a425-ec3bc9c03011" +version = "1.12.0" + +[[deps.Kaleido_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "43032da5832754f58d14a91ffbe86d5f176acda9" +registries = "General" +uuid = "f7e6163d-2fa5-5f23-b69c-1db539e41963" +version = "0.2.1+0" + +[[deps.Krylov]] +deps = ["LinearAlgebra", "Printf", "SparseArrays"] +git-tree-sha1 = "b13076e4fff6ea0d0a5ddd9b939a11ca2027755a" +registries = "General" +uuid = "ba0b0d4f-ebba-5204-a429-3ac8c609bfb7" +version = "0.10.12" + +[[deps.LAME_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "059aabebaa7c82ccb853dd4a0ee9d17796f7e1bc" +registries = "General" +uuid = "c1c5ebd0-6772-5130-a774-d5fcae4a789d" +version = "3.100.3+0" + +[[deps.LERC_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "39bca05343661c347aae0bca57a5994a0bf4f08d" +registries = "General" +uuid = "88015f11-f218-50d7-93a8-a6af411a945d" +version = "4.2.0+0" + +[[deps.LLVMOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e5b100780d4d30d63b4618d7930d48af409c1772" +registries = "General" +uuid = "1d63c593-3942-5779-bab2-d838dc0a180e" +version = "23.1.1+0" + +[[deps.LaTeXStrings]] +git-tree-sha1 = "f88f3ccef05a6a72a0cf0ed417c8fd68530f4ab2" +registries = "General" +uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" +version = "1.4.1" + +[[deps.Latexify]] +deps = ["Format", "Ghostscript_jll", "InteractiveUtils", "LaTeXStrings", "MacroTools", "Markdown", "OrderedCollections", "Requires"] +git-tree-sha1 = "df7566479bd64f20bd16b09960145e70160ffb3b" +registries = "General" +uuid = "23fbe1c1-3f47-55db-b15f-69d7ec21a316" +version = "0.16.12" + + [deps.Latexify.extensions] + DataFramesExt = "DataFrames" + SparseArraysExt = "SparseArrays" + SymEngineExt = "SymEngine" + TectonicExt = "tectonic_jll" + + [deps.Latexify.weakdeps] + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + SymEngine = "123dc426-2d89-5057-bbad-38513e3affd8" + tectonic_jll = "d7dd28d6-a5e6-559c-9131-7eb760cdacc5" + +[[deps.LayoutPointers]] +deps = ["ArrayInterface", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface"] +git-tree-sha1 = "a9eaadb366f5493a5654e843864c13d8b107548c" +registries = "General" +uuid = "10f19ff3-798f-405d-979b-55457f8fc047" +version = "0.1.17" + +[[deps.LazilyInitializedFields]] +git-tree-sha1 = "0f2da712350b020bc3957f269c9caad516383ee0" +registries = "General" +uuid = "0e77f7df-68c5-4e49-93ce-4cd80f5598bf" +version = "1.3.0" + +[[deps.Lazy]] +deps = ["MacroTools"] +git-tree-sha1 = "1370f8202dac30758f3c345f9909b97f53d87d3f" +registries = "General" +uuid = "50d2b5c4-7a5e-59d5-8109-a42b560f39c0" +version = "0.15.1" + +[[deps.LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" +version = "1.11.0" + +[[deps.LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" +version = "1.0.0" + +[[deps.LibCURL_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "Zlib_jll", "Zstd_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "8.22.0+0" + +[[deps.LibGit2]] +deps = ["LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" +version = "1.11.0" + +[[deps.LibGit2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "PCRE2_jll", "Zlib_jll"] +uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" +version = "1.9.7+0" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl", "OpenSSL_jll", "Zlib_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.11.104+0" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" +version = "1.11.0" + +[[deps.Libffi_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "c8da7e6a91781c41a863611c7e966098d783c57a" +registries = "General" +uuid = "e9f186c6-92d2-5b65-8a66-fee21dc1b490" +version = "3.4.7+0" + +[[deps.Libglvnd_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll", "Xorg_libXext_jll"] +git-tree-sha1 = "d36c21b9e7c172a44a10484125024495e2625ac0" +registries = "General" +uuid = "7e76a0d4-f3c7-5321-8279-8d96eeed0f29" +version = "1.7.1+1" + +[[deps.Libiconv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "be484f5c92fad0bd8acfef35fe017900b0b73809" +registries = "General" +uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" +version = "1.18.0+0" + +[[deps.Libmount_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "b8a91037379e1fd661e9b5ff3d7a770424b1f9f2" +registries = "General" +uuid = "4b2f31a3-9ecc-558c-b454-b3730dcb73e9" +version = "2.42.4+0" + +[[deps.Libtiff_jll]] +deps = ["Artifacts", "JLLWrappers", "JpegTurbo_jll", "LERC_jll", "Libdl", "XZ_jll", "Zlib_jll", "Zstd_jll"] +git-tree-sha1 = "aebd334d06cee9f24cea70bd19a39749daf73881" +registries = "General" +uuid = "89763e89-9b03-5906-acba-b20f662cd828" +version = "4.7.3+0" + +[[deps.Libuuid_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "9e887184f306b28dbfcff88cefbb0ec80f1aa9e0" +registries = "General" +uuid = "38a345b3-de98-5d2b-a5d3-14cd9215e700" +version = "2.42.4+0" + +[[deps.LineSearch]] +deps = ["ADTypes", "CommonSolve", "ConcreteStructs", "FastClosures", "LinearAlgebra", "MaybeInplace", "PrecompileTools", "SciMLBase", "SciMLJacobianOperators", "StaticArraysCore"] +git-tree-sha1 = "2e05027f5a68891d997fcad60d11ce48d09208d0" +registries = "General" +uuid = "87fe0de2-c867-4266-b59a-2f0a94fc965b" +version = "0.1.14" +weakdeps = ["LineSearches"] + + [deps.LineSearch.extensions] + LineSearchLineSearchesExt = "LineSearches" + +[[deps.LineSearches]] +deps = ["LinearAlgebra", "NLSolversBase", "NaNMath", "Printf"] +git-tree-sha1 = "a09a85e94e681def2446752cddaf9401a4d82b6d" +registries = "General" +uuid = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" +version = "7.8.2" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +version = "1.13.0" + +[[deps.LinearSolve]] +deps = ["AMD", "ArrayInterface", "ConcreteStructs", "DocStringExtensions", "EnumX", "GPUArraysCore", "InteractiveUtils", "Krylov", "Libdl", "LinearAlgebra", "MKL_jll", "Markdown", "OpenBLAS_jll", "PrecompileTools", "Preferences", "PureKLU", "RecursiveArrayTools", "Reexport", "SciMLBase", "SciMLLogging", "SciMLOperators", "Setfield", "SparseArrays", "SparseColumnPivotedQR", "StaticArraysCore"] +git-tree-sha1 = "ec49ed72f6024be2f9833fe630fbd72f6048f8ad" +registries = "General" +uuid = "7ed4a6bd-45f5-4d41-b270-4a48e9bafcae" +version = "3.87.0" + + [deps.LinearSolve.extensions] + LinearSolveAMDGPUExt = "AMDGPU" + LinearSolveAlgebraicMultigridExt = "AlgebraicMultigrid" + LinearSolveBLISExt = ["blis_jll", "LAPACK_jll"] + LinearSolveBandedMatricesExt = "BandedMatrices" + LinearSolveBlockDiagonalsExt = "BlockDiagonals" + LinearSolveCUDAExt = ["cuSOLVER"] + LinearSolveCUDSSExt = "CUDSS" + LinearSolveCUSOLVERRFExt = ["CUSOLVERRF", "SparseArrays"] + LinearSolveChainRulesCoreExt = "ChainRulesCore" + LinearSolveCliqueTreesExt = ["CliqueTrees", "SparseArrays"] + LinearSolveElementalExt = "Elemental" + LinearSolveEnzymeExt = ["EnzymeCore", "SparseArrays"] + LinearSolveFastAlmostBandedMatricesExt = "FastAlmostBandedMatrices" + LinearSolveFastLapackInterfaceExt = "FastLapackInterface" + LinearSolveForwardDiffExt = "ForwardDiff" + LinearSolveGinkgoExt = ["Ginkgo", "SparseArrays"] + LinearSolveHSLExt = ["HSL", "SparseArrays"] + LinearSolveHYPREExt = "HYPRE" + LinearSolveIterativeSolversExt = "IterativeSolvers" + LinearSolveKernelAbstractionsExt = "KernelAbstractions" + LinearSolveKrylovKitExt = "KrylovKit" + LinearSolveMUMPSExt = ["MUMPS", "SparseArrays"] + LinearSolveMetalExt = "Metal" + LinearSolveMooncakeExt = "Mooncake" + LinearSolvePETScExt = ["PETSc", "SparseArrays", "SparseMatricesCSR"] + LinearSolvePETScMPIExt = ["PETSc", "PartitionedArrays", "SparseArrays", "SparseMatricesCSR"] + LinearSolveParUExt = ["ParU_jll", "SparseArrays"] + LinearSolvePardisoExt = ["Pardiso", "SparseArrays"] + LinearSolvePartitionedSolversExt = ["PartitionedArrays", "PartitionedSolvers"] + LinearSolvePureUMFPACKExt = ["PureUMFPACK", "SparseArrays"] + LinearSolveRecursiveFactorizationExt = "RecursiveFactorization" + LinearSolveSTRUMPACKExt = ["SparseArrays", "STRUMPACK_jll"] + LinearSolveSparseArraysExt = "SparseArrays" + LinearSolveSparspakExt = ["SparseArrays", "Sparspak"] + LinearSolveSpecializingFactorizationsExt = "SpecializingFactorizations" + LinearSolveSuperLUDISTExt = ["SparseArrays", "SuperLUDIST"] + + [deps.LinearSolve.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + AlgebraicMultigrid = "2169fc97-5a83-5252-b627-83903c6c433c" + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockDiagonals = "0a1fb500-61f7-11e9-3c65-f5ef3456f9f0" + CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" + CUSOLVERRF = "a8cc9031-bad2-4722-94f5-40deabb4245c" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + CliqueTrees = "60701a23-6482-424a-84db-faee86b9b1f8" + Elemental = "902c3f28-d1ec-5e7e-8399-a24c3845ee38" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + FastAlmostBandedMatrices = "9d29842c-ecb8-4973-b1e9-a27b1157504e" + FastLapackInterface = "29a986be-02c6-4525-aec4-84b980013641" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + Ginkgo = "4c8bd3c9-ead9-4b5e-a625-08f1338ba0ec" + HSL = "34c5aeac-e683-54a6-a0e9-6e0fdc586c50" + HYPRE = "b5ffcf37-a2bd-41ab-a3da-4bd9bc8ad771" + IterativeSolvers = "42fd0dbc-a981-5370-80f2-aaf504508153" + KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" + KrylovKit = "0b1a1467-8014-51b9-945f-bf0ae24f4b77" + LAPACK_jll = "51474c39-65e3-53ba-86ba-03b1b862ec14" + MUMPS = "55d2b088-9f4e-11e9-26c0-150b02ea6a46" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + PETSc = "ace2c81b-2b5f-4b1e-a30d-d662738edfe0" + ParU_jll = "9e0b026c-e8ce-559c-a2c4-6a3d5c955bc9" + Pardiso = "46dd5b70-b6fb-5a00-ae2d-e8fea33afaf2" + PartitionedArrays = "5a9dfac6-5c52-46f7-8278-5e2210713be9" + PartitionedSolvers = "11b65f7f-80ac-401b-9ef2-3db765482d62" + PureUMFPACK = "b7e1f0a2-3c4d-4e5f-9a0b-1c2d3e4f5a6b" + RecursiveFactorization = "f2c3362d-daeb-58d1-803e-2bc74f2840b4" + STRUMPACK_jll = "86fbd0b9-476f-557c-b766-62c724b42d8c" + SparseMatricesCSR = "a0a7dd2c-ebf4-11e9-1f05-cf50bc540ca1" + Sparspak = "e56a9233-b9d6-4f03-8d0f-1825330902ac" + SpecializingFactorizations = "fa08b7a1-13d3-4faf-875d-5cbc1520e3f3" + SuperLUDIST = "4cd002a6-0da4-410d-a012-232df062f478" + blis_jll = "6136c539-28a5-5bf0-87cc-b183200dce32" + cuSOLVER = "887afef0-6a32-4de5-add4-7827692ba8fc" + +[[deps.LogExpFunctions]] +deps = ["DocStringExtensions", "IrrationalConstants", "LinearAlgebra"] +git-tree-sha1 = "28d620bcdb37a3fb02de9f521928ee453690f414" +registries = "General" +uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688" +version = "1.0.3" + + [deps.LogExpFunctions.extensions] + LogExpFunctionsChainRulesCoreExt = "ChainRulesCore" + LogExpFunctionsChangesOfVariablesExt = "ChangesOfVariables" + LogExpFunctionsInverseFunctionsExt = "InverseFunctions" + + [deps.LogExpFunctions.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ChangesOfVariables = "9e997f8a-9a97-42d5-a9f1-ce6bfc15e2c0" + InverseFunctions = "3587e190-3f89-42d0-90ee-14403ec27112" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" +version = "1.11.0" + +[[deps.LoggingExtras]] +deps = ["Dates", "Logging"] +git-tree-sha1 = "f00544d95982ea270145636c181ceda21c4e2575" +registries = "General" +uuid = "e6f89c97-d47a-5376-807f-9c37f3926c36" +version = "1.2.0" + +[[deps.MKL_jll]] +deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "oneTBB_jll"] +git-tree-sha1 = "282cadc186e7b2ae0eeadbd7a4dffed4196ae2aa" +registries = "General" +uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" +version = "2025.2.0+0" + +[[deps.MPIABI_jll]] +deps = ["Artifacts", "Hwloc_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "MPIPreferences", "TOML"] +git-tree-sha1 = "42e2cada9f35500b4d227106ce2b60e85d9f15bc" +registries = "General" +uuid = "b5ada748-db0f-5fc0-8972-9331c762740c" +version = "1.0.1+0" + +[[deps.MPICH_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Hwloc_jll", "JLLWrappers", "Libdl", "MPIPreferences", "TOML"] +git-tree-sha1 = "08cb47f95a2f1b795e43a9e4f9783e68ecdc1ca6" +registries = "General" +uuid = "7cb0a576-ebde-5e09-9194-50597f1243b4" +version = "5.0.3+0" + +[[deps.MPIPreferences]] +deps = ["Libdl", "Preferences"] +git-tree-sha1 = "8e98d5d80b87403c311fd51e8455d4546ba7a5f8" +registries = "General" +uuid = "3da0fdf6-3ccc-4f1b-acd9-58baa6c99267" +version = "0.1.12" + +[[deps.MPItrampoline_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "MPIPreferences", "TOML"] +git-tree-sha1 = "09a99227205419c00e734f413ee98c18bc1b02e4" +registries = "General" +uuid = "f1f71cc9-e9ae-5b93-9b94-4fe0e1ad3748" +version = "5.5.7+0" + +[[deps.MacroTools]] +git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" +registries = "General" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.16" + +[[deps.ManualMemory]] +git-tree-sha1 = "bcaef4fc7a0cfe2cba636d84cda54b5e4e4ca3cd" +registries = "General" +uuid = "d125e4d3-2237-4719-b19c-fa641b8a4667" +version = "0.1.8" + +[[deps.Markdown]] +deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" +version = "1.11.0" + +[[deps.MarkdownAST]] +deps = ["AbstractTrees", "Markdown"] +git-tree-sha1 = "93c718d892e73931841089cdc0e982d6dd9cc87b" +registries = "General" +uuid = "d0879d2d-cac2-40c8-9cee-1863dc0c7391" +version = "0.1.3" + +[[deps.MatrixFactorizations]] +deps = ["ArrayLayouts", "LinearAlgebra", "Printf", "Random"] +git-tree-sha1 = "076d0f90b1b06e17609cabb48bd2cbef28e7fc77" +registries = "General" +uuid = "a3b82374-2e81-5b9e-98ce-41277c0e4c87" +version = "3.2.0" + + [deps.MatrixFactorizations.extensions] + MatrixFactorizationsBandedMatricesExt = "BandedMatrices" + + [deps.MatrixFactorizations.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + +[[deps.MaybeInplace]] +deps = ["ArrayInterface", "LinearAlgebra", "MacroTools", "PrecompileTools"] +git-tree-sha1 = "f2cde0ae772162f20287b803e623966d0d94dea9" +registries = "General" +uuid = "bb5d69b7-63fc-4a16-80bd-7e42200c7bdb" +version = "0.1.8" +weakdeps = ["SparseArrays"] + + [deps.MaybeInplace.extensions] + MaybeInplaceSparseArraysExt = "SparseArrays" + +[[deps.MbedTLS]] +deps = ["Dates", "MbedTLS_jll", "MozillaCACerts_jll", "NetworkOptions", "Random", "Sockets"] +git-tree-sha1 = "0e4b139a1f0f0b8c054fcdfd3be5f610cfb8c787" +registries = "General" +uuid = "739be429-bea8-5141-9913-cc70e7f3736d" +version = "1.2.0" + +[[deps.MbedTLS_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "ff69a2b1330bcb730b9ac1ab7dd680176f5896b8" +registries = "General" +uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1" +version = "2.28.1010+0" + +[[deps.Measures]] +git-tree-sha1 = "b513cedd20d9c914783d8ad83d08120702bf2c77" +registries = "General" +uuid = "442fdcdd-2543-5da2-b0f3-8c86c306513e" +version = "0.3.3" + +[[deps.Memoization]] +deps = ["MacroTools"] +git-tree-sha1 = "7dbf904fa6c4447bd1f1d316886bfbe29feacf45" +registries = "General" +uuid = "6fafb56a-5788-4b4e-91ca-c0cea6611c73" +version = "0.2.2" + +[[deps.MicrosoftMPI_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "bc95bf4149bf535c09602e3acdf950d9b4376227" +registries = "General" +uuid = "9237b28f-5490-5468-be7b-bb81f5f5e6cf" +version = "10.1.4+3" + +[[deps.Missings]] +deps = ["DataAPI"] +git-tree-sha1 = "ec4f7fbeab05d7747bdf98eb74d130a2a2ed298d" +registries = "General" +uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28" +version = "1.2.0" + +[[deps.Mmap]] +uuid = "a63ad114-7e13-5084-954f-fe012c677804" +version = "1.11.0" + +[[deps.Moshi]] +deps = ["ExproniconLite", "Jieko"] +git-tree-sha1 = "3f234cf937eb1d58f613440ecb022da784ad34d4" +registries = "General" +uuid = "2e0e35c7-a2e4-4343-998d-7ef72827ed2d" +version = "0.3.13" + +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2026.10.20" + +[[deps.MuladdMacro]] +deps = ["PrecompileTools"] +git-tree-sha1 = "283bf85d4a767481dd924dff0eee1735e95f449e" +registries = "General" +uuid = "46d2c3a1-f734-5fdb-9937-b9b9aeba4221" +version = "0.2.7" + +[[deps.Mustache]] +deps = ["DataFrames", "Printf", "Tables"] +git-tree-sha1 = "7437c911e62f50e7a043a774ebdc0dbd780d9fe5" +registries = "General" +uuid = "ffc61752-8dc7-55ee-8c37-f3e9cdd09e70" +version = "1.1.0" + +[[deps.Mux]] +deps = ["AssetRegistry", "Base64", "HTTP", "Hiccup", "MbedTLS", "Pkg", "Sockets"] +git-tree-sha1 = "7295d849103ac4fcbe3b2e439f229c5cc77b9b69" +registries = "General" +uuid = "a975b10e-0019-58db-a62f-e48ff68538c9" +version = "1.0.2" + +[[deps.NLSolversBase]] +deps = ["ADTypes", "DifferentiationInterface", "FiniteDiff", "LinearAlgebra"] +git-tree-sha1 = "f96d38936d92d610318dec4d3b5ef37b0373c20f" +registries = "General" +uuid = "d41bc354-129a-5804-8e4c-c37616107c6c" +version = "8.0.1" + +[[deps.NaNMath]] +deps = ["OpenLibm_jll"] +git-tree-sha1 = "676c0f1c1c34224d6869675047a54b42fdc7b8c5" +registries = "General" +uuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3" +version = "1.1.5" + +[[deps.NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.3.0" + +[[deps.NonlinearSolve]] +deps = ["ADTypes", "ArrayInterface", "BracketingNonlinearSolve", "CommonSolve", "ConcreteStructs", "DifferentiationInterface", "FastClosures", "FiniteDiff", "ForwardDiff", "LineSearch", "LinearAlgebra", "LinearSolve", "NonlinearSolveBase", "NonlinearSolveFirstOrder", "NonlinearSolveQuasiNewton", "NonlinearSolveSpectralMethods", "PrecompileTools", "Preferences", "Reexport", "SciMLBase", "Setfield", "SimpleNonlinearSolve", "StaticArraysCore", "SymbolicIndexingInterface"] +git-tree-sha1 = "a6c5719bbb42985c72f4cacbfa49e86bab850d66" +registries = "General" +uuid = "8913a72c-1f9b-4ce2-8d82-65094dcecaec" +version = "4.19.1" + + [deps.NonlinearSolve.extensions] + NonlinearSolveFastLevenbergMarquardtExt = "FastLevenbergMarquardt" + NonlinearSolveFixedPointAccelerationExt = "FixedPointAcceleration" + NonlinearSolveLeastSquaresOptimExt = "LeastSquaresOptim" + NonlinearSolveMINPACKExt = "MINPACK" + NonlinearSolveNLSolversExt = "NLSolvers" + NonlinearSolveNLsolveExt = ["NLsolve", "LineSearches"] + NonlinearSolvePETScExt = ["PETSc", "MPI", "SparseArrays"] + NonlinearSolveSIAMFANLEquationsExt = "SIAMFANLEquations" + NonlinearSolveSpeedMappingExt = "SpeedMapping" + NonlinearSolveSundialsExt = "Sundials" + + [deps.NonlinearSolve.weakdeps] + FastLevenbergMarquardt = "7a0df574-e128-4d35-8cbd-3d84502bf7ce" + FixedPointAcceleration = "817d07cb-a79a-5c30-9a31-890123675176" + LeastSquaresOptim = "0fc2ff8b-aaa3-5acd-a817-1944a5e08891" + LineSearches = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" + MINPACK = "4854310b-de5a-5eb6-a2a5-c1dee2bd17f9" + MPI = "da04e1cc-30fd-572f-bb4f-1f8673147195" + NLSolvers = "337daf1e-9722-11e9-073e-8b9effe078ba" + NLsolve = "2774e3e8-f4cf-5e23-947b-6d7e65073b56" + PETSc = "ace2c81b-2b5f-4b1e-a30d-d662738edfe0" + SIAMFANLEquations = "084e46ad-d928-497d-ad5e-07fa361a48c4" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + SpeedMapping = "f1835b91-879b-4a3f-a438-e4baacf14412" + Sundials = "c3572dad-4567-51f8-b174-8c6c989267f4" + +[[deps.NonlinearSolveBase]] +deps = ["ADTypes", "Adapt", "ArrayInterface", "CommonSolve", "Compat", "ConcreteStructs", "DifferentiationInterface", "EnzymeCore", "FastClosures", "FunctionWrappers", "FunctionWrappersWrappers", "LinearAlgebra", "LogExpFunctions", "Markdown", "MaybeInplace", "PreallocationTools", "PrecompileTools", "Preferences", "Printf", "RecursiveArrayTools", "SciMLBase", "SciMLJacobianOperators", "SciMLLogging", "SciMLOperators", "SciMLStructures", "Setfield", "StaticArraysCore", "SymbolicIndexingInterface", "TimerOutputs"] +git-tree-sha1 = "cb824030a0d5769555704db95ee3cbe0f76ed53d" +registries = "General" +uuid = "be0214bd-f91f-a760-ac4e-3421ce2b2da0" +version = "2.30.3" + + [deps.NonlinearSolveBase.extensions] + NonlinearSolveBaseBandedMatricesExt = "BandedMatrices" + NonlinearSolveBaseChainRulesCoreExt = "ChainRulesCore" + NonlinearSolveBaseEnzymeExt = ["ChainRulesCore", "Enzyme"] + NonlinearSolveBaseForwardDiffExt = "ForwardDiff" + NonlinearSolveBaseLineSearchExt = "LineSearch" + NonlinearSolveBaseLinearSolveExt = "LinearSolve" + NonlinearSolveBaseMooncakeExt = "Mooncake" + NonlinearSolveBaseReverseDiffExt = "ReverseDiff" + NonlinearSolveBaseSparseArraysExt = "SparseArrays" + NonlinearSolveBaseSparseMatrixColoringsExt = "SparseMatrixColorings" + NonlinearSolveBaseTrackerExt = "Tracker" + + [deps.NonlinearSolveBase.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + LineSearch = "87fe0de2-c867-4266-b59a-2f0a94fc965b" + LinearSolve = "7ed4a6bd-45f5-4d41-b270-4a48e9bafcae" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + SparseMatrixColorings = "0a514795-09f3-496d-8182-132a7b665d35" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.NonlinearSolveFirstOrder]] +deps = ["ADTypes", "ArrayInterface", "CommonSolve", "ConcreteStructs", "FiniteDiff", "ForwardDiff", "LineSearch", "LinearAlgebra", "LinearSolve", "MaybeInplace", "NonlinearSolveBase", "PrecompileTools", "Reexport", "SciMLBase", "SciMLJacobianOperators", "Setfield", "StaticArraysCore"] +git-tree-sha1 = "ce68820a4f421fb5bee7ec4dcf875aff33886bfb" +registries = "General" +uuid = "5959db7a-ea39-4486-b5fe-2dd0bf03d60d" +version = "2.1.1" + +[[deps.NonlinearSolveQuasiNewton]] +deps = ["ArrayInterface", "CommonSolve", "ConcreteStructs", "LinearAlgebra", "LinearSolve", "MaybeInplace", "NonlinearSolveBase", "PrecompileTools", "Reexport", "SciMLBase", "SciMLOperators", "StaticArraysCore"] +git-tree-sha1 = "538432ca1aea8bf63db02929bf870501f8a7c64c" +registries = "General" +uuid = "9a2c21bd-3a47-402d-9113-8faf9a0ee114" +version = "1.13.1" +weakdeps = ["ForwardDiff"] + + [deps.NonlinearSolveQuasiNewton.extensions] + NonlinearSolveQuasiNewtonForwardDiffExt = "ForwardDiff" + +[[deps.NonlinearSolveSpectralMethods]] +deps = ["CommonSolve", "ConcreteStructs", "LineSearch", "MaybeInplace", "NonlinearSolveBase", "PrecompileTools", "Reexport", "SciMLBase"] +git-tree-sha1 = "a3781e12becdf0ce5520bd97ec617e879bf4e9f2" +registries = "General" +uuid = "26075421-4e9a-44e1-8bd1-420ed7ad02b2" +version = "1.7.1" +weakdeps = ["ForwardDiff"] + + [deps.NonlinearSolveSpectralMethods.extensions] + NonlinearSolveSpectralMethodsForwardDiffExt = "ForwardDiff" + +[[deps.Observables]] +git-tree-sha1 = "7438a59546cf62428fc9d1bc94729146d37a7225" +registries = "General" +uuid = "510215fc-4207-5dde-b226-833fc4488ee2" +version = "0.5.5" + +[[deps.Ogg_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "b6aa4566bb7ae78498a5e68943863fa8b5231b59" +registries = "General" +uuid = "e7412a2a-1a6e-54c0-be00-318e2571c051" +version = "1.3.6+0" + +[[deps.OpenBLASConsistentFPCSR_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl"] +git-tree-sha1 = "38a93f17e431141c6470bb67a88952a7c4f0e928" +registries = "General" +uuid = "6cdc7f73-28fd-5e50-80fb-958a8875b1af" +version = "0.3.34+0" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.30+0" + +[[deps.OpenLibm_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "05823500-19ac-5b8b-9628-191a04bc5112" +version = "0.8.7+0" + +[[deps.OpenMPI_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Hwloc_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "MPIPreferences", "TOML", "Zlib_jll"] +git-tree-sha1 = "0dba69ef957d790d41484ca7c20212c5ac806738" +registries = "General" +uuid = "fe0851c0-eecd-5654-98d4-656369965a5c" +version = "5.0.14+0" + +[[deps.OpenSSH_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "OpenSSL_jll", "Zlib_jll"] +git-tree-sha1 = "1f640b82a627df3dbbaaff756a201a9ceb10dd1f" +registries = "General" +uuid = "9bd350c2-7e96-507f-8002-3f2e150b4e1b" +version = "10.6.1+0" + +[[deps.OpenSSL]] +deps = ["BitFlags", "Dates", "MozillaCACerts_jll", "NetworkOptions", "OpenSSL_jll", "Sockets"] +git-tree-sha1 = "f1cffefcdc73bbf17875e7c1cb062ecb000c1552" +registries = "General" +uuid = "4d8831e6-92b7-49fb-bdf8-b643e874388c" +version = "1.7.1" + +[[deps.OpenSSL_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" +version = "3.5.8+0" + +[[deps.OpenSpecFun_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1346c9208249809840c91b26703912dff463d335" +registries = "General" +uuid = "efe28fd5-8261-553b-a9e1-b2916fc3738e" +version = "0.5.6+0" + +[[deps.Opus_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e2bb57a313a74b8104064b7efd01406c0a50d2ff" +registries = "General" +uuid = "91d4177d-7536-5919-b921-800302f37372" +version = "1.6.1+0" + +[[deps.OrderedCollections]] +git-tree-sha1 = "94ba93778373a53bfd5a0caaf7d809c445292ff4" +registries = "General" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "1.8.2" + +[[deps.OrdinaryDiffEq]] +deps = ["ADTypes", "Adapt", "ArrayInterface", "CommonSolve", "DataStructures", "DiffEqBase", "DocStringExtensions", "EnumX", "ExponentialUtilities", "FastBroadcast", "FastClosures", "FillArrays", "FiniteDiff", "ForwardDiff", "FunctionWrappersWrappers", "InteractiveUtils", "LineSearches", "LinearAlgebra", "LinearSolve", "Logging", "MacroTools", "MuladdMacro", "NonlinearSolve", "OrdinaryDiffEqAdamsBashforthMoulton", "OrdinaryDiffEqBDF", "OrdinaryDiffEqCore", "OrdinaryDiffEqDefault", "OrdinaryDiffEqDifferentiation", "OrdinaryDiffEqExplicitRK", "OrdinaryDiffEqExponentialRK", "OrdinaryDiffEqExtrapolation", "OrdinaryDiffEqFIRK", "OrdinaryDiffEqFeagin", "OrdinaryDiffEqFunctionMap", "OrdinaryDiffEqHighOrderRK", "OrdinaryDiffEqIMEXMultistep", "OrdinaryDiffEqLinear", "OrdinaryDiffEqLowOrderRK", "OrdinaryDiffEqLowStorageRK", "OrdinaryDiffEqNonlinearSolve", "OrdinaryDiffEqNordsieck", "OrdinaryDiffEqPDIRK", "OrdinaryDiffEqPRK", "OrdinaryDiffEqQPRK", "OrdinaryDiffEqRKN", "OrdinaryDiffEqRosenbrock", "OrdinaryDiffEqSDIRK", "OrdinaryDiffEqSSPRK", "OrdinaryDiffEqStabilizedIRK", "OrdinaryDiffEqStabilizedRK", "OrdinaryDiffEqSymplecticRK", "OrdinaryDiffEqTsit5", "OrdinaryDiffEqVerner", "Polyester", "PreallocationTools", "PrecompileTools", "Preferences", "RecursiveArrayTools", "Reexport", "SciMLBase", "SciMLOperators", "SciMLStructures", "SimpleNonlinearSolve", "SparseArrays", "Static", "StaticArrayInterface", "StaticArrays", "TruncatedStacktraces"] +git-tree-sha1 = "47271adac597af08263b6ea2669e93040b45c4d0" +registries = "General" +uuid = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed" +version = "6.111.0" + +[[deps.OrdinaryDiffEqAdamsBashforthMoulton]] +deps = ["DiffEqBase", "FastBroadcast", "MuladdMacro", "OrdinaryDiffEqCore", "OrdinaryDiffEqLowOrderRK", "Polyester", "RecursiveArrayTools", "Reexport", "SciMLBase", "Static"] +git-tree-sha1 = "2e44acb684dfcdc2e41851a988733e30b28a8478" +registries = "General" +uuid = "89bda076-bce5-4f1c-845f-551c83cdda9a" +version = "1.11.0" + +[[deps.OrdinaryDiffEqBDF]] +deps = ["ADTypes", "ArrayInterface", "DiffEqBase", "FastBroadcast", "LinearAlgebra", "MacroTools", "MuladdMacro", "OrdinaryDiffEqCore", "OrdinaryDiffEqDifferentiation", "OrdinaryDiffEqNonlinearSolve", "OrdinaryDiffEqSDIRK", "PrecompileTools", "Preferences", "RecursiveArrayTools", "Reexport", "SciMLBase", "TruncatedStacktraces"] +git-tree-sha1 = "d7f69947e070a6a89aaf583e8aa2fada199fc292" +registries = "General" +uuid = "6ad6398a-0878-4a85-9266-38940aa047c8" +version = "1.26.0" + +[[deps.OrdinaryDiffEqCore]] +deps = ["ADTypes", "Accessors", "Adapt", "ArrayInterface", "ConcreteStructs", "DataStructures", "DiffEqBase", "DocStringExtensions", "EnumX", "EnzymeCore", "FastBroadcast", "FastClosures", "FastPower", "FunctionWrappersWrappers", "InteractiveUtils", "LinearAlgebra", "Logging", "MacroTools", "MuladdMacro", "Polyester", "PrecompileTools", "Preferences", "Random", "RecursiveArrayTools", "Reexport", "SciMLBase", "SciMLLogging", "SciMLOperators", "SciMLStructures", "Static", "SymbolicIndexingInterface", "TruncatedStacktraces"] +git-tree-sha1 = "c0a22f012d3e98fd78afafe8e5152ace7a2276bc" +registries = "General" +uuid = "bbf590c4-e513-4bbe-9b18-05decba2e5d8" +version = "3.33.1" + + [deps.OrdinaryDiffEqCore.extensions] + OrdinaryDiffEqCoreMooncakeExt = "Mooncake" + OrdinaryDiffEqCoreSparseArraysExt = "SparseArrays" + + [deps.OrdinaryDiffEqCore.weakdeps] + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + +[[deps.OrdinaryDiffEqDefault]] +deps = ["ADTypes", "DiffEqBase", "EnumX", "LinearAlgebra", "LinearSolve", "OrdinaryDiffEqBDF", "OrdinaryDiffEqCore", "OrdinaryDiffEqRosenbrock", "OrdinaryDiffEqTsit5", "OrdinaryDiffEqVerner", "PrecompileTools", "Preferences", "Reexport", "SciMLBase"] +git-tree-sha1 = "5fbd116f93790ce79c4beff8206e1b8e45c492a2" +registries = "General" +uuid = "50262376-6c5a-4cf5-baba-aaf4f84d72d7" +version = "1.14.0" + +[[deps.OrdinaryDiffEqDifferentiation]] +deps = ["ADTypes", "ArrayInterface", "ConcreteStructs", "ConstructionBase", "DiffEqBase", "DifferentiationInterface", "FastBroadcast", "FiniteDiff", "ForwardDiff", "FunctionWrappersWrappers", "LinearAlgebra", "LinearSolve", "OrdinaryDiffEqCore", "SciMLBase", "SciMLOperators", "SparseMatrixColorings", "StaticArraysCore"] +git-tree-sha1 = "f3976b6baeb64051f41ed461a1933b7501a4f38e" +registries = "General" +uuid = "4302a76b-040a-498a-8c04-15b101fed76b" +version = "2.9.0" +weakdeps = ["SparseArrays"] + + [deps.OrdinaryDiffEqDifferentiation.extensions] + OrdinaryDiffEqDifferentiationSparseArraysExt = "SparseArrays" + +[[deps.OrdinaryDiffEqExplicitRK]] +deps = ["DiffEqBase", "FastBroadcast", "LinearAlgebra", "MuladdMacro", "OrdinaryDiffEqCore", "RecursiveArrayTools", "Reexport", "SciMLBase", "TruncatedStacktraces"] +git-tree-sha1 = "54346c3d7a9932ab11743a99afed8a3ff0a65fea" +registries = "General" +uuid = "9286f039-9fbf-40e8-bf65-aa933bdc4db0" +version = "1.12.0" + +[[deps.OrdinaryDiffEqExponentialRK]] +deps = ["ADTypes", "DiffEqBase", "ExponentialUtilities", "FastBroadcast", "LinearAlgebra", "MuladdMacro", "OrdinaryDiffEqCore", "OrdinaryDiffEqDifferentiation", "RecursiveArrayTools", "Reexport", "SciMLBase"] +git-tree-sha1 = "32fb54c8000c82fd32c55f7bf52f4651a3bd0e61" +registries = "General" +uuid = "e0540318-69ee-4070-8777-9e2de6de23de" +version = "1.15.0" + +[[deps.OrdinaryDiffEqExtrapolation]] +deps = ["ADTypes", "DiffEqBase", "FastBroadcast", "FastPower", "LinearSolve", "MuladdMacro", "OrdinaryDiffEqCore", "OrdinaryDiffEqDifferentiation", "Polyester", "RecursiveArrayTools", "Reexport", "SciMLBase"] +git-tree-sha1 = "57bf89f5b144f6e5af1146fb7aee1544c6b76950" +registries = "General" +uuid = "becaefa8-8ca2-5cf9-886d-c06f3d2bd2c4" +version = "1.18.0" + +[[deps.OrdinaryDiffEqFIRK]] +deps = ["ADTypes", "DiffEqBase", "FastBroadcast", "FastGaussQuadrature", "FastPower", "LinearAlgebra", "LinearSolve", "MuladdMacro", "OrdinaryDiffEqCore", "OrdinaryDiffEqDifferentiation", "OrdinaryDiffEqNonlinearSolve", "Polyester", "RecursiveArrayTools", "Reexport", "SciMLBase", "SciMLOperators"] +git-tree-sha1 = "3339f3a26974a37666c74b95bdb54aefc63b9a56" +registries = "General" +uuid = "5960d6e9-dd7a-4743-88e7-cf307b64f125" +version = "1.26.0" + +[[deps.OrdinaryDiffEqFeagin]] +deps = ["DiffEqBase", "FastBroadcast", "MuladdMacro", "OrdinaryDiffEqCore", "Polyester", "RecursiveArrayTools", "Reexport", "SciMLBase", "Static"] +git-tree-sha1 = "302999c99bc454cf274d39b9ba3c2415f6fbb1cb" +registries = "General" +uuid = "101fe9f7-ebb6-4678-b671-3a81e7194747" +version = "1.10.0" + +[[deps.OrdinaryDiffEqFunctionMap]] +deps = ["DiffEqBase", "FastBroadcast", "MuladdMacro", "OrdinaryDiffEqCore", "RecursiveArrayTools", "Reexport", "SciMLBase", "Static"] +git-tree-sha1 = "2d2d59f9e530bca2f99934ecfde5430f6ad54bfe" +registries = "General" +uuid = "d3585ca7-f5d3-4ba6-8057-292ed1abd90f" +version = "1.11.0" + +[[deps.OrdinaryDiffEqHighOrderRK]] +deps = ["DiffEqBase", "FastBroadcast", "MuladdMacro", "OrdinaryDiffEqCore", "RecursiveArrayTools", "Reexport", "SciMLBase", "Static"] +git-tree-sha1 = "a6fef72198944e64e0d818f2cc46275e663370c9" +registries = "General" +uuid = "d28bc4f8-55e1-4f49-af69-84c1a99f0f58" +version = "1.12.0" + +[[deps.OrdinaryDiffEqIMEXMultistep]] +deps = ["ADTypes", "DiffEqBase", "FastBroadcast", "OrdinaryDiffEqCore", "OrdinaryDiffEqDifferentiation", "OrdinaryDiffEqNonlinearSolve", "Reexport", "SciMLBase"] +git-tree-sha1 = "bd5440f7f09ce75df59e7f5d2f5b8e52d24aae3c" +registries = "General" +uuid = "9f002381-b378-40b7-97a6-27a27c83f129" +version = "1.14.0" + +[[deps.OrdinaryDiffEqLinear]] +deps = ["DiffEqBase", "ExponentialUtilities", "LinearAlgebra", "OrdinaryDiffEqCore", "RecursiveArrayTools", "Reexport", "SciMLBase", "SciMLOperators"] +git-tree-sha1 = "a1217ddfc979da3a2d9cf11b083688562e8ef333" +registries = "General" +uuid = "521117fe-8c41-49f8-b3b6-30780b3f0fb5" +version = "1.12.0" + +[[deps.OrdinaryDiffEqLowOrderRK]] +deps = ["DiffEqBase", "FastBroadcast", "LinearAlgebra", "MuladdMacro", "OrdinaryDiffEqCore", "RecursiveArrayTools", "Reexport", "SciMLBase", "Static"] +git-tree-sha1 = "68a5e7e1b37933841e823a588deff3ec3e757a00" +registries = "General" +uuid = "1344f307-1e59-4825-a18e-ace9aa3fa4c6" +version = "1.13.0" + +[[deps.OrdinaryDiffEqLowStorageRK]] +deps = ["Adapt", "DiffEqBase", "FastBroadcast", "MuladdMacro", "OrdinaryDiffEqCore", "Polyester", "PrecompileTools", "Preferences", "RecursiveArrayTools", "Reexport", "SciMLBase", "Static"] +git-tree-sha1 = "076ac77cee882b2f4858292dde748c8b2ab908e7" +registries = "General" +uuid = "b0944070-b475-4768-8dec-fb6eb410534d" +version = "1.15.0" + +[[deps.OrdinaryDiffEqNonlinearSolve]] +deps = ["ADTypes", "ArrayInterface", "DiffEqBase", "FastBroadcast", "FastClosures", "ForwardDiff", "LinearAlgebra", "LinearSolve", "MuladdMacro", "NonlinearSolve", "OrdinaryDiffEqCore", "OrdinaryDiffEqDifferentiation", "PreallocationTools", "RecursiveArrayTools", "SciMLBase", "SciMLOperators", "SciMLStructures", "SimpleNonlinearSolve", "SparseArrays", "StaticArraysCore"] +git-tree-sha1 = "82dde00dc43d5a4762cf50fa070b654cc38a2e87" +registries = "General" +uuid = "127b3ac7-2247-4354-8eb6-78cf4e7c58e8" +version = "1.28.0" + +[[deps.OrdinaryDiffEqNordsieck]] +deps = ["DiffEqBase", "FastBroadcast", "LinearAlgebra", "MuladdMacro", "OrdinaryDiffEqCore", "OrdinaryDiffEqTsit5", "Polyester", "RecursiveArrayTools", "Reexport", "SciMLBase", "Static"] +git-tree-sha1 = "21117475cb0d27942d31e4b8a27337392ae680b0" +registries = "General" +uuid = "c9986a66-5c92-4813-8696-a7ec84c806c8" +version = "1.11.0" + +[[deps.OrdinaryDiffEqPDIRK]] +deps = ["ADTypes", "DiffEqBase", "FastBroadcast", "MuladdMacro", "OrdinaryDiffEqCore", "OrdinaryDiffEqDifferentiation", "OrdinaryDiffEqNonlinearSolve", "Polyester", "Reexport", "SciMLBase"] +git-tree-sha1 = "1aaaa4851bbe72497c9d01d69fa36396ddeb0a0a" +registries = "General" +uuid = "5dd0a6cf-3d4b-4314-aa06-06d4e299bc89" +version = "1.14.0" + +[[deps.OrdinaryDiffEqPRK]] +deps = ["DiffEqBase", "FastBroadcast", "MuladdMacro", "OrdinaryDiffEqCore", "Polyester", "Reexport", "SciMLBase"] +git-tree-sha1 = "1fe4f58f170c68b187ac42dc5f00932bb162ddfa" +registries = "General" +uuid = "5b33eab2-c0f1-4480-b2c3-94bc1e80bda1" +version = "1.10.0" + +[[deps.OrdinaryDiffEqQPRK]] +deps = ["DiffEqBase", "FastBroadcast", "MuladdMacro", "OrdinaryDiffEqCore", "RecursiveArrayTools", "Reexport", "SciMLBase", "Static"] +git-tree-sha1 = "275900d64ab7be5f1bca8c7bfd48166838b6ab44" +registries = "General" +uuid = "04162be5-8125-4266-98ed-640baecc6514" +version = "1.10.0" + +[[deps.OrdinaryDiffEqRKN]] +deps = ["DiffEqBase", "FastBroadcast", "MuladdMacro", "OrdinaryDiffEqCore", "Polyester", "RecursiveArrayTools", "Reexport", "SciMLBase"] +git-tree-sha1 = "edf3411246d6030e165a5fba513cbdcde5c72f79" +registries = "General" +uuid = "af6ede74-add8-4cfd-b1df-9a4dbb109d7a" +version = "1.12.0" + +[[deps.OrdinaryDiffEqRosenbrock]] +deps = ["ADTypes", "DiffEqBase", "DifferentiationInterface", "FastBroadcast", "FiniteDiff", "ForwardDiff", "LinearAlgebra", "LinearSolve", "MacroTools", "MuladdMacro", "OrdinaryDiffEqCore", "OrdinaryDiffEqDifferentiation", "Polyester", "PrecompileTools", "Preferences", "RecursiveArrayTools", "Reexport", "SciMLBase", "Static"] +git-tree-sha1 = "3579d9272c286ffcceee794c5752e8cc7c3ae514" +registries = "General" +uuid = "43230ef6-c299-4910-a778-202eb28ce4ce" +version = "1.31.1" + +[[deps.OrdinaryDiffEqSDIRK]] +deps = ["ADTypes", "DiffEqBase", "FastBroadcast", "LinearAlgebra", "MacroTools", "MuladdMacro", "OrdinaryDiffEqCore", "OrdinaryDiffEqDifferentiation", "OrdinaryDiffEqNonlinearSolve", "PrecompileTools", "Preferences", "RecursiveArrayTools", "Reexport", "SciMLBase", "TruncatedStacktraces"] +git-tree-sha1 = "c5e26fbadbad137fa2b7e3161a290a1becfec502" +registries = "General" +uuid = "2d112036-d095-4a1e-ab9a-08536f3ecdbf" +version = "1.14.0" + +[[deps.OrdinaryDiffEqSSPRK]] +deps = ["DiffEqBase", "FastBroadcast", "MuladdMacro", "OrdinaryDiffEqCore", "Polyester", "PrecompileTools", "Preferences", "RecursiveArrayTools", "Reexport", "SciMLBase", "Static"] +git-tree-sha1 = "4ec0be19f8115889f61643fc25f6e3af5cd4c9e7" +registries = "General" +uuid = "669c94d9-1f4b-4b64-b377-1aa079aa2388" +version = "1.14.0" + +[[deps.OrdinaryDiffEqStabilizedIRK]] +deps = ["ADTypes", "DiffEqBase", "FastBroadcast", "MuladdMacro", "OrdinaryDiffEqCore", "OrdinaryDiffEqDifferentiation", "OrdinaryDiffEqNonlinearSolve", "OrdinaryDiffEqStabilizedRK", "RecursiveArrayTools", "Reexport", "SciMLBase"] +git-tree-sha1 = "226226d334fe295885df6ecb2d110c22ead79983" +registries = "General" +uuid = "e3e12d00-db14-5390-b879-ac3dd2ef6296" +version = "1.14.0" + +[[deps.OrdinaryDiffEqStabilizedRK]] +deps = ["DiffEqBase", "FastBroadcast", "MuladdMacro", "OrdinaryDiffEqCore", "RecursiveArrayTools", "Reexport", "SciMLBase", "StaticArraysCore"] +git-tree-sha1 = "764e11fb6a26ee8f2d2d10778d531fd708f35d28" +registries = "General" +uuid = "358294b1-0aab-51c3-aafe-ad5ab194a2ad" +version = "1.11.1" + +[[deps.OrdinaryDiffEqSymplecticRK]] +deps = ["DiffEqBase", "FastBroadcast", "MuladdMacro", "OrdinaryDiffEqCore", "Polyester", "RecursiveArrayTools", "Reexport", "SciMLBase"] +git-tree-sha1 = "b18a4e7973e73e84cfd79222e2389565b323b588" +registries = "General" +uuid = "fa646aed-7ef9-47eb-84c4-9443fc8cbfa8" +version = "1.13.0" + +[[deps.OrdinaryDiffEqTsit5]] +deps = ["DiffEqBase", "FastBroadcast", "LinearAlgebra", "MuladdMacro", "OrdinaryDiffEqCore", "PrecompileTools", "Preferences", "RecursiveArrayTools", "Reexport", "SciMLBase", "Static", "TruncatedStacktraces"] +git-tree-sha1 = "6bd89fce8a0b198ac9fe98dc80362a92a2a13ae5" +registries = "General" +uuid = "b1df2697-797e-41e3-8120-5422d3b24e4a" +version = "1.12.0" + +[[deps.OrdinaryDiffEqVerner]] +deps = ["DiffEqBase", "FastBroadcast", "LinearAlgebra", "MuladdMacro", "OrdinaryDiffEqCore", "Polyester", "PrecompileTools", "Preferences", "RecursiveArrayTools", "Reexport", "SciMLBase", "Static", "TruncatedStacktraces"] +git-tree-sha1 = "58dc7756825ca46e5a601a5aeba7d26a071d373a" +registries = "General" +uuid = "79d7bb75-1356-48c1-b8c0-6832512096c2" +version = "1.14.0" + +[[deps.PCRE2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15" +version = "10.47.0+0" + +[[deps.Pango_jll]] +deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "FriBidi_jll", "Glib_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1912a9f1b9ca55005b03ba075f8e19993583e237" +registries = "General" +uuid = "36c8627f-9965-5494-a995-c6b170f724f3" +version = "1.58.2+0" + +[[deps.Parameters]] +deps = ["OrderedCollections", "UnPack"] +git-tree-sha1 = "34c0e9ad262e5f7fc75b10a9952ca7692cfc5fbe" +registries = "General" +uuid = "d96e819e-fc66-5662-9728-84c9c7592b0a" +version = "0.12.3" + +[[deps.Parsers]] +deps = ["Dates", "PrecompileTools", "UUIDs"] +git-tree-sha1 = "ba0dc8a8a67cacac4842631f960c046e4e563675" +registries = "General" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "2.8.8" + +[[deps.Pidfile]] +deps = ["FileWatching", "Test"] +git-tree-sha1 = "2d8aaf8ee10df53d0dfb9b8ee44ae7c04ced2b03" +registries = "General" +uuid = "fa939f87-e72e-5be4-a000-7fc836dbe307" +version = "1.3.0" + +[[deps.Pixman_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl"] +git-tree-sha1 = "e4a6721aa89e62e5d4217c0b21bd714263779dda" +registries = "General" +uuid = "30392449-352a-5448-841d-b1acce4e97dc" +version = "0.46.4+0" + +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "Zstd_jll", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.13.0" +weakdeps = ["REPL"] + + [deps.Pkg.extensions] + REPLExt = "REPL" + +[[deps.PlotThemes]] +deps = ["PlotUtils", "Statistics"] +git-tree-sha1 = "41031ef3a1be6f5bbbf3e8073f210556daeae5ca" +registries = "General" +uuid = "ccf2f8ad-2431-5c83-bf29-c5338b663b6a" +version = "3.3.0" + +[[deps.PlotUtils]] +deps = ["ColorSchemes", "Colors", "Dates", "PrecompileTools", "Printf", "Reexport", "Statistics"] +git-tree-sha1 = "ddcc36fd83fb4cd459a53c891981697bde0d3de6" +registries = "General" +uuid = "995b91a9-d308-5afd-9ec6-746e21dbc043" +version = "1.5.1" + +[[deps.PlotlyBase]] +deps = ["ColorSchemes", "Colors", "Dates", "DelimitedFiles", "DocStringExtensions", "JSON", "LaTeXStrings", "Logging", "Parameters", "Pkg", "REPL", "Requires", "Statistics", "UUIDs"] +git-tree-sha1 = "6256ab3ee24ef079b3afa310593817e069925eeb" +registries = "General" +uuid = "a03496cd-edff-5a9b-9e67-9cda94a718b5" +version = "0.8.23" + + [deps.PlotlyBase.extensions] + DataFramesExt = "DataFrames" + DistributionsExt = "Distributions" + IJuliaExt = "IJulia" + JSON3Ext = "JSON3" + + [deps.PlotlyBase.weakdeps] + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" + IJulia = "7073ff75-c697-5162-941a-fcdaad2a7d2a" + JSON3 = "0f8b85d8-7281-11e9-16c2-39a750bddbf1" + +[[deps.PlotlyJS]] +deps = ["Base64", "Blink", "DelimitedFiles", "JSExpr", "JSON", "Kaleido_jll", "Markdown", "Pkg", "PlotlyBase", "PlotlyKaleido", "REPL", "Reexport", "Requires", "WebIO"] +git-tree-sha1 = "4bf6c08295346efba58bb2d5f8c52984efed7f27" +registries = "General" +uuid = "f0f68f2c-4968-5e81-91da-67840de0976a" +version = "0.18.18" + + [deps.PlotlyJS.extensions] + CSVExt = "CSV" + DataFramesExt = ["DataFrames", "CSV"] + IJuliaExt = "IJulia" + JSON3Ext = "JSON3" + + [deps.PlotlyJS.weakdeps] + CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b" + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + IJulia = "7073ff75-c697-5162-941a-fcdaad2a7d2a" + JSON3 = "0f8b85d8-7281-11e9-16c2-39a750bddbf1" + +[[deps.PlotlyKaleido]] +deps = ["Artifacts", "Base64", "JSON", "Kaleido_jll"] +git-tree-sha1 = "c7a270d11881c0709052f8e3def3d60d551e99f3" +registries = "General" +uuid = "f2990250-8cf9-495f-b13a-cce12b45703c" +version = "2.3.1" + +[[deps.Plots]] +deps = ["Base64", "Contour", "Dates", "Downloads", "FFMPEG", "FixedPointNumbers", "GR", "JLFzf", "JSON", "LaTeXStrings", "Latexify", "LinearAlgebra", "Measures", "NaNMath", "Pkg", "PlotThemes", "PlotUtils", "PrecompileTools", "Printf", "REPL", "Random", "RecipesBase", "RecipesPipeline", "Reexport", "RelocatableFolders", "Requires", "Scratch", "Showoff", "SparseArrays", "Statistics", "StatsBase", "TOML", "UUIDs", "UnicodeFun", "Unzip"] +git-tree-sha1 = "83bd514e8ff16b5858ac54c53fa0bcf6002a3b00" +registries = "General" +uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" +version = "1.41.7" + + [deps.Plots.extensions] + FileIOExt = "FileIO" + GeometryBasicsExt = "GeometryBasics" + IJuliaExt = "IJulia" + ImageInTerminalExt = "ImageInTerminal" + UnitfulExt = "Unitful" + + [deps.Plots.weakdeps] + FileIO = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549" + GeometryBasics = "5c1252a2-5f33-56bf-86c9-59e7332b4326" + IJulia = "7073ff75-c697-5162-941a-fcdaad2a7d2a" + ImageInTerminal = "d8c32880-2388-543b-8c61-d9f865259254" + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.Polyester]] +deps = ["ArrayInterface", "BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "ManualMemory", "PolyesterWeave", "Static", "StaticArrayInterface", "StrideArraysCore", "ThreadingUtilities"] +git-tree-sha1 = "16bbc30b5ebea91e9ce1671adc03de2832cff552" +registries = "General" +uuid = "f517fe37-dbe3-4b94-8317-1923a5111588" +version = "0.7.19" + +[[deps.PolyesterWeave]] +deps = ["BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "Static", "ThreadingUtilities"] +git-tree-sha1 = "645bed98cd47f72f67316fd42fc47dee771aefcd" +registries = "General" +uuid = "1d0040c9-8b98-4ee7-8388-3f51789ca0ad" +version = "0.2.2" + +[[deps.PooledArrays]] +deps = ["DataAPI", "Future"] +git-tree-sha1 = "36d8b4b899628fb92c2749eb488d884a926614d3" +registries = "General" +uuid = "2dfb63ee-cc39-5dd5-95bd-886bf059d720" +version = "1.4.3" + +[[deps.PreallocationTools]] +deps = ["Adapt", "ArrayInterface", "PrecompileTools", "SciMLPublic"] +git-tree-sha1 = "cd00e28071a75c98664663f87c2ae447d25c0503" +registries = "General" +uuid = "d236fae5-4411-538c-8e31-a6e3d9e00b46" +version = "1.7.1" + + [deps.PreallocationTools.extensions] + PreallocationToolsEnzymeCoreExt = "EnzymeCore" + PreallocationToolsForwardDiffExt = "ForwardDiff" + PreallocationToolsReverseDiffExt = "ReverseDiff" + + [deps.PreallocationTools.weakdeps] + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + +[[deps.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "edbeefc7a4889f528644251bdb5fc9ab5348bc2c" +registries = "General" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.3.4" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "aef1987d90dcc2e2cbd919ad10b2d25bcce4f418" +registries = "General" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.6.1" + +[[deps.PrettyTables]] +deps = ["Crayons", "LaTeXStrings", "Markdown", "PrecompileTools", "Printf", "REPL", "Reexport", "StringManipulation", "StyledStrings", "Tables"] +git-tree-sha1 = "99fd8f32ab6728ff205cddd24e2d9ea6cbb498d3" +registries = "General" +uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" +version = "3.5.0" + + [deps.PrettyTables.extensions] + PrettyTablesExcelExt = "XLSX" + PrettyTablesTypstryExt = "Typstry" + PrettyTablesWriteDocxExt = "WriteDocx" + + [deps.PrettyTables.weakdeps] + Typstry = "f0ed7684-a786-439e-b1e3-3b82803b501e" + WriteDocx = "d049ceea-54ee-41d7-a26f-ba29db3b6599" + XLSX = "fdbf4ff8-1666-58a4-91e7-1b58723a45e0" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" +version = "1.11.0" + +[[deps.PtrArrays]] +git-tree-sha1 = "4fbbafbc6251b883f4d2705356f3641f3652a7fe" +registries = "General" +uuid = "43287f4e-b6f4-7ad1-bb20-aadabca52c3d" +version = "1.4.0" + +[[deps.PureKLU]] +deps = ["LinearAlgebra", "PrecompileTools", "SparseArrays"] +git-tree-sha1 = "ad0e84647fe7b3c2ae02aaeace1522139aaf6a27" +registries = "General" +uuid = "0c0d3e7f-3a8b-4f7e-b6f1-9a4d2e7c1f01" +version = "1.6.0" +weakdeps = ["ForwardDiff"] + + [deps.PureKLU.extensions] + PureKLUForwardDiffExt = "ForwardDiff" + +[[deps.Qt6Base_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Fontconfig_jll", "Glib_jll", "JLLWrappers", "Libdl", "Libglvnd_jll", "OpenSSL_jll", "Vulkan_Loader_jll", "Xorg_libSM_jll", "Xorg_libXext_jll", "Xorg_libXrender_jll", "Xorg_libxcb_jll", "Xorg_xcb_util_cursor_jll", "Xorg_xcb_util_image_jll", "Xorg_xcb_util_keysyms_jll", "Xorg_xcb_util_renderutil_jll", "Xorg_xcb_util_wm_jll", "Zlib_jll", "libinput_jll", "xkbcommon_jll"] +git-tree-sha1 = "144895f6166994730ee7ff8113b981fc360638f1" +registries = "General" +uuid = "c0090381-4147-56d7-9ebc-da0b1113ec56" +version = "6.10.2+2" + +[[deps.Qt6Declarative_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Qt6Base_jll", "Qt6ShaderTools_jll", "Qt6Svg_jll"] +git-tree-sha1 = "159d253ab126d5b29230cf53521899bea4ef4648" +registries = "General" +uuid = "629bc702-f1f5-5709-abd5-49b8460ea067" +version = "6.10.2+2" + +[[deps.Qt6ShaderTools_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Qt6Base_jll"] +git-tree-sha1 = "4d85eedf69d875982c46643f6b4f66919d7e157b" +registries = "General" +uuid = "ce943373-25bb-56aa-8eca-768745ed7b5a" +version = "6.10.2+1" + +[[deps.Qt6Svg_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Qt6Base_jll"] +git-tree-sha1 = "81587ff5ff25a4e1115ce191e36285ede0334c9d" +registries = "General" +uuid = "6de9746b-f93d-5813-b365-ba18ad4a9cf3" +version = "6.10.2+0" + +[[deps.Qt6Wayland_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Qt6Base_jll", "Qt6Declarative_jll"] +git-tree-sha1 = "672c938b4b4e3e0169a07a5f227029d4905456f2" +registries = "General" +uuid = "e99dba38-086e-5de3-a5b1-6e4c66e897c3" +version = "6.10.2+1" + +[[deps.QuadGK]] +deps = ["DataStructures", "LinearAlgebra"] +git-tree-sha1 = "5e8e8b0ab68215d7a2b14b9921a946fee794749e" +registries = "General" +uuid = "1fd47b50-473d-5c70-9696-f719f8f3bcdc" +version = "2.11.3" + + [deps.QuadGK.extensions] + QuadGKEnzymeExt = "Enzyme" + + [deps.QuadGK.weakdeps] + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + +[[deps.Quadmath]] +deps = ["Compat", "Printf", "Random"] +git-tree-sha1 = "fc861299ef1c23d1985de276b2233db4a980a55c" +registries = "General" +uuid = "be4d8f0f-7fa4-5f49-b795-2f01399ab2dd" +version = "1.1.0" +weakdeps = ["SpecialFunctions"] + + [deps.Quadmath.extensions] + QuadmathSpecialFunctionsExt = ["SpecialFunctions"] + +[[deps.REPL]] +deps = ["Base64", "Dates", "FileWatching", "InteractiveUtils", "JuliaSyntaxHighlighting", "Markdown", "Sockets", "StyledStrings", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" +version = "1.11.0" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +version = "1.11.0" + +[[deps.RecipesBase]] +deps = ["PrecompileTools"] +git-tree-sha1 = "0c0dcffc464cda2ff33fc8ffc1dd1bdd53cd98be" +registries = "General" +uuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" +version = "1.4.0" + +[[deps.RecipesPipeline]] +deps = ["Dates", "NaNMath", "PlotUtils", "PrecompileTools", "RecipesBase"] +git-tree-sha1 = "45cf9fd0ca5839d06ef333c8201714e888486342" +registries = "General" +uuid = "01d81517-befc-4cb6-b9ec-a95719d0359c" +version = "0.6.12" + +[[deps.RecursiveArrayTools]] +deps = ["Adapt", "ArrayInterface", "DocStringExtensions", "GPUArraysCore", "LinearAlgebra", "PrecompileTools", "RecipesBase", "StaticArraysCore", "SymbolicIndexingInterface"] +git-tree-sha1 = "d0282d612f22dcad7b81cf487b746e63aa2a6709" +registries = "General" +uuid = "731186ca-8d62-57ce-b412-fbd966d074cd" +version = "3.54.0" + + [deps.RecursiveArrayTools.extensions] + RecursiveArrayToolsFastBroadcastExt = "FastBroadcast" + RecursiveArrayToolsFastBroadcastPolyesterExt = ["FastBroadcast", "Polyester"] + RecursiveArrayToolsForwardDiffExt = "ForwardDiff" + RecursiveArrayToolsKernelAbstractionsExt = "KernelAbstractions" + RecursiveArrayToolsMeasurementsExt = "Measurements" + RecursiveArrayToolsMonteCarloMeasurementsExt = "MonteCarloMeasurements" + RecursiveArrayToolsReverseDiffExt = ["ReverseDiff", "Zygote"] + RecursiveArrayToolsSparseArraysExt = ["SparseArrays"] + RecursiveArrayToolsStatisticsExt = "Statistics" + RecursiveArrayToolsStructArraysExt = "StructArrays" + RecursiveArrayToolsTablesExt = ["Tables"] + RecursiveArrayToolsTrackerExt = "Tracker" + RecursiveArrayToolsZygoteExt = "Zygote" + + [deps.RecursiveArrayTools.weakdeps] + FastBroadcast = "7034ab61-46d4-4ed7-9d0f-46aef9175898" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca" + Polyester = "f517fe37-dbe3-4b94-8317-1923a5111588" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" + StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +registries = "General" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[deps.RegistryInstances]] +deps = ["LazilyInitializedFields", "Pkg", "TOML", "Tar"] +git-tree-sha1 = "ffd19052caf598b8653b99404058fce14828be51" +registries = "General" +uuid = "2792f1a3-b283-48e8-9a74-f99dce5104f3" +version = "0.1.0" + +[[deps.RelocatableFolders]] +deps = ["SHA", "Scratch"] +git-tree-sha1 = "ffdaf70d81cf6ff22c2b6e733c900c3321cab864" +registries = "General" +uuid = "05181044-ff0b-4ac5-8273-598c1e38db00" +version = "1.0.1" + +[[deps.Requires]] +deps = ["UUIDs"] +git-tree-sha1 = "62389eeff14780bfe55195b7204c0d8738436d64" +registries = "General" +uuid = "ae029012-a4dd-5104-9daa-d747884805df" +version = "1.3.1" + +[[deps.Roots]] +deps = ["Accessors", "CommonSolve", "Printf"] +git-tree-sha1 = "3eff988b9bd09543783e2e051b0a1eef11f65c2d" +registries = "General" +uuid = "f2b01f46-fcfa-551c-844a-d8ac1e96c665" +version = "2.3.0" + + [deps.Roots.extensions] + RootsChainRulesCoreExt = "ChainRulesCore" + RootsForwardDiffExt = "ForwardDiff" + RootsIntervalRootFindingExt = "IntervalRootFinding" + RootsSymPyExt = "SymPy" + RootsSymPyPythonCallExt = "SymPyPythonCall" + RootsUnitfulExt = "Unitful" + + [deps.Roots.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + IntervalRootFinding = "d2bf35a9-74e0-55ec-b149-d360ff49b807" + SymPy = "24249f21-da20-56a4-8eb1-6a02cf4ae2e6" + SymPyPythonCall = "bc8888f7-b21e-4b7c-a06a-5d9c9496438c" + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.RoundingEmulator]] +git-tree-sha1 = "40b9edad2e5287e05bd413a38f61a8ff55b9557b" +registries = "General" +uuid = "5eaf0fd0-dfba-4ccb-bf02-d820a40db705" +version = "0.2.1" + +[[deps.RuntimeGeneratedFunctions]] +deps = ["ExprTools", "PrecompileTools", "SHA", "Serialization"] +git-tree-sha1 = "9bb075002b40849582905394bb3031fb77aa102d" +registries = "General" +uuid = "7e49a35a-f44a-4d26-94aa-eba1b4ca6b47" +version = "0.5.27" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "1.0.0" + +[[deps.SIMDTypes]] +git-tree-sha1 = "330289636fb8107c5f32088d2741e9fd7a061a5c" +registries = "General" +uuid = "94e857df-77ce-4151-89e5-788b33177be4" +version = "0.1.0" + +[[deps.SciMLBase]] +deps = ["ADTypes", "Accessors", "Adapt", "ArrayInterface", "CommonSolve", "ConstructionBase", "Distributed", "DocStringExtensions", "EnumX", "FunctionWrappersWrappers", "IteratorInterfaceExtensions", "LinearAlgebra", "Logging", "Markdown", "Moshi", "PreallocationTools", "PrecompileTools", "Preferences", "Printf", "RecipesBase", "RecursiveArrayTools", "Reexport", "RuntimeGeneratedFunctions", "SciMLLogging", "SciMLOperators", "SciMLPublic", "SciMLStructures", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface"] +git-tree-sha1 = "d56cb3b924cdf9297c171113e6a6ae9694e370eb" +registries = "General" +uuid = "0bca4576-84f4-4d90-8ffe-ffa030f20462" +version = "2.155.2" + + [deps.SciMLBase.extensions] + SciMLBaseChainRulesCoreExt = "ChainRulesCore" + SciMLBaseDifferentiationInterfaceExt = "DifferentiationInterface" + SciMLBaseDistributionsExt = "Distributions" + SciMLBaseEnzymeExt = "Enzyme" + SciMLBaseForwardDiffExt = "ForwardDiff" + SciMLBaseMLStyleExt = "MLStyle" + SciMLBaseMakieExt = "Makie" + SciMLBaseMeasurementsExt = "Measurements" + SciMLBaseMonteCarloMeasurementsExt = "MonteCarloMeasurements" + SciMLBaseMooncakeExt = "Mooncake" + SciMLBasePartialFunctionsExt = "PartialFunctions" + SciMLBasePyCallExt = "PyCall" + SciMLBasePythonCallExt = "PythonCall" + SciMLBaseRCallExt = "RCall" + SciMLBaseReverseDiffExt = "ReverseDiff" + SciMLBaseTrackerExt = "Tracker" + SciMLBaseZygoteExt = ["Zygote", "ChainRulesCore"] + + [deps.SciMLBase.weakdeps] + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + DifferentiationInterface = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63" + Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + MLStyle = "d8e11817-5142-5d16-987a-aa16d5891078" + Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + PartialFunctions = "570af359-4316-4cb7-8c74-252c00c2016b" + PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" + PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" + RCall = "6f49c342-dc21-5d91-9882-a32aef131414" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.SciMLJacobianOperators]] +deps = ["ADTypes", "ArrayInterface", "ConcreteStructs", "ConstructionBase", "DifferentiationInterface", "FastClosures", "LinearAlgebra", "SciMLBase", "SciMLOperators"] +git-tree-sha1 = "ad167d716fc134c0873c76ba0469ede56a678732" +registries = "General" +uuid = "19f34311-ddf3-4b8b-af20-060888a46c0e" +version = "0.1.17" + +[[deps.SciMLLogging]] +deps = ["Logging", "LoggingExtras", "Preferences"] +git-tree-sha1 = "4e1e21f14a284f892eb62923a356c70a2a0c68e1" +registries = "General" +uuid = "a6db7da4-7206-11f0-1eab-35f2a5dbe1d1" +version = "1.10.1" + + [deps.SciMLLogging.extensions] + SciMLLoggingTracyExt = "Tracy" + + [deps.SciMLLogging.weakdeps] + Tracy = "e689c965-62c8-4b79-b2c5-8359227902fd" + +[[deps.SciMLOperators]] +deps = ["Accessors", "Adapt", "ArrayInterface", "DocStringExtensions", "LinearAlgebra", "PrecompileTools", "SciMLPublic"] +git-tree-sha1 = "2712b6eeef282b5cd8c38660e68c001a4b9b24e2" +registries = "General" +uuid = "c0aeaf25-5076-4817-a8d5-81caf7dfa961" +version = "1.30.3" + + [deps.SciMLOperators.extensions] + SciMLOperatorsLoopVectorizationExt = "LoopVectorization" + SciMLOperatorsSparseArraysExt = "SparseArrays" + + [deps.SciMLOperators.weakdeps] + LoopVectorization = "bdcacae8-1622-11e9-2a5c-532679323890" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + +[[deps.SciMLPublic]] +deps = ["PrecompileTools"] +git-tree-sha1 = "74685afb51732a464fbce79a72708f7c4203ceb7" +registries = "General" +uuid = "431bcebd-1456-4ced-9d72-93c2757fff0b" +version = "1.3.0" + +[[deps.SciMLStructures]] +deps = ["ArrayInterface", "PrecompileTools"] +git-tree-sha1 = "4b8fc0ffe22b4ecba7a02f1fec0b3757db014d0c" +registries = "General" +uuid = "53ae85a6-f571-4167-b2af-e1d143709226" +version = "1.10.6" + +[[deps.ScopedValues]] +deps = ["HashArrayMappedTries", "Logging"] +git-tree-sha1 = "67a144433c4ce877ee6d1ada69a124d6b1ecf7be" +registries = "General" +uuid = "7e506255-f358-4e82-b7e4-beb19740aa63" +version = "1.6.2" + +[[deps.Scratch]] +deps = ["Dates"] +git-tree-sha1 = "9b81b8393e50b7d4e6d0a9f14e192294d3b7c109" +registries = "General" +uuid = "6c6a2e73-6563-6170-7368-637461726353" +version = "1.3.0" + +[[deps.SentinelArrays]] +deps = ["Dates", "Random"] +git-tree-sha1 = "084c47c7c5ce5cfecefa0a98dff69eb3646b5a80" +registries = "General" +uuid = "91c51154-3ec4-41a3-a24f-3f23e20d615c" +version = "1.4.10" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" +version = "1.11.0" + +[[deps.Setfield]] +deps = ["ConstructionBase", "Future", "MacroTools", "StaticArraysCore"] +git-tree-sha1 = "1a17a79e9dffc0d188c81c7ea58e8cc79752df7e" +registries = "General" +uuid = "efcf1570-3423-57d1-acb7-fd33fddbac46" +version = "1.1.3" + +[[deps.Showoff]] +deps = ["Dates"] +git-tree-sha1 = "8238217340ad0aaabe11afe39c1098b5bc9f4c8e" +registries = "General" +uuid = "992d4aef-0814-514b-bc4d-f2e9a6c4116f" +version = "1.1.1" + +[[deps.SimpleBufferStream]] +git-tree-sha1 = "f305871d2f381d21527c770d4788c06c097c9bc1" +registries = "General" +uuid = "777ac1f9-54b0-4bf8-805c-2214025038e7" +version = "1.2.0" + +[[deps.SimpleNonlinearSolve]] +deps = ["ADTypes", "ArrayInterface", "BracketingNonlinearSolve", "CommonSolve", "ConcreteStructs", "DifferentiationInterface", "FastClosures", "FiniteDiff", "ForwardDiff", "LineSearch", "LinearAlgebra", "MaybeInplace", "NonlinearSolveBase", "PrecompileTools", "Reexport", "SciMLBase", "Setfield", "StaticArraysCore"] +git-tree-sha1 = "08d8bafd57b7ea16dc1f69a8bd57db23a2ceb686" +registries = "General" +uuid = "727e6d20-b764-4bd8-a329-72de5adea6c7" +version = "2.12.0" + + [deps.SimpleNonlinearSolve.extensions] + SimpleNonlinearSolveChainRulesCoreExt = "ChainRulesCore" + SimpleNonlinearSolveReverseDiffExt = "ReverseDiff" + SimpleNonlinearSolveTrackerExt = "Tracker" + + [deps.SimpleNonlinearSolve.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" +version = "1.11.0" + +[[deps.SortingAlgorithms]] +deps = ["DataStructures"] +git-tree-sha1 = "13cd91cc9be159e3f4d95b857fa2aa383b53772a" +registries = "General" +uuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c" +version = "1.2.3" + +[[deps.SparseArrays]] +deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" +version = "1.13.0" + +[[deps.SparseColumnPivotedQR]] +deps = ["LinearAlgebra", "PrecompileTools", "SparseArrays"] +git-tree-sha1 = "8cf1a59c78dd6f900feb366e5a574f99ed278ef1" +registries = "General" +uuid = "a57abbd0-fea5-4d57-96be-5e525945e8e4" +version = "2.1.8" +weakdeps = ["AMD"] + + [deps.SparseColumnPivotedQR.extensions] + SparseColumnPivotedQRAMDExt = "AMD" + +[[deps.SparseMatrixColorings]] +deps = ["ADTypes", "DocStringExtensions", "LinearAlgebra", "PrecompileTools", "Random", "SparseArrays"] +git-tree-sha1 = "0730f14b07c68fd3b3a6fae89a829a5124a7ae7e" +registries = "General" +uuid = "0a514795-09f3-496d-8182-132a7b665d35" +version = "0.4.29" + + [deps.SparseMatrixColorings.extensions] + SparseMatrixColoringsAMDGPUExt = "AMDGPU" + SparseMatrixColoringsCUDAExt = ["CUDA", "cuSPARSE"] + SparseMatrixColoringsCliqueTreesExt = "CliqueTrees" + SparseMatrixColoringsColorsExt = "Colors" + SparseMatrixColoringsGPUArraysExt = "GPUArrays" + SparseMatrixColoringsJuMPExt = ["JuMP", "MathOptInterface"] + + [deps.SparseMatrixColorings.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CliqueTrees = "60701a23-6482-424a-84db-faee86b9b1f8" + Colors = "5ae59095-9a9b-59fe-a467-6f913c188581" + GPUArrays = "0c68f7d7-f131-5f86-a1c3-88cf8149b2d7" + JuMP = "4076af6c-e467-56ae-b986-b466b2749572" + MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee" + cuSPARSE = "b26da814-b3bc-49ef-b0ee-c816305aa060" + +[[deps.SpecialFunctions]] +deps = ["IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"] +git-tree-sha1 = "88ef0d98204515bc53dd4aaea5f7788882d1b66c" +registries = "General" +uuid = "276daf66-3868-5448-9aa4-cd146d93841b" +version = "2.9.1" + + [deps.SpecialFunctions.extensions] + SpecialFunctionsChainRulesCoreExt = "ChainRulesCore" + + [deps.SpecialFunctions.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + +[[deps.Static]] +deps = ["CommonWorldInvalidations", "IfElse", "PrecompileTools", "SciMLPublic"] +git-tree-sha1 = "474a5283ad435618090122872eea6a8165ea6bcf" +registries = "General" +uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" +version = "1.4.6" + +[[deps.StaticArrayInterface]] +deps = ["ArrayInterface", "Compat", "IfElse", "LinearAlgebra", "PrecompileTools", "SciMLPublic", "Static"] +git-tree-sha1 = "2a635e15d5035c53b345077c947f31ff91744078" +registries = "General" +uuid = "0d7ed370-da01-4f52-bd93-41d350b8b718" +version = "1.10.0" + + [deps.StaticArrayInterface.extensions] + StaticArrayInterfaceOffsetArraysExt = "OffsetArrays" + StaticArrayInterfaceStaticArraysExt = "StaticArrays" + + [deps.StaticArrayInterface.weakdeps] + OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.StaticArrays]] +deps = ["LinearAlgebra", "PrecompileTools", "Random", "StaticArraysCore"] +git-tree-sha1 = "8a8a52f887f38d44014e24ee46b8a7311c625f6d" +registries = "General" +uuid = "90137ffa-7385-5640-81b9-e52037218182" +version = "1.9.24" + + [deps.StaticArrays.extensions] + StaticArraysChainRulesCoreExt = "ChainRulesCore" + StaticArraysStatisticsExt = "Statistics" + + [deps.StaticArrays.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" + +[[deps.StaticArraysCore]] +git-tree-sha1 = "6ab403037779dae8c514bad259f32a447262455a" +registries = "General" +uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" +version = "1.4.4" + +[[deps.Statistics]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "e2b53ce13a53367e96601081e33d34746b571bad" +registries = "General" +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +version = "1.11.5" +weakdeps = ["SparseArrays"] + + [deps.Statistics.extensions] + SparseArraysExt = ["SparseArrays"] + +[[deps.StatsAPI]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "178ed29fd5b2a2cfc3bd31c13375ae925623ff36" +registries = "General" +uuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0" +version = "1.8.0" + +[[deps.StatsBase]] +deps = ["AliasTables", "DataAPI", "DataStructures", "IrrationalConstants", "LinearAlgebra", "LogExpFunctions", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"] +git-tree-sha1 = "adb9da019510162e67a4493fc235c23203d8b09e" +registries = "General" +uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" +version = "0.34.13" + +[[deps.StrideArraysCore]] +deps = ["ArrayInterface", "CloseOpenIntervals", "IfElse", "LayoutPointers", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface", "ThreadingUtilities"] +git-tree-sha1 = "5316097111523c9a970596a5b33cfea5f92e8581" +registries = "General" +uuid = "7792a7ef-975c-4747-a70f-980b88e8d1da" +version = "0.5.9" + +[[deps.StringManipulation]] +deps = ["PrecompileTools", "StyledStrings"] +git-tree-sha1 = "9e3a02d73a8f0a9be04e677dbef758aab40f8bea" +registries = "General" +uuid = "892a3eda-7b42-436c-8928-eab12a02cf0e" +version = "0.6.1" + +[[deps.StyledStrings]] +uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b" +version = "1.11.0" + +[[deps.SuiteSparse_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl", "libblastrampoline_jll"] +uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c" +version = "7.10.1+0" + +[[deps.SymbolicIndexingInterface]] +deps = ["Accessors", "ArrayInterface", "PrecompileTools", "RuntimeGeneratedFunctions", "StaticArraysCore"] +git-tree-sha1 = "7eb6da9656581ac9fbffaef3ef7950a090a5002a" +registries = "General" +uuid = "2efcf032-c050-4f8e-a9bb-153293bab1f5" +version = "0.3.55" +weakdeps = ["PrettyTables"] + + [deps.SymbolicIndexingInterface.extensions] + SymbolicIndexingInterfacePrettyTablesExt = "PrettyTables" + +[[deps.TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.3" + +[[deps.TableTraits]] +deps = ["IteratorInterfaceExtensions"] +git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39" +registries = "General" +uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" +version = "1.0.1" + +[[deps.Tables]] +deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "OrderedCollections", "TableTraits"] +git-tree-sha1 = "a94d9bdda1b7bed0046cea645639ab3f62196fac" +registries = "General" +uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" +version = "1.14.0" + +[[deps.Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + +[[deps.TensorCore]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "1feb45f88d133a655e001435632f019a9a1bcdb6" +registries = "General" +uuid = "62fd8b95-f654-4bbd-a8a5-9c27f68ccd50" +version = "0.1.1" + +[[deps.Test]] +deps = ["InteractiveUtils", "Logging", "Random", "Serialization"] +uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40" +version = "1.11.0" + +[[deps.ThreadSafeDicts]] +git-tree-sha1 = "411010ade7dd5576d693db8737976d805ee9945b" +registries = "General" +uuid = "4239201d-c60e-5e0a-9702-85d713665ba7" +version = "0.1.7" + +[[deps.ThreadingUtilities]] +deps = ["ManualMemory"] +git-tree-sha1 = "e12924c87b5476110130841e973ba9b9f20ae599" +registries = "General" +uuid = "8290d209-cae3-49c0-8002-c8c24d57dab5" +version = "0.5.7" + +[[deps.TimerOutputs]] +deps = ["ExprTools", "Printf"] +git-tree-sha1 = "3748bd928e68c7c346b52125cf41fff0de6937d0" +registries = "General" +uuid = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f" +version = "0.5.29" + + [deps.TimerOutputs.extensions] + FlameGraphsExt = "FlameGraphs" + + [deps.TimerOutputs.weakdeps] + FlameGraphs = "08572546-2f56-4bcf-ba4e-bab62c3a3f89" + +[[deps.TranscodingStreams]] +git-tree-sha1 = "0c45878dcfdcfa8480052b6ab162cdd138781742" +registries = "General" +uuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa" +version = "0.11.3" + +[[deps.TruncatedStacktraces]] +deps = ["InteractiveUtils", "MacroTools", "Preferences"] +git-tree-sha1 = "ea3e54c2bdde39062abf5a9758a23735558705e1" +registries = "General" +uuid = "781d530d-4396-4725-bb49-402e4bee1e77" +version = "1.4.0" + +[[deps.URIs]] +deps = ["Serialization"] +git-tree-sha1 = "50eda8011f098869a76da69a524ff59e0298711a" +registries = "General" +uuid = "5c2747f8-b7ea-4ff2-ba2e-563bfd36b1d4" +version = "1.7.2" + +[[deps.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" +version = "1.11.0" + +[[deps.UnPack]] +git-tree-sha1 = "387c1f73762231e86e0c9c5443ce3b4a0a9a0c2b" +registries = "General" +uuid = "3a884ed6-31ef-47d7-9d2a-63182c4928ed" +version = "1.0.2" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" +version = "1.11.0" + +[[deps.UnicodeFun]] +deps = ["REPL"] +git-tree-sha1 = "53915e50200959667e78a92a418594b428dffddf" +registries = "General" +uuid = "1cfade01-22cf-5700-b092-accc4b62d6e1" +version = "0.4.1" + +[[deps.Unzip]] +git-tree-sha1 = "ca0969166a028236229f63514992fc073799bb78" +registries = "General" +uuid = "41fe7b60-77ed-43a1-b4f0-825fd5a5650d" +version = "0.2.0" + +[[deps.Vulkan_Loader_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Wayland_jll", "Xorg_libX11_jll", "Xorg_libXrandr_jll", "xkbcommon_jll"] +git-tree-sha1 = "2f0486047a07670caad3a81a075d2e518acc5c59" +registries = "General" +uuid = "a44049a8-05dd-5a78-86c9-5fde0876e88c" +version = "1.3.243+0" + +[[deps.Wayland_jll]] +deps = ["Artifacts", "EpollShim_jll", "Expat_jll", "JLLWrappers", "Libdl", "Libffi_jll"] +git-tree-sha1 = "96478df35bbc2f3e1e791bc7a3d0eeee559e60e9" +registries = "General" +uuid = "a2964d1f-97da-50d4-b82a-358c7fce9d89" +version = "1.24.0+0" + +[[deps.WebIO]] +deps = ["AssetRegistry", "Base64", "Distributed", "FunctionalCollections", "JSON", "Logging", "Observables", "Pkg", "Random", "Requires", "Sockets", "UUIDs", "WebSockets", "Widgets"] +git-tree-sha1 = "0eef0765186f7452e52236fa42ca8c9b3c11c6e3" +registries = "General" +uuid = "0f1e0344-ec1d-5b48-a673-e5cf874b6c29" +version = "0.8.21" + +[[deps.WebSockets]] +deps = ["Base64", "Dates", "HTTP", "Logging", "Sockets"] +git-tree-sha1 = "4162e95e05e79922e44b9952ccbc262832e4ad07" +registries = "General" +uuid = "104b5d7c-a370-577a-8038-80a2059c5097" +version = "1.6.0" + +[[deps.Widgets]] +deps = ["Colors", "Dates", "Observables", "OrderedCollections"] +git-tree-sha1 = "cab29ed70d9355a28b95b1798007ff3a00eefc91" +registries = "General" +uuid = "cc8bc4a8-27d6-5769-a93b-9d913e69aa62" +version = "0.6.8" + +[[deps.XML2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Zlib_jll"] +git-tree-sha1 = "b826aedca5fce2e3c91904e338c279e5c1a2da74" +registries = "General" +uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a" +version = "2.15.4+0" + +[[deps.XZ_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e52eca002a11c30a858185efdfb15311e1c7a6bf" +registries = "General" +uuid = "ffd25f8a-64ca-5728-b0f7-c24cf3aae800" +version = "5.8.4+0" + +[[deps.Xorg_libICE_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "a3ea76ee3f4facd7a64684f9af25310825ee3668" +registries = "General" +uuid = "f67eecfb-183a-506d-b269-f58e52b52d7c" +version = "1.1.2+0" + +[[deps.Xorg_libSM_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libICE_jll"] +git-tree-sha1 = "9c7ad99c629a44f81e7799eb05ec2746abb5d588" +registries = "General" +uuid = "c834827a-8449-5923-a945-d239c165b7dd" +version = "1.2.6+0" + +[[deps.Xorg_libX11_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libxcb_jll", "Xorg_xtrans_jll"] +git-tree-sha1 = "ce91b54a5f90c4f27df6950706234b34e49cf79e" +registries = "General" +uuid = "4f6342f7-b3d2-589e-9d20-edeb45f2b2bc" +version = "1.8.14+0" + +[[deps.Xorg_libXau_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "aa1261ebbac3ccc8d16558ae6799524c450ed16b" +registries = "General" +uuid = "0c0b7dd1-d40b-584c-a123-a41640f87eec" +version = "1.0.13+0" + +[[deps.Xorg_libXcursor_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libXfixes_jll", "Xorg_libXrender_jll"] +git-tree-sha1 = "6c74ca84bbabc18c4547014765d194ff0b4dc9da" +registries = "General" +uuid = "935fb764-8cf2-53bf-bb30-45bb1f8bf724" +version = "1.2.4+0" + +[[deps.Xorg_libXdmcp_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "52858d64353db33a56e13c341d7bf44cd0d7b309" +registries = "General" +uuid = "a3789734-cfe1-5b06-b2d0-1dd0d9d62d05" +version = "1.1.6+0" + +[[deps.Xorg_libXext_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] +git-tree-sha1 = "1a4a26870bf1e5d26cd585e38038d399d7e65706" +registries = "General" +uuid = "1082639a-0dae-5f34-9b06-72781eeb8cb3" +version = "1.3.8+0" + +[[deps.Xorg_libXfixes_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] +git-tree-sha1 = "75e00946e43621e09d431d9b95818ee751e6b2ef" +registries = "General" +uuid = "d091e8ba-531a-589c-9de9-94069b037ed8" +version = "6.0.2+0" + +[[deps.Xorg_libXi_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libXext_jll", "Xorg_libXfixes_jll"] +git-tree-sha1 = "704274ca960c42049fd9bda089fc4be32af5cdca" +registries = "General" +uuid = "a51aa0fd-4e3c-5386-b890-e753decda492" +version = "1.8.5+0" + +[[deps.Xorg_libXinerama_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libXext_jll"] +git-tree-sha1 = "0ba01bc7396896a4ace8aab67db31403c71628f4" +registries = "General" +uuid = "d1454406-59df-5ea1-beac-c340f2130bc3" +version = "1.1.7+0" + +[[deps.Xorg_libXrandr_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libXext_jll", "Xorg_libXrender_jll"] +git-tree-sha1 = "6c174ef70c96c76f4c3f4d3cfbe09d018bcd1b53" +registries = "General" +uuid = "ec84b674-ba8e-5d96-8ba1-2a689ba10484" +version = "1.5.6+0" + +[[deps.Xorg_libXrender_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] +git-tree-sha1 = "a54cf54677c9f6eac0d97e9d757c233b56bc21b9" +registries = "General" +uuid = "ea2f1a96-1ddc-540d-b46f-429655e07cfa" +version = "0.9.13+0" + +[[deps.Xorg_libpciaccess_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "58972370b81423fc546c56a60ed1a009450177c3" +registries = "General" +uuid = "a65dc6b1-eb27-53a1-bb3e-dea574b5389e" +version = "0.19.0+0" + +[[deps.Xorg_libxcb_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libXau_jll", "Xorg_libXdmcp_jll"] +git-tree-sha1 = "bfcaf7ec088eaba362093393fe11aa141fa15422" +registries = "General" +uuid = "c7cfdc94-dc32-55de-ac96-5a1b8d977c5b" +version = "1.17.1+0" + +[[deps.Xorg_libxkbfile_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] +git-tree-sha1 = "ed756a03e95fff88d8f738ebc2849431bdd4fd1a" +registries = "General" +uuid = "cc61e674-0454-545c-8b26-ed2c68acab7a" +version = "1.2.0+0" + +[[deps.Xorg_xcb_util_cursor_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_xcb_util_image_jll", "Xorg_xcb_util_jll", "Xorg_xcb_util_renderutil_jll"] +git-tree-sha1 = "9750dc53819eba4e9a20be42349a6d3b86c7cdf8" +registries = "General" +uuid = "e920d4aa-a673-5f3a-b3d7-f755a4d47c43" +version = "0.1.6+0" + +[[deps.Xorg_xcb_util_image_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_xcb_util_jll"] +git-tree-sha1 = "f4fc02e384b74418679983a97385644b67e1263b" +registries = "General" +uuid = "12413925-8142-5f55-bb0e-6d7ca50bb09b" +version = "0.4.1+0" + +[[deps.Xorg_xcb_util_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libxcb_jll"] +git-tree-sha1 = "68da27247e7d8d8dafd1fcf0c3654ad6506f5f97" +registries = "General" +uuid = "2def613f-5ad1-5310-b15b-b15d46f528f5" +version = "0.4.1+0" + +[[deps.Xorg_xcb_util_keysyms_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_xcb_util_jll"] +git-tree-sha1 = "44ec54b0e2acd408b0fb361e1e9244c60c9c3dd4" +registries = "General" +uuid = "975044d2-76e6-5fbe-bf08-97ce7c6574c7" +version = "0.4.1+0" + +[[deps.Xorg_xcb_util_renderutil_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_xcb_util_jll"] +git-tree-sha1 = "5b0263b6d080716a02544c55fdff2c8d7f9a16a0" +registries = "General" +uuid = "0d47668e-0667-5a69-a72c-f761630bfb7e" +version = "0.3.10+0" + +[[deps.Xorg_xcb_util_wm_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_xcb_util_jll"] +git-tree-sha1 = "f233c83cad1fa0e70b7771e0e21b061a116f2763" +registries = "General" +uuid = "c22f9ab0-d5fe-5066-847c-f4bb1cd4e361" +version = "0.4.2+0" + +[[deps.Xorg_xkbcomp_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libxkbfile_jll"] +git-tree-sha1 = "9a5e6e8f1a7c40941465c04840145e527f0d6b4b" +registries = "General" +uuid = "35661453-b289-5fab-8a00-3d9160c6a3a4" +version = "1.5.0+0" + +[[deps.Xorg_xkeyboard_config_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_xkbcomp_jll"] +git-tree-sha1 = "df77b22eb77051b3d0ef30aab979684f7482c66f" +registries = "General" +uuid = "33bec58e-1273-512f-9401-5d533626f822" +version = "2.48.0+0" + +[[deps.Xorg_xtrans_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "a63799ff68005991f9d9491b6e95bd3478d783cb" +registries = "General" +uuid = "c5fb5394-a638-5e4d-96e5-b29de1b5cf10" +version = "1.6.0+0" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.3.2+0" + +[[deps.Zstd_jll]] +deps = ["CompilerSupportLibraries_jll", "Libdl"] +uuid = "3161d3a3-bdf6-5164-811a-617609db77b4" +version = "1.5.7+1" + +[[deps.aws_c_auth_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "aws_c_cal_jll", "aws_c_http_jll", "aws_c_sdkutils_jll"] +git-tree-sha1 = "8cab83c96af80a1be968251ce1a0548a7545484d" +registries = "General" +uuid = "2b3700d1-4306-52e2-a478-c162f0c514be" +version = "0.9.6+0" + +[[deps.aws_c_cal_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "aws_c_common_jll"] +git-tree-sha1 = "22c0f42f4a1f0dc5dcfa8fd267c4ac407c455e7a" +registries = "General" +uuid = "70f11efc-bab2-57f1-b0f3-22aad4e67c4b" +version = "0.9.13+0" + +[[deps.aws_c_common_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "a759cb9bf456ad792cc7898a81ae333cce9ef02a" +registries = "General" +uuid = "73048d1d-b8c4-5092-a58d-866c5e8d1e50" +version = "0.12.6+0" + +[[deps.aws_c_compression_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "aws_c_common_jll"] +git-tree-sha1 = "7910c72f45f44afd297c39fe43b99c56d5ed22ec" +registries = "General" +uuid = "73a04cd5-f3d7-5bac-9290-e8adb709f224" +version = "0.3.2+0" + +[[deps.aws_c_http_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "aws_c_compression_jll", "aws_c_io_jll"] +git-tree-sha1 = "3fb8685778068de502c72fec5dd8075e037cee15" +registries = "General" +uuid = "3254fc65-9028-534d-aa9d-d76d128babc6" +version = "0.10.15+0" + +[[deps.aws_c_io_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "aws_c_cal_jll", "aws_c_common_jll", "s2n_tls_jll"] +git-tree-sha1 = "7e481d474b2087ee8bbf55b81bf9119f21e396d9" +registries = "General" +uuid = "13c41daa-f319-5298-b5eb-5754e0170d52" +version = "0.26.3+0" + +[[deps.aws_c_s3_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "aws_c_auth_jll", "aws_c_common_jll", "aws_c_http_jll", "aws_checksums_jll", "s2n_tls_jll"] +git-tree-sha1 = "3e9917ab25114feba657e71be41cad068b9f6595" +registries = "General" +uuid = "bd1f34fb-993f-5903-a121-aaf302eed6d4" +version = "0.11.5+0" + +[[deps.aws_c_sdkutils_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "aws_c_common_jll"] +git-tree-sha1 = "c43dfba2c1ab9ea9f02f2c80e86fa16f6460244e" +registries = "General" +uuid = "1282aa60-004d-510b-9f52-12498d409daa" +version = "0.2.4+1" + +[[deps.aws_checksums_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "aws_c_common_jll"] +git-tree-sha1 = "2570c8e23f4771a087b12a47edcaaa670ac05a01" +registries = "General" +uuid = "b2a88e68-78e7-5e94-8c20-c02986ec140e" +version = "0.2.10+0" + +[[deps.dlfcn_win32_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e141d67ffe550eadfb5af1bdbdaf138031e4805f" +registries = "General" +uuid = "c4b69c83-5512-53e3-94e6-de98773c479f" +version = "1.4.2+0" + +[[deps.eudev_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "c3b0e6196d50eab0c5ed34021aaa0bb463489510" +registries = "General" +uuid = "35ca27e7-8b34-5b7f-bca9-bdc33f59eb06" +version = "3.2.14+0" + +[[deps.fzf_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "b6a34e0e0960190ac2a4363a1bd003504772d631" +registries = "General" +uuid = "214eeab7-80f7-51ab-84ad-2988db7cef09" +version = "0.61.1+0" + +[[deps.libaec_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "60f4792734488db6f42e2c7699f1d4594780bd03" +registries = "General" +uuid = "477f73a3-ac25-53e9-8cc3-50b2fa2566f0" +version = "1.1.7+0" + +[[deps.libaom_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "0343a4dc329ca4dd71bf5c5b3fc1a8c2f6e0692d" +registries = "General" +uuid = "a4ae2306-e953-59d6-aa16-d00cac43593b" +version = "3.15.2+0" + +[[deps.libass_jll]] +deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "cb007192783c56d8249db4cf0e3495001edfe414" +registries = "General" +uuid = "0ac62f75-1d6f-5e53-bd7c-93b484bb37c0" +version = "0.17.5+0" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.15.0+0" + +[[deps.libdecor_jll]] +deps = ["Artifacts", "Dbus_jll", "JLLWrappers", "Libdl", "Libglvnd_jll", "Pango_jll", "Wayland_jll", "xkbcommon_jll"] +git-tree-sha1 = "9bf7903af251d2050b467f76bdbe57ce541f7f4f" +registries = "General" +uuid = "1183f4f0-6f2a-5f1a-908b-139f9cdfea6f" +version = "0.2.2+0" + +[[deps.libdrm_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libpciaccess_jll"] +git-tree-sha1 = "28e57478e8a160d346a19c28b3fffb9273bcc9c2" +registries = "General" +uuid = "8e53e030-5e6c-5a89-a30b-be5b7263a166" +version = "2.4.134+0" + +[[deps.libevdev_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "56d643b57b188d30cccc25e331d416d3d358e557" +registries = "General" +uuid = "2db6ffa8-e38f-5e21-84af-90c45d0032cc" +version = "1.13.4+0" + +[[deps.libfdk_aac_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "646634dd19587a56ee2f1199563ec056c5f228df" +registries = "General" +uuid = "f638f0a6-7fb0-5443-88ba-1cc74229b280" +version = "2.0.4+0" + +[[deps.libinput_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "eudev_jll", "libevdev_jll", "mtdev_jll"] +git-tree-sha1 = "91d05d7f4a9f67205bd6cf395e488009fe85b499" +registries = "General" +uuid = "36db933b-70db-51c0-b978-0f229ee0e533" +version = "1.28.1+0" + +[[deps.libpng_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "1fcd6cf05d23adab0b5ffc496d020537215751dc" +registries = "General" +uuid = "b53b4c65-9356-5827-b1ea-8c7a1a84506f" +version = "1.6.59+1" + +[[deps.libva_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll", "Xorg_libXext_jll", "Xorg_libXfixes_jll", "libdrm_jll"] +git-tree-sha1 = "21cbc8fc2ac0bb182ed461e556d9c062ae6a3164" +registries = "General" +uuid = "9a156e7d-b971-5f62-b2c9-67348b8fb97c" +version = "2.24.1+0" + +[[deps.libvorbis_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Ogg_jll"] +git-tree-sha1 = "11e1772e7f3cc987e9d3de991dd4f6b2602663a5" +registries = "General" +uuid = "f27f6e37-5d2b-51aa-960f-b287f2bc3b7a" +version = "1.3.8+0" + +[[deps.mpif_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "MPIABI_jll", "MPICH_jll", "MPIPreferences", "MPItrampoline_jll", "MicrosoftMPI_jll", "OpenMPI_jll", "TOML"] +git-tree-sha1 = "52e322f7a6d418576cdeb043dd2a7f7ad9a8abd0" +registries = "General" +uuid = "9aeb927a-4695-514f-a259-621a69f20ec0" +version = "1.0.1+0" + +[[deps.mtdev_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "b4d631fd51f2e9cdd93724ae25b2efc198b059b1" +registries = "General" +uuid = "009596ad-96f7-51b1-9f1b-5ce2d5e8a71e" +version = "1.1.7+0" + +[[deps.nghttp2_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.70.0+0" + +[[deps.oneTBB_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ed2d8d4ad96c03d3abe3382cdbbdea9489b63636" +registries = "General" +uuid = "1317d2d5-d96f-522e-a858-c73665f53c3e" +version = "2023.1.0+0" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.8.3+0" + +[[deps.s2n_tls_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6f9611b1b99beb089154f19a4031579f3a818cbd" +registries = "General" +uuid = "cddc5d3d-934d-5d3a-9747-62fc12ea3f48" +version = "1.7.12+0" + +[[deps.x264_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "14cc7083fc6dff3cc44f2bc435ee96d06ed79aa7" +registries = "General" +uuid = "1270edf5-f2f9-52d2-97e9-ab00b5d0237a" +version = "10164.0.1+0" + +[[deps.x265_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e7b67590c14d487e734dcb925924c5dc43ec85f3" +registries = "General" +uuid = "dfaa095f-4041-5dcd-9319-2fabd8486b76" +version = "4.1.0+0" + +[[deps.xkbcommon_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libxcb_jll", "Xorg_xkeyboard_config_jll"] +git-tree-sha1 = "a1fc6507a40bf504527d0d4067d718f8e179b2b8" +registries = "General" +uuid = "d8fb68d0-12a3-5cfd-a85a-d49703b185fd" +version = "1.13.0+0" + +[registries.General] +url = "https://github.com/JuliaRegistries/General.git" +uuid = "23338594-aafe-5451-b93e-139f81909106" diff --git a/ci/manifests/README.md b/ci/manifests/README.md index 68255855e..63de45514 100644 --- a/ci/manifests/README.md +++ b/ci/manifests/README.md @@ -14,12 +14,64 @@ an unpinned resolve makes every run non-reproducible and quietly wastes time: minor version into `Manifest.toml` before building. The copy exists only inside the CI runner and never reaches a developer's working tree. +## Compilation caches + +CI uses `JULIA_CPU_TARGET=generic` for portable package images across runner CPUs of the same +architecture. The production depot and source-cache keys record the optimization and bounds-checking +settings, so incompatible images are not restored. Existing production caches remain reusable. + +CI restores the dependency depot first, then overlays GPEC's compiled package directory from a +smaller cache keyed by Julia version, runner architecture, dependency pins, source contents, and +build settings. Cache writes have a run-specific suffix to avoid stale reservations; restores +match the compatible prefix. A compatible snapshot is reused without saving another copy. +Missing or incompatible snapshots are refreshed after successful compilation. Cache saves are +best-effort and limited to three minutes, so a stalled upload cannot block the workflow indefinitely. + +For each Julia version, a production precompile job prepares the environment before releasing +three parallel test groups (`core`, `api`, `errorfields`). On hosted runners it uploads a one-day +workflow artifact containing the resolved manifest and a compressed depot archive. Test groups +first try the compatible depot and exact source-image caches. When either is missing or its restore +fails, they restore the artifact into a fresh depot, preserving permissions and symlinks through tar +and avoiding partially restored read-only files. Its `JULIA_DEPOT_PATH` keeps a trailing `:` to retain +Julia's bundled depots. The small manifest +artifact is always restored. Cache availability therefore affects speed rather than correctness: +a reservation failure or eviction cannot invalidate the job handoff. Artifact publication is required +for precompile to pass. The two Julia versions progress independently. +Cold compilation is paid once per version; warm runs reuse the existing production images. + +Test jobs use optimization level 1 to reduce first-use compilation. Julia can still reuse cached +package images built at level 2; the production build job keeps that default optimization level. +Only the test orchestration modules disable optimization entirely. + +Bounds checking remains enabled. A source change still requires compiling a new GPEC image; +the source cache helps subsequent runs of that source, not the first build. Cache eviction or a +new Julia version likewise requires rebuilding. The test runner logs elapsed and compilation +seconds per file to distinguish this startup cost from work inside the tests. + +## Local cache on self-hosted runners + +Set the repository variable `GPEC_LOCAL_CACHE_DIR` to a shared directory on the runner host. +On self-hosted runners this replaces GitHub cache and environment-artifact transfers with local +snapshots keyed by the exact Julia version, dependencies, source, architecture, and build flags. +Hosted runners continue using GitHub storage. + +The precompile job copies its depot and resolved manifest into a staging directory, then publishes +the complete snapshot with an atomic rename. A lock serializes publishers. Test jobs copy from +that immutable snapshot into their private depots, so concurrent jobs do not write shared images. +An absent test snapshot fails the handoff. Existing snapshots are reused between workflow runs; +obsolete snapshots can be removed when no jobs need them. Snapshots use reflinks when supported. + +All runners eligible for these jobs must have access to the configured directory. On +`pharr-desktop` it is `/home/pharr/Projects/github/julia-cache`; each new runner has its own home +and depot. Unset the variable to return to GitHub storage. + ## Files | File | Purpose | | --- | --- | | `Manifest-v1.11.toml` | Dependency set for the `1.11` matrix job | -| `Manifest-v1.12.toml` | Dependency set for the `1.x` matrix job | +| `Manifest-v1.12.toml` | Dependency set for local Julia 1.12 runs | +| `Manifest-v1.13.toml` | Dependency set for the `1.x` matrix job | | `project.sha256` | `Project.toml` checksum when the pins were generated | | `update.jl` | Regenerates the above | @@ -31,6 +83,7 @@ repository: ```bash julia +1.11 ci/manifests/update.jl julia +1.12 ci/manifests/update.jl +julia +1.13 ci/manifests/update.jl ``` Each run resolves a bare copy of `Project.toml` in a temporary directory, so your diff --git a/ci/manifests/update.jl b/ci/manifests/update.jl index c094343c3..ad204f587 100644 --- a/ci/manifests/update.jl +++ b/ci/manifests/update.jl @@ -6,6 +6,7 @@ anywhere: julia +1.11 ci/manifests/update.jl julia +1.12 ci/manifests/update.jl + julia +1.13 ci/manifests/update.jl Each run resolves `Project.toml` for the running Julia version and writes `ci/manifests/Manifest-v..toml`, then refreshes diff --git a/docs/development/git-workflow.md b/docs/development/git-workflow.md index cb3f82f7f..163f550aa 100644 --- a/docs/development/git-workflow.md +++ b/docs/development/git-workflow.md @@ -37,6 +37,23 @@ A change that builds on another unmerged pull request can be opened against that CI runs the test suite on every pull request whatever its base. While the base is another feature branch, the harness stamp stays current until this pull request's own `src/` changes differ from those at the stamped commit, so merging an updated parent in does not invalidate it. Once retargeted to `develop`, the usual check applies: nothing under `src/` may differ from the stamped commit. Because the check compares file contents, a report taken on top of the final parent survives the retarget unless `develop` has since gained other `src/` changes. +## Merge queue + +The `Tests` and `Documentation` workflows handle `merge_group: checks_requested` as well as +pull requests. Queue candidates run the full test battery and build documentation; they do not +deploy documentation. Each queue ref has its own concurrency group. PR conventions remain on +pull-request events because they validate the PR title, body, and regression stamp. + +After these workflows have landed on `develop`, an administrator can enable **Require merge +queue** on its exact branch protection rule. Keep `Tests` and `Documentation` required, retain +at least one human approval, select **merge commits**, and start with build concurrency **1**. +Keep **Only merge non-failing pull requests** enabled. Adding a PR to the queue still requires +human review; queue checks validate it together with the target branch and earlier queued PRs. +The queue does not resolve textual merge conflicts. + +Workflow support does not enable the repository setting. Validate the first actual queue build +when enabling it; a normal PR run cannot exercise GitHub's synthetic merge-group event. + ## Hotfix Workflow Hotfixes address critical bugs in production (`main`) that cannot wait for the next release cycle: diff --git a/docs/make.jl b/docs/make.jl index 6fb5a3ed5..8b5fe99db 100644 --- a/docs/make.jl +++ b/docs/make.jl @@ -41,16 +41,19 @@ makedocs(; "Tearing" => "inner_layer.md", "Analysis" => "analysis.md", "Utilities" => "utilities.md" - ], + ], "Citations" => "citations.md", - "Developer Notes" => "developer_notes.md", + "Developer Notes" => "developer_notes.md" ], checkdocs=:exports ) -deploydocs(; - repo="github.com/OpenFUSIONToolkit/GPEC.git", - branch="gh-pages", - devbranch="develop", - push_preview=true -) +# Queue candidates validate the build; previews and published docs come from PRs and pushes. +if get(ENV, "GITHUB_EVENT_NAME", "") != "merge_group" + deploydocs(; + repo="github.com/OpenFUSIONToolkit/GPEC.git", + branch="gh-pages", + devbranch="develop", + push_preview=true + ) +end diff --git a/src/KineticForces/Torque.jl b/src/KineticForces/Torque.jl index bf1a3025e..9cf9d200f 100644 --- a/src/KineticForces/Torque.jl +++ b/src/KineticForces/Torque.jl @@ -60,7 +60,7 @@ function tpsi!(tpsi_var::Ref{ComplexF64}, psi::Float64, n::Int, l::Int, # bundle across the bounce harmonics of a surface. surf = surface === nothing ? _torque_surface(psi, zi, mi, electron, method, equil, intr, kinetic_profiles; - need_matrices=!isnothing(op_wmats), n, wdfac, divxfac) : + need_matrices=(!isnothing(op_wmats)), n, wdfac, divxfac) : surface (; chrg, mass, tspl, bmax, bmin, q, n_s, T_s, welec, wdian, wdiat, wtran, wgyro, nuk, epsr, dVdpsi, dbob_m_f, divx_m_f) = surf wbhat = (π / 4) * sqrt(epsr / 2) * wtran @@ -482,6 +482,11 @@ function _setup_surface_state( djdpsi_vals[i+1] = equil.rzphi_jac(pt; deriv=DerivOp(1, 0), hint=hJ) / intr.chi1^2 end + # The repeated periodic endpoint must match exactly, including sampled derivatives. + for values in (B_vals, dBdpsi_vals, dBdtheta_vals, jac_vals, djdpsi_vals) + values[end] = values[1] + end + tspl = cubic_interp(xs, Series(hcat(B_vals, dBdpsi_vals, dBdtheta_vals, jac_vals, djdpsi_vals)); bc=PeriodicBC()) # Periodic cubic of B for v_par and bounce points (Fortran vspl equivalent); 1−(λ/bo)B # is periodic on the closed θ interval, so a non-periodic fit would break at the seam. diff --git a/test/runtests.jl b/test/runtests.jl index 7e3253182..bc7263af4 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1,3 +1,8 @@ +module GPECTests + +# Test orchestration needs little optimization; imported package kernels retain their defaults. +Base.Experimental.@optlevel 0 + using Test using Pkg using GeneralizedPerturbedEquilibrium.Vacuum @@ -14,68 +19,26 @@ using LinearAlgebra Pkg.activate(joinpath(@__DIR__, "..")) using GeneralizedPerturbedEquilibrium -# Check if specific test files are requested via ARGS -if !isempty(ARGS) - for testfile in ARGS - @info "Running test file: $testfile" - include(testfile) - end -else - include("./runtests_utilities.jl") - include("./runtests_fouriertransforms.jl") - include("./runtests_vacuum.jl") - include("./runtests_equil.jl") - include("./runtests_sfl_sampling.jl") - include("./runtests_grid_refinement.jl") - include("./runtests_core_capped_knots.jl") - include("./runtests_coordinate_invariant.jl") - include("./runtests_eulerlagrange.jl") - include("./runtests_riccati.jl") - include("./runtests_galerkin.jl") - include("./runtests_parallel_integration.jl") - include("./runtests_result_struct.jl") - include("./runtests_solve_api.jl") - include("./runtests_galerkin_cholesky.jl") - include("./runtests_matching_models.jl") - include("./runtests_dominant_coupling.jl") - include("./runtests_error_fields.jl") - include("./runtests_tolerance_toml.jl") - include("./runtests_sampling.jl") - include("./runtests_monte_carlo.jl") - include("./runtests_risk.jl") - include("./runtests_phasing.jl") - include("./runtests_ntv_limits.jl") - include("./runtests_sing.jl") - include("./runtests_innerlayer.jl") - include("./runtests_tj_analytic.jl") - include("./runtests_kinetic_profiles.jl") - include("./runtests_resist_eval.jl") - include("./runtests_localstability.jl") - include("./runtests_analysis_plots.jl") - include("./runtests_slayer_params.jl") - include("./runtests_slayer_riccati.jl") - include("./runtests_slayer_inputs.jl") - include("./runtests_layer_overlap_fitzpatrick.jl") - include("./runtests_dispersion_residual.jl") - include("./runtests_dispersion_coupled.jl") - include("./runtests_dispersion_coupled_full.jl") - include("./runtests_dispersion_rotation.jl") - include("./runtests_dispersion_scan.jl") - include("./runtests_dispersion_amr.jl") - include("./runtests_dispersion_polish.jl") - include("./runtests_slayer_profile_transport.jl") - include("./runtests_dispersion_winding.jl") - include("./runtests_dispersion_ggj.jl") - include("./runtests_slayer_runner.jl") - include("./runtests_critical_resonant_field.jl") - include("./runtests_kinetic.jl") - include("./runtests_kinetic_validity.jl") - include("./runtests_multiion.jl") - include("./runtests_fullruns.jl") - include("./runtests_torque_response.jl") - include("./runtests_coils.jl") - include("./runtests_imas.jl") - include("./runtests_rerun_from_h5.jl") - include("./runtests_frozen_equilibrium.jl") - include("./runtests_h5_schema.jl") +function run_test_file(testfile) + @info "Running test file" testfile + measurement = @timed include(testfile) + @info "Completed test file" testfile elapsed_seconds=measurement.time compile_seconds=measurement.compile_time recompile_seconds=measurement.recompile_time + return nothing +end + +include("suites.jl") + +# Fail if a new test file is omitted or accidentally assigned to multiple groups. +registered = first.(TEST_SUITES) +discovered = filter(f -> startswith(f, "runtests_") && endswith(f, ".jl"), readdir(@__DIR__)) +length(unique(registered)) == length(registered) || error("Duplicate test file in suites.jl") +Set(registered) == Set(discovered) || error("Update test/suites.jl to cover every runtests_*.jl file") + +group = get(ENV, "GPEC_TEST_GROUP", "") +isempty(group) || group in last.(TEST_SUITES) || error("Unknown GPEC_TEST_GROUP: $group") +selected = isempty(ARGS) ? [file for (file, suite) in TEST_SUITES if isempty(group) || suite == group] : ARGS +for testfile in selected + run_test_file(testfile) +end + end diff --git a/test/runtests_coils.jl b/test/runtests_coils.jl index f5fde2f38..cebb8aeb2 100644 --- a/test/runtests_coils.jl +++ b/test/runtests_coils.jl @@ -739,7 +739,7 @@ end open(flipped, "w") do io for (i, l) in enumerate(lines) if i == 4 # header line 4 starts with the plasma current - vals = [l[j:min(j + 15, end)] for j in 1:16:length(l)] + vals = [l[j:min(j+15, end)] for j in 1:16:length(l)] cur = -parse(Float64, strip(vals[1])) l = @sprintf("%16.9E", cur) * l[17:end] end diff --git a/test/runtests_error_fields.jl b/test/runtests_error_fields.jl index 860c9ff9f..a4a7c41f2 100644 --- a/test/runtests_error_fields.jl +++ b/test/runtests_error_fields.jl @@ -1,3 +1,10 @@ +module ErrorFieldsTests + +# Avoid optimizing test orchestration; physics kernels keep their own compilation settings. +Base.Experimental.@optlevel 0 + +using Test +using GeneralizedPerturbedEquilibrium using HDF5 using TOML using LinearAlgebra @@ -80,11 +87,16 @@ include("h5_metadata_check.jl") cp(joinpath(@__DIR__, "test_data", "ErrorFields", "tolerances_two_hoops.toml"), joinpath(dir, "tolerances.toml")) # Kinetic profiles consistent with this Solovev pressure, for the NTV torque couplings. cp(joinpath(@__DIR__, "..", "examples", "Solovev_kinetic_NTV_example", "kinetic.dat"), joinpath(dir, "kinetic.dat")) - inputs["KineticForces"] = Dict{String,Any}("kinetic_file" => "kinetic.dat", "verbose" => false, "write_outputs_to_HDF5" => true) + # Exercise the kinetic pipeline at smoke-test precision, retaining all bounce harmonics. + inputs["KineticForces"] = Dict{String,Any}( + "kinetic_file" => "kinetic.dat", "verbose" => false, "write_outputs_to_HDF5" => true, + "rtol_psi" => 0.2, "rtol_pitch" => 1e-2, "atol_pitch" => 1e-5, + "rtol_x" => 1e-3, "atol_x" => 1e-6) + # Small batches exercise orchestration; distribution accuracy is tested on synthetic inputs. inputs["ErrorFields"] = Dict{String,Any}("verbose" => false, "tolerance_file" => "tolerances.toml", - "MonteCarlo" => Dict{String,Any}("nsample" => 20_000, "nbatch" => 2, "seed" => 5, "nbins" => 100), + "MonteCarlo" => Dict{String,Any}("nsample" => 512, "nbatch" => 2, "seed" => 5, "nbins" => 16), "scenario" => Dict{String,Any}("n_e" => 12.0), - "Risk" => Dict{String,Any}("nsample_threshold" => 20_000, "seed" => 3, "scan_scales" => [0.5, 1.0, 2.0]), + "Risk" => Dict{String,Any}("nsample_threshold" => 512, "seed" => 3, "scan_scales" => [0.5, 1.0, 2.0]), # The smallest rotation scan that exercises the table path (three shifts, no refinement). "NTV" => Dict{String,Any}("efc_coils" => ["hoop_efc"], "rotation_scan_points" => 3, "rotation_scan_max_points" => 3)) open(io -> TOML.print(io, inputs), toml_path, "w") @@ -180,7 +192,7 @@ include("h5_metadata_check.jl") # The run's Monte Carlo (full window, dominant mode) is written and re-runnable from the file. mc = res.monte_carlo @test mc isa EF.MonteCarloResult - @test mc.nsample == 20_000 && mc.nbatch == 2 && mc.seed == 5 + @test mc.nsample == 512 && mc.nbatch == 2 && mc.seed == 5 @test mc.abs_delta_total_as_designed ≈ abs(sum(ef_table.delta_as_designed)) @test !(mc.abs_delta_total_as_designed ≈ abs(sum(table.delta_as_designed))) # A tolerance on the excluded array is an error, in each of the three places a name can appear. @@ -190,10 +202,10 @@ include("h5_metadata_check.jl") @test sum(mc.abs_delta_pdf .* diff(mc.abs_delta_bin_edges)) ≈ 1 atol = 1e-6 @test mc.abs_delta_efc_sampled_mean < mc.abs_delta_sampled_mean mc_file = EF.MonteCarloResult(h5path) - @test mc_file.abs_delta_pdf == mc.abs_delta_pdf && mc_file.abs_delta_bin_edges == mc.abs_delta_bin_edges && mc_file.nsample == 20_000 - rerun = EF.run_monte_carlo(h5path; nsample=20_000, nbatch=2, seed=5, nbins=100) + @test mc_file.abs_delta_pdf == mc.abs_delta_pdf && mc_file.abs_delta_bin_edges == mc.abs_delta_bin_edges && mc_file.nsample == 512 + rerun = EF.run_monte_carlo(h5path; nsample=512, nbatch=2, seed=5, nbins=16) @test rerun.abs_delta_pdf == mc.abs_delta_pdf - windowed_mc = EF.run_monte_carlo(h5path; psi_low=rc.rational_psi[end], nsample=5_000, nbatch=1, seed=5, nbins=50) + windowed_mc = EF.run_monte_carlo(h5path; psi_low=rc.rational_psi[end], nsample=256, nbatch=1, seed=5, nbins=16) @test windowed_mc.abs_delta_total_as_designed ≈ abs(sum(EF.without_coils(windowed, ["hoop_efc"]).delta_as_designed)) # Locking risk and tolerance scan: written, bounded, and reproducible from the file. @@ -217,24 +229,25 @@ include("h5_metadata_check.jl") # distribution built to straddle a threshold. @test risk.locking_probability_percent == 0 @test scan.locking_probability_percent[2] ≈ risk.locking_probability_percent rtol = 1e-12 # the scale-1 point is the run's own Monte Carlo - again = EF.locking_risk(h5path; n_e=12.0, nsample=20_000, nbatch=2, seed=5, nbins=100, - risk_ctrl=EF.RiskControl(; nsample_threshold=20_000, seed=3)) + again = EF.locking_risk(h5path; n_e=12.0, nsample=512, nbatch=2, seed=5, nbins=16, + risk_ctrl=EF.RiskControl(; nsample_threshold=512, seed=3)) @test again.locking_probability_percent == risk.locking_probability_percent # The scan's own file entry point at unit scale is that same re-run. - rescan = EF.tolerance_scan(h5path; scales=[1.0], n_e=12.0, nsample=20_000, nbatch=2, seed=5, nbins=100, - risk_ctrl=EF.RiskControl(; nsample_threshold=20_000, seed=3)) + rescan = EF.tolerance_scan(h5path; scales=[1.0], n_e=12.0, nsample=512, nbatch=2, seed=5, nbins=16, + risk_ctrl=EF.RiskControl(; nsample_threshold=512, seed=3)) @test rescan.tolerance_scale == [1.0] @test rescan.locking_probability_percent[1] == again.locking_probability_percent @test rescan.locking_probability_efc_percent[1] == again.locking_probability_efc_percent - # Analysis plots: every ErrorFields plot renders from the file and saves; the phasing map - # of the two hoops is the closed form on their stored spectra. + # Construct every plot; render representative bar, contour, polar, and composite layouts. AEF = GPEC.Analysis.ErrorFields for (name, fn) in (("sens", AEF.plot_coil_sensitivities), ("abs_delta_pdf", AEF.plot_tolerance_pdf), ("risk", AEF.plot_locking_risk), ("thr", AEF.plot_threshold_scaling), ("mode", AEF.plot_dominant_mode_spectrum)) png = joinpath(dir, "plot_$name.png") - @test fn(h5path; save_path=png) isa Plots.Plot - @test isfile(png) + @test fn(h5path; save_path=name == "sens" ? png : nothing) isa Plots.Plot + if name == "sens" + @test isfile(png) + end end # The spectrum plot draws the stored dominant mode, padded to zero at both ends by the step convention. spec = AEF.plot_dominant_mode_spectrum(h5path) @@ -254,8 +267,8 @@ include("h5_metadata_check.jl") # The threshold plot needs the overlap distribution and the penetration threshold, which # live on two different result types. A lone RiskResult cannot supply the distribution, # so it must be skipped rather than indexed into a missing field; the pair must work. - @test AEF.plot_threshold_scaling(["pair" => (mc, risk)]) isa Plots.Plot paired = AEF.plot_threshold_scaling(["pair" => (mc, risk)]) + @test paired isa Plots.Plot @test !isempty(paired.series_list) @test AEF.plot_threshold_scaling(["risk only" => risk]) isa Plots.Plot @test isequal(AEF.plot_threshold_scaling(["f" => h5path]).series_list[1][:y], @@ -268,8 +281,11 @@ include("h5_metadata_check.jl") for (name, fn) in (("spectra", AEF.plot_applied_spectra), ("contrib", AEF.plot_overlap_contributions), ("surface", AEF.plot_surface_overlay)) png = joinpath(dir, "diag_$name.png") - @test fn(ctx_plot, ovs_plot; save_path=png) isa Plots.Plot - @test isfile(png) + kwargs = name == "surface" ? (; ntheta=32, nzeta=24, save_path=png) : (;) + @test fn(ctx_plot, ovs_plot; kwargs...) isa Plots.Plot + if name == "surface" + @test isfile(png) + end end @test AEF.plot_applied_spectra(h5path, plot_sets) isa Plots.Plot @test AEF.plot_applied_spectra(ctx_plot, ovs_plot; normalize=false)[1][:yaxis][:guide] == "|b̃| (T)" @@ -322,8 +338,7 @@ include("h5_metadata_check.jl") small = EF.linearity_check(ctx_plot, plot_sets, snapshot; scales=(1e-2,)) @test maximum(filter(!isnan, small.relative_error)) < maximum(finite) @test_throws ArgumentError EF.linearity_check(ctx_plot, plot_sets, snapshot; scales=(0.0,)) - @test AEF.plot_linearity_check(lin; save_path=joinpath(dir, "linearity_check.png")) isa Plots.Plot - @test isfile(joinpath(dir, "linearity_check.png")) + @test AEF.plot_linearity_check(lin) isa Plots.Plot @test AEF.plot_linearity_residuals(h5path; at=:step, yscale=:log10) isa Plots.Plot @test_throws ArgumentError AEF.plot_linearity_residuals(h5path; yscale=:bogus) @@ -388,14 +403,14 @@ include("h5_metadata_check.jl") @test_throws ArgumentError AEF.plot_coil_sensitivities(h5path; coils=["hoop_tilted", "no_such_coil"]) @test_throws ArgumentError AEF.plot_coil_sensitivities(ovs_plot; quantity=:shift) # On a logarithmic axis the values are stems and markers, never bars. - stems = AEF.plot_coil_sensitivities(h5path; yscale=:log10, save_path=joinpath(dir, "stems.png")) + stems = AEF.plot_coil_sensitivities(h5path; yscale=:log10) @test stems[1][:yaxis][:scale] === :log10 @test all(st[:seriestype] in (:path, :scatter) for st in stems.series_list) @test AEF.plot_coil_sensitivities(h5path; quantity=:as_designed, yscale=:log10) isa Plots.Plot # The head-to-tail phasor walk ends at the coherent as-designed total the Monte Carlo # starts from; the tilted hoop carries the whole n=1 overlap and the axisymmetric one none. - phasors = AEF.plot_overlap_phasors(h5path; save_path=joinpath(dir, "phasors.png")) + phasors = AEF.plot_overlap_phasors(h5path) @test phasors isa Plots.Plot @test abs(sum(AEF._load(h5path).delta_as_designed[1:2])) ≈ mc.abs_delta_total_as_designed rtol = 1e-10 @test length(AEF.plot_overlap_phasors(["file" => h5path, "memory" => table]).subplots) == 2 @@ -421,16 +436,16 @@ include("h5_metadata_check.jl") from_file = EF.worst_case_terms(h5path) @test from_file.abs_delta_worst_case ≈ mc.abs_delta_worst_case rtol = 1e-10 @test EF.worst_case_terms(table, snapshot, plot_sets; tolerance_scale=2.0).abs_delta_shift_tolerance[i_axi] > terms.abs_delta_shift_tolerance[i_axi] - budget = AEF.plot_tolerance_budget(h5path; save_path=joinpath(dir, "budget.png")) - @test budget isa Plots.Plot && isfile(joinpath(dir, "budget.png")) + budget = AEF.plot_tolerance_budget(h5path) + @test budget isa Plots.Plot @test AEF.plot_tolerance_budget(table, snapshot, plot_sets; monte_carlo=mc, sort=:name) isa Plots.Plot @test AEF.plot_tolerance_budget(terms; top=1, sort=:none) isa Plots.Plot @test_throws ArgumentError AEF.plot_tolerance_budget(terms; sort=:bogus) # Linearity residuals: at the tolerance each tap is the stored ratio scaled by # tolerance / step, with the metres tilt of the tilted hoop converted through its radius. - lin_step = AEF.plot_linearity_residuals(h5path; at=:step, save_path=joinpath(dir, "linearity.png")) - @test lin_step isa Plots.Plot && isfile(joinpath(dir, "linearity.png")) + lin_step = AEF.plot_linearity_residuals(h5path; at=:step) + @test lin_step isa Plots.Plot @test AEF.plot_linearity_residuals(h5path) isa Plots.Plot @test AEF.plot_linearity_residuals(sens; at=:step) isa Plots.Plot @test AEF.plot_linearity_residuals(sens; tolerances=snapshot, fd_step_shift_m=1e-3, fd_step_tilt_deg=0.1) isa Plots.Plot @@ -459,7 +474,7 @@ include("h5_metadata_check.jl") kat = sens.winding_multiplier .* sens.peak_current ./ 1e3 δ_each = [dot(dom.right_singular_vectors[:, 1], sens.field_as_designed[:, j]) / kat[j] / sens.b_t0 for j in 1:2] @test pmap.delta_per_kat ≈ abs.(δ_each[1] .+ δ_each[2] .* cis.(deg2rad.(pmap.phase_deg[1]))) - @test AEF.plot_phasing_map(pmap; save_path=joinpath(dir, "phasing.png")) isa Plots.Plot + @test AEF.plot_phasing_map(pmap) isa Plots.Plot @test AEF.plot_phasing_map(h5path, ["hoop_tilted", "hoop_axi"]; nphase=12) isa Plots.Plot from_file = EF.CoilSensitivities(h5path) @test from_file.coil_names == sens.coil_names @@ -478,10 +493,10 @@ include("h5_metadata_check.jl") rebuilt = GPEC.equilibrium_from_h5(h5path) @test rebuilt.psilim == ffs.psilim @test rebuilt.equil.params.bt0 ≈ ffs.equil.params.bt0 - post_hoc = EF.compute_coil_sensitivities(h5path, sets) - @test post_hoc.field_as_designed ≈ sens.field_as_designed rtol = 1e-10 - @test post_hoc.shift_sensitivity_per_m ≈ sens.shift_sensitivity_per_m rtol = 1e-10 - @test post_hoc.tilt_sensitivity_per_deg ≈ sens.tilt_sensitivity_per_deg rtol = 1e-10 + post_hoc = EF.compute_coil_sensitivities(h5path, sets[1:1]) + @test post_hoc.field_as_designed ≈ sens.field_as_designed[:, 1:1] rtol = 1e-10 + @test post_hoc.shift_sensitivity_per_m ≈ sens.shift_sensitivity_per_m[:, :, 1:1] rtol = 1e-10 + @test post_hoc.tilt_sensitivity_per_deg ≈ sens.tilt_sensitivity_per_deg[:, :, 1:1] rtol = 1e-10 # Correction-coil couplings: the third hoop as the correction array. Its overlap per kAt is # the table's nominal overlap over its ampere-turns; the residual field carries no dominant @@ -526,7 +541,7 @@ include("h5_metadata_check.jl") @test AEF.plot_needed_current(mc, src_efc; coupling=c, delta_threshold=risk.threshold_fit, torque_budget=1.0) isa Plots.Plot @test_throws ArgumentError AEF.plot_needed_current(mc, src_efc; coupling=c) @test length(curve.delta_ef) == 500 && all(curve.current_linear .>= 0) - ntv_plot = GPEC.Analysis.ErrorFields.plot_efc_ntv_limits(h5path; torque_budget=1.0, save_path=joinpath(dir, "ntv.png")) + ntv_plot = GPEC.Analysis.ErrorFields.plot_efc_ntv_limits(h5path; torque_budget=1.0) @test length(ntv_plot.series_list) >= 2 # the single-mode and NTV-limited currents @test length(ntv_plot.subplots) == 2 # the scan adds the torque-against-rotation panel with_profiles = GPEC.Analysis.ErrorFields.plot_efc_ntv_limits(h5path; torque_budget=1.0, profiles=true) @@ -536,15 +551,15 @@ include("h5_metadata_check.jl") @test_throws ErrorException GPEC.efc_couplings(pe.response, sets, rc, dom, cfg, GPEC.KineticForces.KineticForcesControl(), nothing) # Central differences: doubling the step moves the derivatives at O(h²). - coarse = EF.compute_coil_sensitivities(sets, rc, ffs.equil, cfg, + coarse = EF.compute_coil_sensitivities(sets[1:1], rc, ffs.equil, cfg, EF.ErrorFieldsControl(; fd_step_shift_m=2e-3, fd_step_tilt_deg=0.2); psi=ffs.psilim, b_t0=sens.b_t0) - @test coarse.shift_sensitivity_per_m ≈ sens.shift_sensitivity_per_m rtol = 1e-4 - @test coarse.tilt_sensitivity_per_deg ≈ sens.tilt_sensitivity_per_deg rtol = 1e-3 + @test coarse.shift_sensitivity_per_m ≈ sens.shift_sensitivity_per_m[:, :, 1:1] rtol = 1e-4 + @test coarse.tilt_sensitivity_per_deg ≈ sens.tilt_sensitivity_per_deg[:, :, 1:1] rtol = 1e-3 # Single-conductor sets: the set pivot is the conductor pivot. - set_pivot = EF.compute_coil_sensitivities(sets, rc, ffs.equil, cfg, + set_pivot = EF.compute_coil_sensitivities(sets[1:1], rc, ffs.equil, cfg, EF.ErrorFieldsControl(; rotation_center="set"); psi=ffs.psilim, b_t0=sens.b_t0) - @test set_pivot.tilt_sensitivity_per_deg ≈ sens.tilt_sensitivity_per_deg rtol = 1e-10 + @test set_pivot.tilt_sensitivity_per_deg ≈ sens.tilt_sensitivity_per_deg[:, :, 1:1] rtol = 1e-10 # The one-call overlap path. Built in memory from the same coupling the table used, so # the comparison is exact rather than up to an SVD phase. @@ -648,3 +663,5 @@ include("h5_metadata_check.jl") end end end + +end diff --git a/test/runtests_fullruns.jl b/test/runtests_fullruns.jl index 5ca37c868..e26d9531e 100644 --- a/test/runtests_fullruns.jl +++ b/test/runtests_fullruns.jl @@ -4,12 +4,6 @@ using TOML # Run GeneralizedPerturbedEquilibrium.main on the provided example directories and assert it completes without throwing. @testset "Full ForceFreeStates runs" begin ex1 = joinpath(@__DIR__, "test_data", "regression_solovev_ideal_example") - @info "Running Solovev ideal example" - @test begin - GeneralizedPerturbedEquilibrium.main([ex1]) - true - end - # A renorm_threshold reduction landing just before an ideal crossing must not change which solution the crossing removes. @info "Running Solovev ideal example with frequent Gaussian reductions" @testset "et[1] is independent of the reduction frequency" begin diff --git a/test/runtests_localstability.jl b/test/runtests_localstability.jl index 7ee46667e..79c2de2c5 100644 --- a/test/runtests_localstability.jl +++ b/test/runtests_localstability.jl @@ -81,9 +81,10 @@ using TOML open(io -> TOML.print(io, inputs), toml_path, "w") return dir end - _h5_local_stability(dir) = h5open(joinpath(dir, "gpec.h5"), "r") do f - Dict(k => read(f, "LocalStability/$k") for k in keys(f["LocalStability"])) - end + _h5_local_stability(dir) = + h5open(joinpath(dir, "gpec.h5"), "r") do f + Dict(k => read(f, "LocalStability/$k") for k in keys(f["LocalStability"])) + end quiet_section = Dict{String,Any}("LocalStability" => Dict{String,Any}("verbose" => false)) @testset "deck section and solve give identical results" begin diff --git a/test/runtests_monte_carlo.jl b/test/runtests_monte_carlo.jl index ec9db1b5f..7964aea83 100644 --- a/test/runtests_monte_carlo.jl +++ b/test/runtests_monte_carlo.jl @@ -24,7 +24,7 @@ using LinearAlgebra end hoops(names; heights=zeros(length(names))) = [FT.make_pf_hoop(; radius=1.5, height=heights[i], name=nm) for (i, nm) in enumerate(names)] pdf_moments(res) = begin - centers = (res.abs_delta_bin_edges[1:end-1] .+ res.abs_delta_bin_edges[2:end]) ./ 2 + centers = (res.abs_delta_bin_edges[1:(end-1)] .+ res.abs_delta_bin_edges[2:end]) ./ 2 w = diff(res.abs_delta_bin_edges) (sum(res.abs_delta_pdf .* w), sum(centers .* res.abs_delta_pdf .* w)) end @@ -39,7 +39,7 @@ using LinearAlgebra shift_tol_mm = 2.0 radial_shape = "flat" """) - ctrl = EF.MonteCarloControl(; nsample=200_000, nbatch=2, seed=3, nbins=100, delta_max=abs(Sx) * 2e-3) + ctrl = EF.MonteCarloControl(; nsample=20_000, nbatch=2, seed=3, nbins=20, delta_max=abs(Sx) * 2e-3) res = EF.run_monte_carlo(table, ts, hoops(["a"]), ctrl) total, mean_δ = pdf_moments(res) @test total ≈ 1 atol = 1e-2 @@ -51,9 +51,9 @@ using LinearAlgebra # Everything is correctable: the corrected |δ| is the intrinsic one halved, a box on [0, |S|R/2]. half = ctrl.nbins ÷ 2 @test all(abs.(res.abs_delta_efc_pdf[1:half] .- 2 / (abs(Sx) * 2e-3)) .< 0.3 / (abs(Sx) * 2e-3)) - @test all(res.abs_delta_efc_pdf[half+1:end] .== 0) + @test all(res.abs_delta_efc_pdf[(half+1):end] .== 0) @test res.abs_delta_efc_sampled_mean ≈ res.abs_delta_sampled_mean / 2 rtol = 2e-2 - @test size(res.abs_delta_pdf_batches) == (100, 2) + @test size(res.abs_delta_pdf_batches) == (20, 2) end @testset "reduction to the OMFIT model and seed reproducibility" begin @@ -92,14 +92,14 @@ using LinearAlgebra radial_shape = "ring" """ ts = EF.parse_tolerance_toml(tol) - ctrl = EF.MonteCarloControl(; nsample=300_000, nbatch=2, seed=11, nbins=200) + ctrl = EF.MonteCarloControl(; nsample=30_000, nbatch=2, seed=11, nbins=200) res = EF.run_monte_carlo(table, ts, hoops(names), ctrl) # Literal OMFIT transcription: dfac = tol·rand^p·e^{iφ}, dunc = σ·randn·e^{iφ}, deltas = # dc_nerr + dc_disp·(dfac + dunc) + dc_tilt·(tfac + tunc), other = mag·rand^0·e^{iφ}, # EFC divides correctable rows and the other budget. rng = Xoshiro(99) - N = 600_000 + N = 60_000 dc_disp = abs.(Sx) dc_tilt = abs.(Tx) disp_tol = [1e-3, 0.5e-3, 2e-3] @@ -125,7 +125,7 @@ using LinearAlgebra δ_efc[s] = abs((corr + other) / 2 + unc) end edges = res.abs_delta_bin_edges - hist(x) = [count(v -> edges[i] <= v < edges[i+1], x) for i in 1:length(edges)-1] ./ (length(x) * (edges[2] - edges[1])) + hist(x) = [count(v -> edges[i] <= v < edges[i+1], x) for i in 1:(length(edges)-1)] ./ (length(x) * (edges[2] - edges[1])) h_all = hist(δ_all) h_efc = hist(δ_efc) # Histograms agree to Monte Carlo noise: compare CDFs (max deviation) and means. @@ -141,14 +141,14 @@ using LinearAlgebra @test again.abs_delta_pdf == res.abs_delta_pdf && again.abs_delta_efc_pdf == res.abs_delta_efc_pdf @test again.abs_delta_pdf_batches == res.abs_delta_pdf_batches # A different seed differs; the tolerance scale widens the distribution. - other_seed = EF.run_monte_carlo(table, ts, hoops(names), EF.MonteCarloControl(; nsample=300_000, nbatch=2, seed=12, nbins=200)) + other_seed = EF.run_monte_carlo(table, ts, hoops(names), EF.MonteCarloControl(; nsample=30_000, nbatch=2, seed=12, nbins=200)) @test other_seed.abs_delta_pdf != res.abs_delta_pdf - wide = EF.run_monte_carlo(table, ts, hoops(names), EF.MonteCarloControl(; nsample=100_000, nbatch=1, seed=11, nbins=200, tolerance_scale=3.0)) + wide = EF.run_monte_carlo(table, ts, hoops(names), EF.MonteCarloControl(; nsample=2_000, nbatch=1, seed=11, nbins=200, tolerance_scale=3.0)) @test wide.abs_delta_sampled_mean > res.abs_delta_sampled_mean # Coil subset: only c1 sampled; c2 and c3 contribute their nominal overlap. - sub = EF.run_monte_carlo(table, ts, hoops(names), EF.MonteCarloControl(; nsample=100_000, nbatch=1, seed=11, nbins=200, coil_subset=["c1"])) + sub = EF.run_monte_carlo(table, ts, hoops(names), EF.MonteCarloControl(; nsample=2_000, nbatch=1, seed=11, nbins=200, coil_subset=["c1"])) @test sub.abs_delta_worst_case < res.abs_delta_worst_case - none = EF.run_monte_carlo(table, ts, hoops(names), EF.MonteCarloControl(; nsample=20_000, nbatch=1, seed=11, nbins=200, coil_subset=["zzz"])) + none = EF.run_monte_carlo(table, ts, hoops(names), EF.MonteCarloControl(; nsample=512, nbatch=1, seed=11, nbins=200, coil_subset=["zzz"])) # With nothing sampled but the ring budget, |δ| = |Σδ0 + 5e-5·e^{iφ}| lies within 5e-5 of the nominal. @test none.abs_delta_sampled_mean ≈ res.abs_delta_total_as_designed rtol = 0.5 @test all( @@ -175,8 +175,8 @@ using LinearAlgebra @test mapped.abs_delta_tilt_tolerance[2] ≈ 2 * terms.abs_delta_tilt_tolerance[2] @test mapped.abs_delta_shift_tolerance[[1, 3]] == terms.abs_delta_shift_tolerance[[1, 3]] # A zero multiplier on c2 draws the same numbers as leaving c2 out of coil_subset (c2 has no sigma). - zero_c2 = EF.run_monte_carlo(table, ts, hoops(names), EF.MonteCarloControl(; nsample=50_000, nbatch=1, seed=11, nbins=200, scale_map=Dict("c2" => 0.0))) - without_c2 = EF.run_monte_carlo(table, ts, hoops(names), EF.MonteCarloControl(; nsample=50_000, nbatch=1, seed=11, nbins=200, coil_subset=["c1", "c3"])) + zero_c2 = EF.run_monte_carlo(table, ts, hoops(names), EF.MonteCarloControl(; nsample=5_000, nbatch=1, seed=11, nbins=200, scale_map=Dict("c2" => 0.0))) + without_c2 = EF.run_monte_carlo(table, ts, hoops(names), EF.MonteCarloControl(; nsample=5_000, nbatch=1, seed=11, nbins=200, coil_subset=["c1", "c3"])) @test zero_c2.abs_delta_pdf == without_c2.abs_delta_pdf @test_throws ArgumentError EF.run_monte_carlo(table, ts, hoops(names), EF.MonteCarloControl(; nsample=10, nbatch=1, scale_subset=["zzz"])) @test_throws ArgumentError EF.run_monte_carlo(table, ts, hoops(names), EF.MonteCarloControl(; nsample=10, nbatch=1, scale_map=Dict("zzz" => 1.0))) @@ -283,7 +283,7 @@ using LinearAlgebra radial_shape = "ring" rotation_center_z_m = 0.0 """) - res0 = EF.run_monte_carlo(table, centered, sets, EF.MonteCarloControl(; nsample=20_000, nbatch=1, seed=2, nbins=50, delta_max=1e-2)) + res0 = EF.run_monte_carlo(table, centered, sets, EF.MonteCarloControl(; nsample=512, nbatch=1, seed=2, nbins=50, delta_max=1e-2)) @test res0.abs_delta_sampled_mean < 1e-12 offset = EF.parse_tolerance_toml(""" [[ErrorFields.coherent_group]] @@ -295,7 +295,7 @@ using LinearAlgebra rotation_center_z_m = -0.5 """) # Rotation about the lower coil by 1° moves the upper coil by 1.0 m·deg2rad(1): |δ| = |S|·1.0·deg2rad(1). - res1 = EF.run_monte_carlo(table, offset, sets, EF.MonteCarloControl(; nsample=20_000, nbatch=1, seed=2, nbins=50, delta_max=0.05)) + res1 = EF.run_monte_carlo(table, offset, sets, EF.MonteCarloControl(; nsample=512, nbatch=1, seed=2, nbins=50, delta_max=0.05)) @test res1.abs_delta_sampled_mean ≈ deg2rad(1.0) rtol = 1e-2 # Two groups sharing a phase_group move in the same direction: their shifts add coherently. shared = EF.parse_tolerance_toml(""" @@ -312,10 +312,10 @@ using LinearAlgebra radial_shape = "ring" phase_group = "same" """) - res_s = EF.run_monte_carlo(table, shared, sets, EF.MonteCarloControl(; nsample=20_000, nbatch=1, seed=2, nbins=50, delta_max=5e-3)) + res_s = EF.run_monte_carlo(table, shared, sets, EF.MonteCarloControl(; nsample=512, nbatch=1, seed=2, nbins=50, delta_max=5e-3)) @test res_s.abs_delta_sampled_mean ≈ 2e-3 rtol = 1e-2 independent = EF.parse_tolerance_toml(replace(shared.raw, "phase_group = \"same\"" => "")) - res_i = EF.run_monte_carlo(table, independent, sets, EF.MonteCarloControl(; nsample=50_000, nbatch=1, seed=2, nbins=50, delta_max=5e-3)) + res_i = EF.run_monte_carlo(table, independent, sets, EF.MonteCarloControl(; nsample=5_000, nbatch=1, seed=2, nbins=50, delta_max=5e-3)) # |e^{iφ1} + e^{iφ2}| averages 4/π for independent phases. @test res_i.abs_delta_sampled_mean ≈ 1e-3 * 4 / π rtol = 2e-2 end diff --git a/test/runtests_parallel_integration.jl b/test/runtests_parallel_integration.jl index 67c21f60e..2677d2490 100644 --- a/test/runtests_parallel_integration.jl +++ b/test/runtests_parallel_integration.jl @@ -280,7 +280,7 @@ end # # Bidirectional FM integration (crossing chunks integrated backward) is what the # Riccati path uses. It keeps FM propagators well-conditioned for both small-N - # (Solovev N=8, tested here) and large-N (DIIID N=26, tested below). + # on this small multi-surface fixture. ex = joinpath(@__DIR__, "test_data", "regression_solovev_ideal_example") function run_solovev(integrator) @@ -318,78 +318,6 @@ end # Energy eigenvalue matches to 2% @test isapprox(et_ric, et_fwd; rtol=0.02) - # Per-surface Δ' assertions were removed: per-surface Δ' is a stub calculation - # left in the code for future work but no longer reported, output, or tested. - # The STRIDE BVP Δ' matrix (`SingularSurfaces/Delta_prime_matrix`) is the canonical - # Δ', regression-tested via the DIIID-like fixture which has well-conditioned - # values; Solovev is near marginal stability and BVP Δ' is pathological there. - end - - @testset "Riccati FM integration matches forward ODE — DIIID-like example (large N)" begin - # Run forward and Riccati FM integrations on the DIIID-like example (N≈26 modes). - # Before bidirectional integration, the all-forward FM propagators were ill-conditioned - # for large N, producing ~10% energy error. Bidirectional integration (backward crossing - # chunks + forward intermediate chunks) restores accuracy to within 2%. - # - # This is the key regression test for the bidirectional parallel FM fix. - ex = joinpath(@__DIR__, "..", "examples", "DIIID-like_ideal_example") - - function run_diiid(integrator) - inputs = TOML.parsefile(joinpath(ex, "gpec.toml")) - inputs["ForceFreeStates"]["verbose"] = false - inputs["ForceFreeStates"]["integrator"] = integrator - inputs["ForceFreeStates"]["write_outputs_to_HDF5"] = false - intr = GeneralizedPerturbedEquilibrium.ForceFreeStates.ForceFreeStatesInternal(; dir_path=ex) - ctrl = GeneralizedPerturbedEquilibrium.ForceFreeStates.ForceFreeStatesControl(; - (Symbol(k) => v for (k, v) in inputs["ForceFreeStates"])...) - eq_config = GeneralizedPerturbedEquilibrium.Equilibrium.EquilibriumConfig(inputs["Equilibrium"], ex) - equil = GeneralizedPerturbedEquilibrium.Equilibrium.PlasmaEquilibrium( - eq_config, - haskey(inputs, "SOL_INPUT") ? GeneralizedPerturbedEquilibrium.Equilibrium.SolovevConfig(inputs["SOL_INPUT"]) : nothing - ) - # Apply the two-pass auto grid exactly as the main driver does (the example ships - # grid_type="auto", mpsi=0): measured-curvature refinement with rational surfaces - # pinned as mandatory knots, re-formed from the captured ingest. The pinned values - # below are for this grid, which is the production default. - if GeneralizedPerturbedEquilibrium.Equilibrium.wants_two_pass(eq_config) - mand = GeneralizedPerturbedEquilibrium.ForceFreeStates.rational_psi_nodes(equil; nlow=ctrl.nn_low, nhigh=ctrl.nn_high) - psi_nodes = GeneralizedPerturbedEquilibrium.Equilibrium.refined_psi_grid(equil; tau=eq_config.psi_accuracy, mandatory=mand) - rerun_input = GeneralizedPerturbedEquilibrium.Equilibrium.build_direct_from_ingest(eq_config, equil.ingest) - equil = GeneralizedPerturbedEquilibrium.Equilibrium.PlasmaEquilibrium(eq_config, rerun_input; override_psi_nodes=psi_nodes) - end - intr.wall_settings = GeneralizedPerturbedEquilibrium.Vacuum.WallShapeSettings(; - (Symbol(k) => v for (k, v) in inputs["Wall"])...) - intr.nlow = ctrl.nn_low; - intr.nhigh = ctrl.nn_high; - intr.npert = 1 - GeneralizedPerturbedEquilibrium.ForceFreeStates.sing_lim!(intr, ctrl, equil) - GeneralizedPerturbedEquilibrium.ForceFreeStates.sing_find!(intr, equil) - intr.mlow = min(intr.nlow * equil.params.qmin, 0) - 4 - ctrl.delta_mlow - intr.mhigh = trunc(Int, intr.nhigh * equil.params.qmax) + ctrl.delta_mhigh - intr.mpert = intr.mhigh - intr.mlow + 1 - intr.numpert_total = intr.mpert * intr.npert - metric = GeneralizedPerturbedEquilibrium.ForceFreeStates.make_metric(equil, intr.mpert) - mats = GeneralizedPerturbedEquilibrium.ForceFreeStates.build_matrix_splines(equil, intr, metric) - odet, _, _, _ = GeneralizedPerturbedEquilibrium.ForceFreeStates.eulerlagrange_integration(ctrl, equil, mats, intr) - vac = GeneralizedPerturbedEquilibrium.ForceFreeStates.free_run(odet, ctrl, equil, mats, intr) - return real(vac.et[1]), intr - end - - et_ric, intr_ric = run_diiid("riccati") - - # Riccati FM et[1] regression — pinned tightly, NOT bracketed. et[1] is grid- and - # equilibrium-sensitive (auto-mpsi gives a spurious value; a wrong grid/Ip shifts it), so - # a loose bracket would mask exactly that accuracy regression. The Riccati-path value is - # deterministic and reproducible. - @test isapprox(et_ric, 0.800637; rtol=2e-2) - # Per-surface Δ' assertions removed (stub calculation; see Solovev testset - # comment above). BVP Δ' matrix regression for DIIID-like is in the - # `delta_prime_matrix — STRIDE BVP DIIID-like regression (large N)` testset. - - # No explicit Riccati-vs-forward cross-path check here: the two paths share the - # equilibrium grid (so a cross-path comparison is blind to grid/accuracy regressions), - # and their agreement is already verified on the lighter Solovev case above. The tight - # absolute pin above is the guard for grid/equilibrium regressions on this case. end @testset "ode_itime_cost is additive over sub-intervals" begin @@ -503,117 +431,6 @@ end @test isempty(odet_ric.xi_s_store) end - @testset "delta_prime_matrix — STRIDE BVP DIIID-like regression (large N)" begin - # Verify that the parallel FM path computes a well-formed inter-surface Δ' matrix - # for the DIIID-like case (N≈26 modes, multiple rational surfaces). This complements - # the Solovev test above by exercising the BVP assembly with more surfaces and larger - # mode space, where ill-conditioned (non-bidirectional) FM propagators would fail. - ex = joinpath(@__DIR__, "..", "examples", "DIIID-like_ideal_example") - inputs = TOML.parsefile(joinpath(ex, "gpec.toml")) - inputs["ForceFreeStates"]["verbose"] = false - inputs["ForceFreeStates"]["integrator"] = "riccati" - inputs["ForceFreeStates"]["write_outputs_to_HDF5"] = false - intr = GeneralizedPerturbedEquilibrium.ForceFreeStates.ForceFreeStatesInternal(; dir_path=ex) - ctrl = GeneralizedPerturbedEquilibrium.ForceFreeStates.ForceFreeStatesControl(; - (Symbol(k) => v for (k, v) in inputs["ForceFreeStates"])...) - eq_config = GeneralizedPerturbedEquilibrium.Equilibrium.EquilibriumConfig(inputs["Equilibrium"], ex) - equil = GeneralizedPerturbedEquilibrium.Equilibrium.PlasmaEquilibrium( - eq_config, - haskey(inputs, "SOL_INPUT") ? GeneralizedPerturbedEquilibrium.Equilibrium.SolovevConfig(inputs["SOL_INPUT"]) : nothing - ) - # Apply the two-pass auto grid (measured-curvature refinement, rational surfaces pinned - # as mandatory knots) exactly as the main driver does (see the FM testset above); the - # pinned values below are for this grid, the production default. - if GeneralizedPerturbedEquilibrium.Equilibrium.wants_two_pass(eq_config) - mand = GeneralizedPerturbedEquilibrium.ForceFreeStates.rational_psi_nodes(equil; nlow=ctrl.nn_low, nhigh=ctrl.nn_high) - psi_nodes = GeneralizedPerturbedEquilibrium.Equilibrium.refined_psi_grid(equil; tau=eq_config.psi_accuracy, mandatory=mand) - rerun_input = GeneralizedPerturbedEquilibrium.Equilibrium.build_direct_from_ingest(eq_config, equil.ingest) - equil = GeneralizedPerturbedEquilibrium.Equilibrium.PlasmaEquilibrium(eq_config, rerun_input; override_psi_nodes=psi_nodes) - end - intr.wall_settings = GeneralizedPerturbedEquilibrium.Vacuum.WallShapeSettings(; - (Symbol(k) => v for (k, v) in inputs["Wall"])...) - intr.nlow = ctrl.nn_low; - intr.nhigh = ctrl.nn_high; - intr.npert = 1 - GeneralizedPerturbedEquilibrium.ForceFreeStates.sing_lim!(intr, ctrl, equil) - GeneralizedPerturbedEquilibrium.ForceFreeStates.sing_find!(intr, equil) - intr.mlow = min(intr.nlow * equil.params.qmin, 0) - 4 - ctrl.delta_mlow - intr.mhigh = trunc(Int, intr.nhigh * equil.params.qmax) + ctrl.delta_mhigh - intr.mpert = intr.mhigh - intr.mlow + 1 - intr.numpert_total = intr.mpert * intr.npert - metric = GeneralizedPerturbedEquilibrium.ForceFreeStates.make_metric(equil, intr.mpert) - mats = GeneralizedPerturbedEquilibrium.ForceFreeStates.build_matrix_splines(equil, intr, metric) - odet, fm_propagators, fm_chunks, fm_S_left = - GeneralizedPerturbedEquilibrium.ForceFreeStates.eulerlagrange_integration(ctrl, equil, mats, intr) - vac = GeneralizedPerturbedEquilibrium.ForceFreeStates.free_run(odet, ctrl, equil, mats, intr) - GeneralizedPerturbedEquilibrium.ForceFreeStates.compute_delta_prime_matrix!( - intr, fm_propagators, fm_chunks; - wv=vac.wv, psio=equil.psio, - S_at_surface_left=fm_S_left, ctrl=ctrl, equil=equil, mats=mats) - - msing = intr.msing - dpm = intr.delta_prime_matrix - - # Matrix is populated with correct shape (msing × msing); see Solovev test above - # for why this is msing × msing rather than 2·msing × 2·msing. - @test !isempty(dpm) - @test size(dpm) == (msing, msing) - - # All elements are finite - @test all(isfinite, dpm) - - # Diagonal (self-response) elements are non-zero - for j in 1:msing - @test abs(dpm[j, j]) > 1e-10 - end - - # Pinned diagonal `delta_prime_matrix` REAL parts, PEST3-convention self-response Δ' from - # the STRIDE BVP with vacuum coupling, on the two-pass measured-curvature grid (rational - # surfaces now *bracketed* rather than pinned on — see `bracket_mandatory_nodes`). - # - # The q=2 pin is now a CONVERGED value, which closes the "replace this with a converged-Δ′ - # pin on a fixed ldp grid" item the previous pin carried. Three independent grid families - # on this fixture agree to ~1%: - # ldp mpsi 512 / 1024 / 2048 : 8.478 / 9.142 / 9.244 - # uniform mpsi 1024 / 2048 : 9.146 / 9.143 - # auto τ 2e-3/1e-3/5e-4/2.5e-4 : 9.198 / 9.239 / 9.206 / 9.157 - # i.e. dpm[1,1] → ≈9.2. Before this grid fix the τ-scan swung ~50% (6.2–9.9) and the pin - # had to be a mid-spread snapshot; it is now flat in τ to 0.9%, so the default - # psi_accuracy lands on the converged value rather than near it by luck. - # See the "pinning grid-sensitive Δ′ robustly" open problem in - # docs/src/developer_notes.md for the plateau criterion meant to replace single-point pins. - # (et[1], NTV torque, and ‖resonant flux‖ stay grid-robust to <1% — the sensitivity is - # local to the singular-layer matching, not the global response.) Only real parts are - # pinned; the imaginary parts are dominated by the PEST3 four-term cancellation and are - # FP/platform-sensitive. Near-separatrix surfaces q=5,6 keep only the finiteness/non-zero - # checks above. Values use this testset's mode range (mpert=27, vs full-pipeline mpert=35). - # - # The q=2 platform spread also collapsed with this fix: because the matching stencil no - # longer straddles a knot, q‴ is single-valued across it and the surface no longer sits on - # the steepest part of the refinement curve. Same grid and inputs now give 9.239 - # (macOS/aarch64), 9.333 (linux/julia 1.11) and 9.356 (linux/julia 1.x) — 1.3% end to end, - # against ~25% before (6.14 / 6.69 / 7.70). rtol=3e-2 spans that with margin and is a 5× - # TIGHTENING of the old 1.5e-1. q=3 and q=4 are unchanged: the same ladder puts them at - # −5.716 and −16.033 (ldp 2048), inside their existing tolerances, and they reproduce - # across platforms. - @test isapprox(real(dpm[1, 1]), +9.300000e+00; rtol=3e-2) # q=2, converged (ldp2048 9.244) - @test isapprox(real(dpm[2, 2]), -5.344199e+00; rtol=1e-1) # q=3 - @test isapprox(real(dpm[3, 3]), -1.590034e+01; rtol=1e-1) # q=4 - - # Compare Float64 against the default Double64 solve, including complex off-diagonal entries. - @test ctrl.extended_precision_bvp - ctrl_float = GeneralizedPerturbedEquilibrium.ForceFreeStates.ForceFreeStatesControl(; - (Symbol(k) => v for (k, v) in inputs["ForceFreeStates"])..., extended_precision_bvp=false) - GeneralizedPerturbedEquilibrium.ForceFreeStates.compute_delta_prime_matrix!( - intr, fm_propagators, fm_chunks; - wv=vac.wv, psio=equil.psio, - S_at_surface_left=fm_S_left, ctrl=ctrl_float, equil=equil, mats=mats) - @test isapprox(real.(diag(intr.delta_prime_matrix)), real.(diag(dpm)); rtol=1e-8) - @test isapprox(intr.delta_prime_matrix, dpm; rtol=1e-8) - for j in 1:msing, i in 1:msing - @test isapprox(real(intr.delta_prime_matrix[i, j]), real(dpm[i, j]); rtol=1e-8, atol=1e-8) - @test isapprox(imag(intr.delta_prime_matrix[i, j]), imag(dpm[i, j]); rtol=1e-8, atol=1e-8) - end - end + # Production DIII-D energies and Δ′ are tracked by the diiid_n1_riccati harness cases. end diff --git a/test/runtests_rerun_from_h5.jl b/test/runtests_rerun_from_h5.jl index a0b51b271..05b25bb4e 100644 --- a/test/runtests_rerun_from_h5.jl +++ b/test/runtests_rerun_from_h5.jl @@ -163,7 +163,7 @@ end # the source run and the replay: the default (recompute-from-TOML) path then # fails, while `--coil-source coils` succeeds from the stored geometry. @testset "Rerun from gpec.h5: coil geometry snapshot" begin - template_dir = joinpath(@__DIR__, "..", "examples", "Solovev_ideal_example") + template_dir = joinpath(@__DIR__, "test_data", "regression_solovev_ideal_example") src_dat = joinpath(@__DIR__, "..", "src", "ForcingTerms", "coil_geometries", "d3d_il.dat") read_resfield(path) = @@ -185,8 +185,11 @@ end toml_path = joinpath(snapshot_dir, "gpec.toml") inputs = TOML.parsefile(toml_path) inputs["ForceFreeStates"]["write_outputs_to_HDF5"] = true + inputs["PerturbedEquilibrium"] = Dict{String,Any}( + "compute_singular_coupling" => true, + "verbose" => false, "write_outputs_to_HDF5" => true) inputs["ForcingTerms"] = Dict{String,Any}( - "forcing_data_format" => "coil", + "forcing_data_format" => "coil", "mtheta_coil" => 64, "nzeta_coil" => 32, "coil_set" => [Dict{String,Any}( "dat_file" => coil_dat, "currents" => fill(1.0e3, 6) diff --git a/test/runtests_result_struct.jl b/test/runtests_result_struct.jl index 964cf1643..418ffc317 100644 --- a/test/runtests_result_struct.jl +++ b/test/runtests_result_struct.jl @@ -18,10 +18,19 @@ include("h5_metadata_check.jl") inputs = TOML.parsefile(toml_path) merge!(inputs["ForceFreeStates"], ffs_overrides) merge!(inputs, extra_sections) + if haskey(inputs, "TJ_ANALYTIC_INPUT") + # Interface checks need two rational surfaces, not a converged production grid. + merge!(inputs["Equilibrium"], Dict("mpsi" => 32, "mtheta" => 64)) + merge!(inputs["TJ_ANALYTIC_INPUT"], Dict("ma" => 32, "mtheta" => 32)) + merge!(inputs["ForceFreeStates"], Dict("gal_nx" => 32, "delta_mlow" => 2, "delta_mhigh" => 2, "mtheta_vacuum" => 64)) + end open(io -> TOML.print(io, inputs), toml_path, "w") return dir end + forward_result = Ref{FFS.ForceFreeStatesResult}() + riccati_result = Ref{FFS.ForceFreeStatesResult}() + @testset "forward run publishes a dense axis-basis solution" begin mktempdir() do dir _stage_deck(dir, template) @@ -29,6 +38,7 @@ include("h5_metadata_check.jl") @test keys(ret)[1:3] == (:ffs, :pe, :slayer) # later stages append their own outputs ffs = ret.ffs + forward_result[] = ffs @test ffs isa FFS.ForceFreeStatesResult @test ffs.integrator === :forward @@ -75,6 +85,7 @@ include("h5_metadata_check.jl") ret = GeneralizedPerturbedEquilibrium.main([dir]) ffs = ret.ffs + riccati_result[] = ffs @test ffs.integrator === :riccati # Chunk-endpoint Riccati states are not a ξ solution; only the raw state is carried. @test ffs.solution === nothing @@ -96,10 +107,7 @@ include("h5_metadata_check.jl") end @testset "require / require_solution gates" begin - mktempdir() do dir - _stage_deck(dir, template; ffs_overrides=Dict{String,Any}("integrator" => "riccati")) - ffs = GeneralizedPerturbedEquilibrium.main([dir]).ffs - + let ffs = riccati_result[] # `require` passes silently on a populated field and warns once on an absent one. @test @test_logs FFS.require(ffs, :free_boundary, "a calculation") @test !(@test_logs (:warn,) FFS.require(ffs, :galerkin, "a calculation")) @@ -249,9 +257,7 @@ include("h5_metadata_check.jl") end @testset "free-boundary run aliases free_run's W_p" begin - mktempdir() do dir - _stage_deck(dir, template) - ffs = GeneralizedPerturbedEquilibrium.main([dir]).ffs + let ffs = forward_result[] @test ffs.free_boundary !== nothing @test ffs.wp === ffs.free_boundary.wp end diff --git a/test/runtests_slayer_runner.jl b/test/runtests_slayer_runner.jl index 4f7a4b8f3..3c07ff7de 100644 --- a/test/runtests_slayer_runner.jl +++ b/test/runtests_slayer_runner.jl @@ -5,6 +5,7 @@ using GeneralizedPerturbedEquilibrium.Dispersion using GeneralizedPerturbedEquilibrium.Runner using HDF5 + using TOML include("h5_metadata_check.jl") @@ -154,6 +155,13 @@ for name in readdir(deck) cp(joinpath(deck, name), joinpath(dir, name)) end + # Preserve the two-surface producer/consumer path on a small Galerkin grid. + deck_path = joinpath(dir, "gpec.toml") + inputs = TOML.parsefile(deck_path) + merge!(inputs["Equilibrium"], Dict("mpsi" => 32, "mtheta" => 64)) + merge!(inputs["TJ_ANALYTIC_INPUT"], Dict("ma" => 32, "mtheta" => 32)) + merge!(inputs["ForceFreeStates"], Dict("gal_nx" => 32, "delta_mlow" => 2, "delta_mhigh" => 2, "mtheta_vacuum" => 64)) + open(io -> TOML.print(io, inputs), deck_path, "w") ffs = GeneralizedPerturbedEquilibrium.main([dir]).ffs @test ffs.integrator === :galerkin @@ -293,6 +301,7 @@ @test Runner.delta_prime_to_rs_reference(dp, [_mk_params(), _mk_params()]) ≈ dp end + coupled_result = Ref{SLAYERResult}() @testset "run_slayer_from_inputs: coupled mode finds known root" begin # Build a 2-surface problem with a known coupled root by construction. p1 = _mk_params(; rs=0.5, lu=1.0e7, tauk=1.0e-4, Q_e=-1.0, Q_i=0.5, @@ -321,8 +330,10 @@ Q_re_range=(-1.0, 1.0), Q_im_range=(-0.5, 0.8), nre=80, nim=80, - pole_threshold=1e5) # tuned for lu^(1/3) scale - r = run_slayer_from_inputs(SLAYERModel(; variant=:fitzpatrick), params, dp, c) + pole_threshold=1e5, store_scan=true) + r = run_slayer_from_inputs(SLAYERModel(; variant=:fitzpatrick), params, dp, c; + rational_psi=[0.45, 0.72], rational_q=[2.0, 3.0]) + coupled_result[] = r @test r.enabled @test length(r.Q_root) == 1 # single coupled eigenvalue @test abs(r.Q_root[1] - Q_target) < 2e-2 # grid-resolution limited @@ -331,27 +342,9 @@ end @testset "write_slayer_hdf5!: round-trip structure" begin - p1 = _mk_params(; rs=0.5, lu=1.0e7, tauk=1.0e-4, m=2, ising=1) - p2 = _mk_params(; rs=0.6, lu=2.0e7, tauk=1.2e-4, m=3, ising=2) - params = [p1, p2] - - # Diagonal dp, zero coupling → trivial root structure at Q_target=0 - Q_target = 0.0 + 0.0im - model = SLAYERModel() - Δ1 = InnerLayer.solve_inner(model, p1, Q_target).tearing * p1.lu^(1 / 3) - Δ2 = InnerLayer.solve_inner(model, p2, Q_target).tearing * p2.lu^(1 / 3) - dp = ComplexF64[Δ1 0.0; 0.0 Δ2] + # Serialize the known-root integration result without repeating the scan. + r = coupled_result[] - c = SLAYERControl(; enabled=true, - scan_mode=:brute_force, - coupling_mode=:coupled, - Q_re_range=(-0.5, 0.5), - Q_im_range=(-0.3, 0.3), - nre=40, nim=40, - pole_threshold=1e5, - store_scan=true) - r = run_slayer_from_inputs(SLAYERModel(; variant=:fitzpatrick), params, dp, c; - rational_psi=[0.45, 0.72], rational_q=[2.0, 3.0]) @test r.model === SLAYERModel(; variant=:fitzpatrick) mktemp() do path, io diff --git a/test/runtests_solve_api.jl b/test/runtests_solve_api.jl index 5d33ded18..f7caa70ea 100644 --- a/test/runtests_solve_api.jl +++ b/test/runtests_solve_api.jl @@ -20,7 +20,7 @@ using HDF5 # The deck's `[ForceFreeStates]` block as `solve` keywords: everything except the knobs the # integrator object and the `nn` keyword own. ffs_kwargs = Dict(Symbol(k) => v for (k, v) in deck["ForceFreeStates"] - if !(k in ("integrator", "nn_low", "nn_high"))) + if !(k in ("integrator", "nn_low", "nn_high"))) # Copy the fixture deck into `dir` and apply `[Equilibrium]` / `[ForceFreeStates]` overrides and extra sections. function _stage_deck(dir; eq_overrides=Dict{String,Any}(), ffs_overrides=Dict{String,Any}(), extra_sections=Dict{String,Any}()) @@ -401,7 +401,7 @@ using HDF5 kwargs = merge(ffs_kwargs, Dict(Symbol(k) => v for (k, v) in ffs_overrides)) api = solve(pass1, Forward(); nn=1, wall=wall, dir_path=dir, kwargs...) - # The equilibrium stores its analytic config, so `solve` re-forms it on the deck's grid. + # The API and deck reform the same analytic source on the same refined grid. @test api.equil.rzphi_xs == reference.equil.rzphi_xs end end diff --git a/test/suites.jl b/test/suites.jl new file mode 100644 index 000000000..32fdaa645 --- /dev/null +++ b/test/suites.jl @@ -0,0 +1,60 @@ +# Keep the full suite order while assigning each file to exactly one CI group. +const TEST_SUITES = [ + "runtests_utilities.jl" => "core", + "runtests_fouriertransforms.jl" => "core", + "runtests_vacuum.jl" => "core", + "runtests_equil.jl" => "core", + "runtests_sfl_sampling.jl" => "core", + "runtests_grid_refinement.jl" => "api", + "runtests_core_capped_knots.jl" => "core", + "runtests_coordinate_invariant.jl" => "core", + "runtests_eulerlagrange.jl" => "core", + "runtests_riccati.jl" => "core", + "runtests_galerkin.jl" => "core", + "runtests_galerkin_cholesky.jl" => "core", + "runtests_parallel_integration.jl" => "core", + "runtests_result_struct.jl" => "api", + "runtests_solve_api.jl" => "api", + "runtests_matching_models.jl" => "api", + "runtests_dominant_coupling.jl" => "api", + "runtests_error_fields.jl" => "errorfields", + "runtests_tolerance_toml.jl" => "errorfields", + "runtests_sampling.jl" => "errorfields", + "runtests_monte_carlo.jl" => "errorfields", + "runtests_risk.jl" => "errorfields", + "runtests_phasing.jl" => "errorfields", + "runtests_ntv_limits.jl" => "errorfields", + "runtests_sing.jl" => "core", + "runtests_innerlayer.jl" => "errorfields", + "runtests_tj_analytic.jl" => "core", + "runtests_kinetic_profiles.jl" => "core", + "runtests_resist_eval.jl" => "core", + "runtests_localstability.jl" => "core", + "runtests_analysis_plots.jl" => "api", + "runtests_slayer_params.jl" => "errorfields", + "runtests_slayer_riccati.jl" => "errorfields", + "runtests_slayer_inputs.jl" => "errorfields", + "runtests_slayer_profile_transport.jl" => "errorfields", + "runtests_layer_overlap_fitzpatrick.jl" => "errorfields", + "runtests_dispersion_residual.jl" => "errorfields", + "runtests_dispersion_coupled.jl" => "errorfields", + "runtests_dispersion_coupled_full.jl" => "errorfields", + "runtests_dispersion_rotation.jl" => "errorfields", + "runtests_dispersion_scan.jl" => "errorfields", + "runtests_dispersion_amr.jl" => "errorfields", + "runtests_dispersion_polish.jl" => "errorfields", + "runtests_dispersion_winding.jl" => "errorfields", + "runtests_dispersion_ggj.jl" => "errorfields", + "runtests_critical_resonant_field.jl" => "errorfields", + "runtests_slayer_runner.jl" => "errorfields", + "runtests_kinetic.jl" => "core", + "runtests_kinetic_validity.jl" => "core", + "runtests_multiion.jl" => "core", + "runtests_fullruns.jl" => "api", + "runtests_torque_response.jl" => "api", + "runtests_coils.jl" => "api", + "runtests_imas.jl" => "api", + "runtests_rerun_from_h5.jl" => "api", + "runtests_frozen_equilibrium.jl" => "api", + "runtests_h5_schema.jl" => "api" +]