diff --git a/.github/dependabot.yml b/.github/dependabot.yml index 9b09538..1b23ebc 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -9,3 +9,9 @@ updates: directory: "/" schedule: interval: "weekly" + ignore: + # The v5→v7 bump silently broke coverage uploads in the sibling + # DecisionRules.jl repo. Keep codecov-action pinned until a deliberate, + # verified migration — see the comment in .github/workflows/CI.yml. + - dependency-name: "codecov/codecov-action" + update-types: ["version-update:semver-major"] diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index d6b04cb..be1a6df 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -17,6 +17,7 @@ jobs: permissions: actions: write contents: read + id-token: write # OIDC token for tokenless Codecov uploads (see codecov step) strategy: fail-fast: false matrix: @@ -37,8 +38,22 @@ jobs: - uses: julia-actions/julia-buildpkg@v1 - uses: julia-actions/julia-runtest@v1 - uses: julia-actions/julia-processcoverage@v1 - - uses: codecov/codecov-action@v7 + # Pinned to v5: codecov-action@v7 silently stopped uploading coverage in + # the sibling DecisionRules.jl repo (Codecov "Missing Head Commit" on + # PRs); v5 is the last version verified to upload from this workflow + # shape. Before re-bumping, migrate deliberately and confirm a commit + # appears on Codecov. + # Authentication uses OIDC (`use_oidc` + the job's `id-token: write` + # permission) because the CODECOV_TOKEN secret is not set in this repo + # ("Token length: 0" in CI) and tokenless uploads are rejected on + # protected branches. OIDC requires the Codecov GitHub App to be + # installed for the organization AND this repository to be activated on + # codecov.io (it currently is not); if uploads fail with an OIDC error, + # either install the app + activate the repo, or set the CODECOV_TOKEN + # secret and replace `use_oidc` with `token: ${{ secrets.CODECOV_TOKEN }}`. + - uses: codecov/codecov-action@v5 with: files: lcov.info - token: ${{ secrets.CODECOV_TOKEN }} - fail_ci_if_error: false + use_oidc: true + # Fail loudly so upload breakage is visible instead of silent. + fail_ci_if_error: true diff --git a/.gitignore b/.gitignore index a432b01..8f248ab 100644 --- a/.gitignore +++ b/.gitignore @@ -42,3 +42,5 @@ logs/ # Slurm batch scripts (user-specific, not part of the package) *.sbatch *.sh +examples/HydroPowerModels/results/ +*strong.json diff --git a/Project.toml b/Project.toml index 42ea84c..f07852b 100644 --- a/Project.toml +++ b/Project.toml @@ -1,33 +1,42 @@ name = "DecisionRulesExa" uuid = "7c3e91a4-d8f2-4b6a-9e15-a2c4f7b80d53" -authors = ["Andrew Rosemberg and contributors"] version = "0.1.0" +authors = ["Andrew Rosemberg and contributors"] [deps] -ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" +CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b" CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" +ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" ExaModels = "1037b233-b668-4ce9-9b63-f9f681f55dd2" Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c" +JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" +KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" MadNLP = "2621e9c9-9eb4-46b1-8089-e8c72242dfb6" MadNLPGPU = "d72a61cc-809d-412f-99be-fd81f4b8a598" NLPModels = "a4795742-8479-5a88-8948-cc11e1c8c1a6" Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" [compat] +CSV = "0.10.16" CUDA = "6" ChainRulesCore = "1.26" ExaModels = "0.11" Flux = "0.16" +JSON = "1.6.1" MadNLP = "0.10" MadNLPGPU = "0.10" NLPModels = "0.21" +Tables = "1.12.1" Zygote = "0.7" julia = "1.10, 1.11, 1.12" [extras] +Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" [targets] -test = ["Test"] +test = ["Test", "Statistics"] diff --git a/README.md b/README.md index a06eca1..57cc681 100644 --- a/README.md +++ b/README.md @@ -59,6 +59,16 @@ train_tsddr( ) ``` +> **Note on the uncertainty parameter**: `train_tsddr` writes the full sampled +> trajectory (length `T * nw`) into `p_uncertainty` with +> `ExaModels.set_parameter!`, which enforces an exact size match (ExaModels ≥ +> 0.11). The `p_w` built by `build_deterministic_equivalent` / +> `build_linear_tracking_problem` holds only the `(T - 1) * nw` dynamics +> entries, so for `train_tsddr` your NLP needs an uncertainty parameter of +> length `T * nw` (as the Hydro example's `p_inflow` is). See the +> `"train_tsddr open-loop smoke test"` testset in `test/runtests.jl` for a +> minimal full-length variant of the problem above. + For GPU, replace `backend = nothing` with `backend = CUDABackend()` and add `linear_solver = CUDSSSolver` to `madnlp_kwargs`. ## What you need to provide @@ -71,7 +81,59 @@ For a custom problem you need: - **An uncertainty sampler** `() -> w_flat` returning a flat `Float32`/`Float64` vector of length `T * nw`. - **A Flux policy** (LSTM or MLP) mapping `(w_t, x_{t-1})` to target `x_t` at each stage. -The package provides `build_deterministic_equivalent` for generic problems and `build_linear_tracking_problem` as a ready-made demo. For domain-specific models (power systems, robotics), build the ExaModels NLP directly — see `examples/HydroPowerModels/` for a complete AC-OPF example. +The package provides `build_deterministic_equivalent` for generic problems and `build_linear_tracking_problem` as a ready-made demo. For domain-specific models, build the ExaModels NLP directly; `examples/BatteryStorageOPF/` contains an AC-OPF battery example. + +## Strict reachable target equality + +The usual TS-DDR deterministic equivalent uses slack-penalized target +constraints, + +```text +x_t - pi_theta(w_t, x_{t-1}) = delta_t, +objective += rho * penalty(delta_t). +``` + +This is the right default for open-loop target trajectories and for cases where +the policy can request states that are not reachable from the previous realized +state. The target multipliers are then gradients of the penalized projection +problem, so their quality depends on the penalty calibration. + +For policies whose output is guaranteed to lie in a one-stage reachable state +set, a stricter formulation is possible: + +```text +x_t = pi_theta(w_t, x_{t-1}), pi_theta(w_t, x_{t-1}) in R(w_t, x_{t-1}). +``` + +In that case the deterministic equivalent does not need target slack variables +or target penalties. The multiplier on the equality is the local envelope +sensitivity of the true stage problem with respect to the policy-imposed next +state, not the sensitivity of a penalized approximation. This is useful when: + +- users can define a differentiable or piecewise differentiable map into a + subset of the one-stage reachable set; +- total recourse is guaranteed by the model for every state produced by that + map. + +There are two strict hydro paths: + +- **Embedded strict DE** evaluates the policy inside the NLP against realized + reservoir states. This is the usual way to make strict mode safe because the + policy sees the state from which its next target must be reachable. +- **Regular strict DE with reachable rollout** computes targets before solving + the NLP, but starts from the true initial state and feeds the previous target + back to the reachable policy. If + `x̂_t ∈ R(x̂_{t-1}, w_t)` and `x̂_0 = x_0`, the full target path is feasible by + induction. The strict equality then forces the realized path to equal that + reachable target path. + +Do not use strict equality for a generic open-loop target policy. For +unreachable targets, the slack-penalty formulation is the robust fallback. + +The hydro reachable policy keeps recurrence over inflows only. Optional +`combiner_layers` / `DR_HEAD_LAYERS` add a nonlinear feed-forward map from +`[encoded_inflow; reservoir_state]` to targets without adding recurrence over +the state input. ## Parallel GPU solves @@ -217,7 +279,24 @@ Choose DecisionRules.jl when: - [`examples/end_to_end_cpu.jl`](examples/end_to_end_cpu.jl) — minimal CPU demo with a linear tracking problem - [`examples/end_to_end_gpu.jl`](examples/end_to_end_gpu.jl) — same demo on GPU with CUDSS -- [`examples/HydroPowerModels/`](examples/HydroPowerModels/) — full multi-stage hydrothermal scheduling with DC and AC OPF +- [`examples/BatteryStorageOPF/`](examples/BatteryStorageOPF/) — reproducible PGLib AC-OPF cases with linear battery storage + +## Repository Map + +| Path | Purpose | +|---|---| +| `src/DecisionRulesExa.jl` | Module entrypoint and public exports | +| `src/policy.jl` | MLP, state-conditioned LSTM policies, bounded target policies, nonlinear target heads | +| `src/deterministic_equivalent.jl` | Generic open-loop deterministic-equivalent builder and solve helpers | +| `src/embedded_deterministic_equivalent.jl` | Generic embedded-policy deterministic equivalent with nonlinear oracle | +| `src/training.jl` | `train_tsddr`, embedded training, solver retry/warm-start handling | +| `src/rollout.jl` | Stage-wise rollout evaluation for ExaModels problems | +| `src/critic_control_variate.jl` | Scalar critic/control-variate helpers | +| `src/utils.jl` | Indexing and small shared utilities | +| `examples/end_to_end_cpu.jl` | Minimal CPU training demo | +| `examples/end_to_end_gpu.jl` | Minimal GPU training demo | +| `examples/BatteryStorageOPF/` | PGLib AC-OPF battery-storage example | +| `test/runtests.jl` | Unit and smoke tests | ## Citation diff --git a/examples/BatteryStorageOPF/.gitignore b/examples/BatteryStorageOPF/.gitignore new file mode 100644 index 0000000..23662d2 --- /dev/null +++ b/examples/BatteryStorageOPF/.gitignore @@ -0,0 +1,3 @@ +# Generated outputs from run_case300.jl (manifests + battery tables are +# reproducible from the seeded API, so they are not tracked). +results/ diff --git a/examples/BatteryStorageOPF/Project.toml b/examples/BatteryStorageOPF/Project.toml new file mode 100644 index 0000000..e7b92f4 --- /dev/null +++ b/examples/BatteryStorageOPF/Project.toml @@ -0,0 +1,29 @@ +[deps] +ExaModels = "1037b233-b668-4ce9-9b63-f9f681f55dd2" +Ipopt = "b6b21f68-93f8-5de0-b562-5493be1d77c9" +JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +JuMP = "4076af6c-e467-56ae-b986-b466b2749572" +LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +MadNLP = "2621e9c9-9eb4-46b1-8089-e8c72242dfb6" +NLPModels = "a4795742-8479-5a88-8948-cc11e1c8c1a6" +PGLib = "07a8691f-3d11-4330-951b-3c50f98338be" +PowerModels = "c36e90e8-916a-50a6-bd94-075b64ef4655" +Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7" +Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +SHA = "ea8e919c-243c-51af-8825-aaa63cd721ce" +StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3" +Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +TOML = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[compat] +ExaModels = "0.11" +Ipopt = "1.15" +JSON = "1.6" +JuMP = "1.31" +MadNLP = "0.10" +NLPModels = "0.21" +PGLib = "0.2.2" +PowerModels = "0.21" +StableRNGs = "1" +julia = "1.10, 1.11, 1.12" diff --git a/examples/BatteryStorageOPF/README.md b/examples/BatteryStorageOPF/README.md new file mode 100644 index 0000000..4e97264 --- /dev/null +++ b/examples/BatteryStorageOPF/README.md @@ -0,0 +1,274 @@ +# Battery-Storage AC-OPF (deterministic foundation) + +This example builds a **deterministic AC optimal-power-flow (AC-OPF) problem with +batteries** on top of any [PGLib-OPF](https://github.com/power-grid-lib/pglib-opf) +benchmark network, entirely in [ExaModels](https://github.com/exanauts/ExaModels.jl), +and solves it on the CPU with [MadNLP](https://github.com/MadNLP/MadNLP.jl). + +It is **Phase 1** of a larger project: a reproducible battery-case generator plus +the ExaModels model that later phases train (TS-DDR) and benchmark (SDDP) on. This +phase contains **no** training, no uncertainty, and no SDDP — just the case +generator, the model, a reference check, and tests. + +If you have never used Julia or power systems before: you can change three +numbers (the case name, the number of batteries, and a random seed), run one +command, and get a solved battery dispatch with a manifest that lets anyone +reproduce it exactly. + +--- + +## 1. The battery model and units + +Every quantity is **per unit (pu)** on the network's `baseMVA` power base. Energy +is in **pu·hours (pu·h)** and time in **hours**. All unit conversion happens in a +single data layer (`src/network_data.jl`), so the model code never re-scales. + +For each battery `b` and stage `t` (stage length `Δt` hours) the model uses +continuous, non-negative charge/discharge powers and a linear state of charge +`e` (the battery SoC — *not* the SOC-WR relaxation used later by SDDP): + +$$ +0 \le p^{ch}_{t,b} \le \bar p^{ch}_b, \qquad +0 \le p^{dis}_{t,b} \le \bar p^{dis}_b, +$$ + +$$ +e_{t+1,b} = (1-\sigma_b\,\Delta t)\,e_{t,b} + + \eta^{ch}_b\,\Delta t\,p^{ch}_{t,b} + - \frac{\Delta t}{\eta^{dis}_b}\,p^{dis}_{t,b}, +\qquad +\underline e_b \le e_{t,b} \le \bar e_b, +$$ + +$$ +p^{bat}_{t,b} = p^{dis}_{t,b} - p^{ch}_{t,b}. +$$ + +`p_bat` enters the **active** power balance at the battery's bus. Batteries run at +**unity power factor** (no reactive injection). + +**Cost units (read carefully).** The stage objective is + +$$ +\Delta t \sum_g \big(c^{(2)}_g\,pg_{t,g}^2 + c^{(1)}_g\,pg_{t,g} + c^{(0)}_g\big) +\;+\; +\sum_b c^{cycle}_b \,\big(p^{ch}_{t,b} + p^{dis}_{t,b}\big). +$$ + +* **Generator cost** — the PGLib polynomial coefficients + $(c^{(2)}_g, c^{(1)}_g, c^{(0)}_g)$ are **USD per hour** at the stage dispatch + (with `pg` in pu on `baseMVA`). Because a stage lasts $\Delta t$ hours, the + *physical* stage cost is $\Delta t\,(c^{(2)}pg^2 + c^{(1)}pg + c^{(0)})$ — the + factor $\Delta t$ multiplies **every** term, including the constant $c^{(0)}$. + The reported objective is therefore dollars over the whole horizon. (For the + default $\Delta t = 1$ h this equals the raw hourly cost.) +* **Battery cycle cost** — a documented, non-negative **throughput/degradation** + price, computed **per battery**: + $c^{cycle}_b = \text{cycle\_cost\_per\_mwh}_b \cdot \text{baseMVA} \cdot \Delta t$ + (USD/MWh × MW/pu × h), so $c^{cycle}_b\,(p^{ch}+p^{dis})$ is the dollar cost of + that battery's throughput **energy** over the stage. $\Delta t$ is already + folded into $c^{cycle}_b$. Each battery uses its own price — the fleet does not + share a single coefficient. + +The strictly-positive cycle cost keeps the formulation continuous and removes any +incentive to charge and discharge simultaneously (audited by the tests). + +The full network model is the standard **AC-polar OPF**: bus voltage magnitudes +and angles, generator active/reactive dispatch with the original PGLib cost +functions and limits, the four branch power-flow equations, angle-difference +limits, apparent-power thermal limits at both branch ends, and **hard** active +and reactive power balance. There is **no load shedding and no reactive slack** — +balance is enforced exactly. + +Sizing is derived from **declared system quantities only** (never from generator +prices): the fleet charge/discharge power is `fleet_power_fraction · Σ load`, +split equally across batteries, and each battery's energy capacity is +`power · duration_hours`. + +--- + +## 2. File inventory + +``` +examples/BatteryStorageOPF/ +├── Project.toml # pinned example environment +├── Manifest.toml # resolved versions (created by setup) +├── setup_env.jl # one-shot dependency resolver +├── run_case300.jl # CPU smoke runner (any case via env vars) +├── README.md # this file +├── src/ +│ ├── BatteryStorageOPF.jl # module; includes the files below +│ ├── network_data.jl # typed per-unit PGLib parsing + stable id maps +│ ├── battery_data.jl # battery structs + make_battery_case + validation +│ ├── manifest.jl # manifest write / hash / reconstruct +│ ├── battery_opf_exa.jl # ExaModels AC-polar deterministic equivalent +│ └── reference_powermodels.jl # independent PowerModels/JuMP+Ipopt ACP check +└── test/ + └── runtests.jl # example-local test suite +``` + +--- + +## 3. Environment setup + +This example has its own environment; it does **not** use the parent package's. + +```bash +module load julia # Julia 1.11+ +cd examples/BatteryStorageOPF +julia --pkgimages=no --project=. setup_env.jl +``` + +> **Why `--pkgimages=no`?** On this cluster the system Julia cannot build the +> native precompile image for the `Pkg` standard library (a MadNLP dependency), +> which aborts a normal load. Disabling native package images sidesteps that; the +> model and solver are otherwise unaffected. **Use `--pkgimages=no` on every +> command below.** (The first run of each command JIT-compiles from source and +> may take a few minutes; subsequent runs in the same session are fast.) + +The dependencies download the PGLib-OPF **23.07** benchmark artifact once; no +network access is needed afterwards. + +--- + +## 4. Run case300 (one command) + +```bash +julia --pkgimages=no --project=. run_case300.jl +``` + +This builds `case300_ieee` with 20 reproducibly-placed batteries (seed +`20260722`), writes a manifest, builds a 4-stage ExaModels AC-polar model, and +solves it on the CPU. + +### Expected output (abridged) + +``` +Building battery case "case300_ieee" (batteries=20, seed=20260722) + network: 300 buses, 69 gens, 411 branches, 201 loads, baseMVA=100.0 + total load = 235.2585 pu ; eligible load buses = 191 + battery buses (stable order) = [247, 104, 215, 211, 178, 201, 141, 135, 79, 21, 11, 234, 156, 73, 77, 175, 209, 9533, 10, 167] + per-battery: p̄=2.9407 pu, e_max=11.7629 pu·h, e_init=5.8815 pu·h, η=0.95/0.95 + manifest hash = 002af1ee461dae3cec4dc1b29e0582e3bac81916ca9997853bd2869a5beeb93e + wrote results/manifest_case300_ieee_seed20260722.json + results/batteries_case300_ieee_seed20260722.csv + +Building ExaModels AC-polar DE (T=4, Δt=1.0 h) ... +Solving on CPU with MadNLP ... + +── Results ───────────────────────────────────────────── +status : SOLVE_SUCCEEDED +accepted : true +objective (USD) : 1903529.258329 +solve time (s) : ~30 +max primal residual : 3.350e-07 +max |battery balance|: 7.550e-15 +max simultaneous charge/discharge power : 1.658e-08 pu +SoC[:,1] (init) : [5.8815, 5.8815, ... ] +SoC[:,end] (final) : [-0.0, -0.0, ... , 4.6325, -0.0, -0.0] +Σ discharge (pu) : 107.3469 ; Σ charge (pu) : 0.0000 +──────────────────────────────────────────────────────── +``` + +The batteries discharge their stored energy over the horizon (the SoC drains +from 5.88 to ~0 pu·h); with a flat/gentle load shape there is no arbitrage +incentive to charge. The tiny **max simultaneous charge/discharge power** (the +smaller of the two powers per battery, in pu — not a product) and the +machine-precision battery-balance residual confirm the continuous formulation +behaves as intended. Exact numbers can vary slightly across solver builds. + +The two files under `results/` are the machine-readable manifest and a +human-readable battery table. + +--- + +## 5. Change the case, battery count, and seed + +`run_case300.jl` reads four environment variables: + +```bash +# A different network, 3 batteries, a different seed, a 6-stage horizon: +BAT_CASE=case14_ieee BAT_NBAT=3 BAT_SEED=1 BAT_HORIZON=6 \ + julia --pkgimages=no --project=. run_case300.jl +``` + +Or from the Julia API directly: + +```julia +include("src/BatteryStorageOPF.jl"); using .BatteryStorageOPF +case = make_battery_case("case300_ieee"; + number_of_batteries = 20, + seed = 20260722, + duration_hours = 4.0, # energy/power ratio (a "4-hour battery") + initial_soc = 0.5, # fraction of energy capacity + charge_efficiency = 0.95, + discharge_efficiency= 0.95) +prob = build_battery_de(case, 4; stage_hours = 1.0) +result = solve_de!(prob) # named solve_de! (avoids clashing with CommonSolve.solve!) +``` + +List every available benchmark with `available_pglib_cases()`. Names resolve +leniently (`"case300_ieee"`, `"pglib_opf_case300_ieee"`, or the `.m` file name); +missing or ambiguous names raise an actionable error. + +--- + +## 6. A second, small PGLib example + +`case14_ieee` (14 buses) solves in a second and is handy for experimentation: + +```bash +BAT_CASE=case14_ieee BAT_NBAT=3 BAT_SEED=7 BAT_HORIZON=4 \ + julia --pkgimages=no --project=. run_case300.jl +``` + +The same API works for **any** PGLib case — only the name changes. + +--- + +## 7. Tests + +```bash +julia --pkgimages=no --project=. test/runtests.jl +``` + +The suite checks reproducible placement and manifest hashing, reconstruction +from a manifest, input validation, non-consecutive identifier mapping, the +case300 structure (300 buses, 20 distinct valid battery buses), an accepted +solve with small primal and battery-balance residuals, the absence of +simultaneous charge/discharge, and **base-ACP parity**: with zero batteries or +zero battery power the ExaModels objective matches the independent +PowerModels/Ipopt reference. + +--- + +## 8. Attribution and reproducibility + +**Network data & license.** Networks come from the *Power Grid Library for +Benchmarking AC Optimal Power Flow Algorithms* (PGLib-OPF), release **23.07**, +distributed via `PGLib.jl`. PGLib-OPF is licensed under the **Creative Commons +Attribution 4.0 International** license +(). Please cite +S. Babaeinejadsarookolaee *et al.*, "The Power Grid Library for Benchmarking AC +Optimal Power Flow Algorithms," arXiv:1908.02788. The manifest records the exact +MATPOWER filename, its SHA-256, the upstream release, the license name and URL, +the attribution/citation, and the PGLib.jl / PowerModels.jl / Julia versions. + +**Reproducibility.** Battery placement is a seeded, uniform-without-replacement +sample of eligible load buses using `StableRNGs` (stable across Julia versions). +`make_battery_case` records the exact case, the **SHA-256 of the MATPOWER source +bytes**, the seed, eligible-bus rule, selected buses (in stable order), all +battery parameters and units, package/artifact versions, and a **SHA-256 content +hash** (which itself includes the source-file hash). `write_manifest` serializes +this to JSON. `reconstruct_case(manifest)` does not claim a "byte-identical" +rebuild loosely — it verifies three concrete things and errors on any mismatch: + +1. **source network bytes** — the SHA-256 of the currently resolved MATPOWER file + equals the recorded `matpower_sha256` (checked first, so a changed or tampered + network file is rejected outright); +2. **ordered placement** — the rebuilt battery buses match `selected_bus_ids` in + order; +3. **battery parameters** — the rebuilt content hash equals the recorded one. + +The same seed always yields the same ordered placement and hash; a different seed +yields a reproducibly different placement. diff --git a/examples/BatteryStorageOPF/run_case300.jl b/examples/BatteryStorageOPF/run_case300.jl new file mode 100644 index 0000000..6bd1f29 --- /dev/null +++ b/examples/BatteryStorageOPF/run_case300.jl @@ -0,0 +1,92 @@ +#!/usr/bin/env julia +# run_case300.jl +# +# CPU smoke runner for the deterministic battery-storage AC-OPF foundation. +# Builds a reproducible battery case from a PGLib benchmark, writes its manifest +# + human-readable battery file, builds a short-horizon ExaModels AC-polar +# deterministic equivalent, solves it on the CPU with MadNLP, and reports the +# solver status, objective, residuals, chosen battery buses, and manifest hash. +# +# Run (from examples/BatteryStorageOPF): +# module load julia +# julia --pkgimages=no --project=. run_case300.jl +# +# Change the case / battery count / seed / horizon via environment variables: +# BAT_CASE=case14_ieee BAT_NBAT=3 BAT_SEED=1 BAT_HORIZON=4 \ +# julia --pkgimages=no --project=. run_case300.jl + +include(joinpath(@__DIR__, "src", "BatteryStorageOPF.jl")) +using .BatteryStorageOPF +using MadNLP +using Printf + +const CASE = get(ENV, "BAT_CASE", "case300_ieee") +const NBAT = parse(Int, get(ENV, "BAT_NBAT", "20")) +const SEED = parse(Int, get(ENV, "BAT_SEED", "20260722")) +const HORIZON = parse(Int, get(ENV, "BAT_HORIZON", "4")) +const OUTDIR = get(ENV, "BAT_OUTDIR", joinpath(@__DIR__, "results")) + +function main() + mkpath(OUTDIR) + @printf("Building battery case \"%s\" (batteries=%d, seed=%d)\n", CASE, NBAT, SEED) + case = make_battery_case(CASE; number_of_batteries = NBAT, seed = SEED) + nd = case.network + + @printf(" network: %d buses, %d gens, %d branches, %d loads, baseMVA=%.1f\n", + nbus(nd), ngen(nd), nbranch(nd), nload(nd), nd.baseMVA) + @printf(" total load = %.4f pu ; eligible load buses = %d\n", + case.total_load_pu, length(case.eligible_bus_ids)) + @printf(" battery buses (stable order) = %s\n", string(case.selected_bus_ids)) + if !isempty(case.batteries) + b = case.batteries[1] + @printf(" per-battery: p̄=%.4f pu, e_max=%.4f pu·h, e_init=%.4f pu·h, η=%.2f/%.2f\n", + b.p_charge_max, b.e_max, b.e_init, b.eta_ch, b.eta_dis) + end + + hash = manifest_hash(case) + man_path = joinpath(OUTDIR, "manifest_$(CASE)_seed$(SEED).json") + bat_path = joinpath(OUTDIR, "batteries_$(CASE)_seed$(SEED).csv") + write_battery_file(case, bat_path) + write_manifest(case, man_path; extra_files = [bat_path]) + @printf(" manifest hash = %s\n", hash) + @printf(" wrote %s\n %s\n", man_path, bat_path) + + # Short horizon with a gentle time-of-day load shape (±3%) so the batteries + # cycle (peak/off-peak arbitrage) — exercises the state equation — while + # staying within the base case's feasible region. + profile = HORIZON == 4 ? [1.00, 1.03, 1.00, 0.97] : + [1.0 + 0.03 * sinpi(2 * (t - 1) / HORIZON) for t in 1:HORIZON] + @printf("\nBuilding ExaModels AC-polar DE (T=%d, Δt=1.0 h) ...\n", HORIZON) + prob = build_battery_de(case, HORIZON; stage_hours = 1.0, demand_profile = profile) + + @printf("Solving on CPU with MadNLP ...\n") + t0 = time() + result = solve_de!(prob; print_level = MadNLP.ERROR, tol = 1e-6, max_iter = 1000) + dt = time() - t0 + + sol = battery_solution(prob, result) + prim = max_primal_residual(prob, result) + balres = battery_balance_residuals(prob, sol) + simult = simultaneous_charge_discharge_power(sol) + + println("\n── Results ─────────────────────────────────────────────") + @printf("status : %s\n", string(result.status)) + @printf("accepted : %s\n", solve_succeeded(result.status)) + @printf("objective (USD) : %.6f\n", result.objective) + @printf("solve time (s) : %.2f\n", dt) + @printf("max primal residual : %.3e\n", prim) + if !isempty(case.batteries) + @printf("max |battery balance|: %.3e\n", maximum(abs, balres)) + @printf("max simultaneous charge/discharge power : %.3e pu\n", maximum(simult)) + @printf("SoC[:,1] (init) : %s\n", string(round.(sol.soc[:, 1], digits = 4))) + @printf("SoC[:,end] (final) : %s\n", string(round.(sol.soc[:, end], digits = 4))) + @printf("Σ discharge (pu) : %.4f ; Σ charge (pu) : %.4f\n", + sum(sol.p_dis), sum(sol.p_ch)) + end + println("────────────────────────────────────────────────────────") + + solve_succeeded(result.status) || error("smoke solve did not reach an accepted status") + return nothing +end + +main() diff --git a/examples/BatteryStorageOPF/setup_env.jl b/examples/BatteryStorageOPF/setup_env.jl new file mode 100644 index 0000000..6a23f34 --- /dev/null +++ b/examples/BatteryStorageOPF/setup_env.jl @@ -0,0 +1,42 @@ +# setup_env.jl +# +# One-shot helper that resolves the BatteryStorageOPF example environment. +# It activates THIS directory and adds the pinned dependency set, letting Pkg +# fetch the correct UUIDs and a mutually compatible set of versions from the +# registry. Run once (or after deleting Manifest.toml): +# +# module load julia +# julia --project=examples/BatteryStorageOPF examples/BatteryStorageOPF/setup_env.jl +# +# The depot lives in /tmp per project policy; do not redirect it elsewhere. + +import Pkg +Pkg.activate(@__DIR__) + +# User-facing PGLib benchmark source + power-flow modeling stack, the ExaModels +# builder + its CPU NLP solver (MadNLP), the independent JuMP/Ipopt reference, +# the seeded RNG for reproducible placement, and JSON/SHA for the manifest. +Pkg.add([ + Pkg.PackageSpec(name = "PGLib"), + Pkg.PackageSpec(name = "PowerModels"), + Pkg.PackageSpec(name = "StableRNGs"), + Pkg.PackageSpec(name = "ExaModels"), + Pkg.PackageSpec(name = "MadNLP"), + Pkg.PackageSpec(name = "NLPModels"), + Pkg.PackageSpec(name = "JuMP"), + Pkg.PackageSpec(name = "Ipopt"), + Pkg.PackageSpec(name = "JSON"), + # Standard libraries used directly by the example (must be explicit deps in + # a project environment). + Pkg.PackageSpec(name = "TOML"), + Pkg.PackageSpec(name = "SHA"), + Pkg.PackageSpec(name = "Random"), + Pkg.PackageSpec(name = "LinearAlgebra"), + Pkg.PackageSpec(name = "Test"), + Pkg.PackageSpec(name = "Statistics"), + Pkg.PackageSpec(name = "Printf"), +]) + +Pkg.precompile() + +@info "BatteryStorageOPF environment resolved" project = Base.active_project() diff --git a/examples/BatteryStorageOPF/src/BatteryStorageOPF.jl b/examples/BatteryStorageOPF/src/BatteryStorageOPF.jl new file mode 100644 index 0000000..25ffcd1 --- /dev/null +++ b/examples/BatteryStorageOPF/src/BatteryStorageOPF.jl @@ -0,0 +1,48 @@ +# BatteryStorageOPF.jl +# +# Self-contained example module: a deterministic ExaModels AC-OPF foundation for +# battery-storage dispatch, plus a reproducible PGLib battery-case generator. +# (Phase 1 of BATTERY_STORAGE_OPF_PLAN.md; no TS-DDR / SDDP / uncertainty here.) +# +# Load it from the example environment: +# +# module load julia +# julia --pkgimages=no --project=. -e 'include("src/BatteryStorageOPF.jl")' +# +# `--pkgimages=no` is required on this cluster: the system Julia cannot build +# the native precompile image for the `Pkg` stdlib (a MadNLP dependency), so the +# example is run with native pkgimages disabled. Everything else is standard. + +module BatteryStorageOPF + +using TOML + +# Order matters: data layer → case construction → manifest → model → reference. +include("network_data.jl") +include("battery_data.jl") +include("manifest.jl") +include("battery_opf_exa.jl") +include("reference_powermodels.jl") + +# ── Public API ──────────────────────────────────────────────────────────────── +# Network / case construction +export NetworkData, BusData, GenData, BranchData, LoadData +export nbus, ngen, nbranch, nload +export resolve_pglib_case, available_pglib_cases, load_pglib_network, parse_network +export BatteryData, BatteryCase, nbattery +export make_battery_case, validate_battery_case, eligible_load_bus_ids + +# Manifest +export battery_manifest, manifest_hash, canonical_content +export write_manifest, write_battery_file, reconstruct_case + +# ExaModels model +export BatteryExaProblem, build_battery_de, solve_de!, solve_succeeded +export set_demand!, set_initial_soc! +export battery_solution, battery_balance_residuals +export simultaneous_charge_discharge_power, max_primal_residual + +# Reference / parity +export reference_ac_opf, exa_base_objective, check_base_acp_parity + +end # module diff --git a/examples/BatteryStorageOPF/src/battery_data.jl b/examples/BatteryStorageOPF/src/battery_data.jl new file mode 100644 index 0000000..8c3b2a5 --- /dev/null +++ b/examples/BatteryStorageOPF/src/battery_data.jl @@ -0,0 +1,269 @@ +# battery_data.jl +# +# Validated battery structures and the seeded, reproducible case-construction +# API `make_battery_case`. All battery quantities are per unit on the network +# `baseMVA` (power in pu, energy in pu·h), consistent with the one conversion +# layer in network_data.jl. + +using StableRNGs +using Random + +# ── Battery model (see BATTERY_STORAGE_OPF_PLAN.md §4) ───────────────────────── + +""" + BatteryData + +One battery, per unit on the network `baseMVA`. + +* `id` : 1-based battery index; equals placement order (stable). +* `bus_id`,`bus_pos` : host bus original PGLib id and array position. +* `p_charge_max` : max charge power p̄ᶜʰ (pu), applied as `0 ≤ pᶜʰ ≤ p̄ᶜʰ`. +* `p_discharge_max` : max discharge power p̄ᵈⁱˢ (pu), `0 ≤ pᵈⁱˢ ≤ p̄ᵈⁱˢ`. +* `e_min`,`e_max` : energy bounds e (pu·h), `e_min ≤ e ≤ e_max`. +* `e_init` : initial state of charge (pu·h). +* `eta_ch`,`eta_dis` : charge / discharge efficiencies in (0, 1]. +* `sigma` : self-discharge rate σ (per hour); state keeps `(1 − σΔt)`. +* `cycle_cost_per_mwh`: nonnegative throughput/degradation price (\$/MWh). The + objective charges `cycle_cost_per_mwh · baseMVA · Δt · (pᶜʰ + pᵈⁱˢ)` — the + dollar degradation cost of the throughput energy — which keeps the model + continuous and removes any incentive for simultaneous charge/discharge. + +State equation (linear): + `e_{t+1} = (1 − σΔt)·e_t + η_ch·Δt·pᶜʰ_t − (Δt/η_dis)·pᵈⁱˢ_t`, +active injection into the host bus: `p_bat = pᵈⁱˢ − pᶜʰ` (unity power factor). +""" +struct BatteryData + id::Int + bus_id::Int + bus_pos::Int + p_charge_max::Float64 + p_discharge_max::Float64 + e_min::Float64 + e_max::Float64 + e_init::Float64 + eta_ch::Float64 + eta_dis::Float64 + sigma::Float64 + cycle_cost_per_mwh::Float64 +end + +""" + BatteryCase + +A network plus its reproducibly-placed battery fleet and the full record needed +to rebuild it byte-identically (seed, sampling rule, sizing parameters, units). +""" +struct BatteryCase + network::NetworkData + batteries::Vector{BatteryData} + # placement / configuration record (mirrored into the manifest) + case_name::String + seed::Int + number_of_batteries::Int + duration_hours::Float64 + initial_soc::Float64 + charge_efficiency::Float64 + discharge_efficiency::Float64 + fleet_power_fraction::Float64 + self_discharge_rate::Float64 + e_min_fraction::Float64 + cycle_cost_per_mwh::Float64 + eligible_bus_rule::String + eligible_bus_ids::Vector{Int} + selected_bus_ids::Vector{Int} # stable placement order + explicit_buses::Bool + total_load_pu::Float64 + parse_meta::NamedTuple +end + +nbattery(bc::BatteryCase) = length(bc.batteries) + +# ── Eligible-bus rule ───────────────────────────────────────────────────────── + +""" + eligible_load_bus_ids(network) -> Vector{Int} + +Default battery placement pool: original ids of buses hosting at least one +in-service load with strictly positive active demand, sorted ascending. Sorting +by original id makes the sampling reproducible independent of parse order. +""" +function eligible_load_bus_ids(network::NetworkData) + ids = Int[] + for (pos, b) in enumerate(network.buses) + network.bus_pd[pos] > 0 && push!(ids, b.id) + end + return sort!(ids) +end + +const ELIGIBLE_BUS_RULE = "in_service_load_buses_with_positive_active_demand" + +# ── Case construction ───────────────────────────────────────────────────────── + +""" + make_battery_case(case_name; + number_of_batteries = 20, + seed = 20260722, + duration_hours = 4.0, + initial_soc = 0.5, + charge_efficiency = 0.95, + discharge_efficiency= 0.95, + fleet_power_fraction= 0.25, + self_discharge_rate = 0.0, + e_min_fraction = 0.0, + cycle_cost_per_mwh = 2.0, + buses = nothing, + ) -> BatteryCase + +Build a reproducible battery-storage AC-OPF case from a PGLib benchmark. + +Steps: resolve `case_name` in the pinned PGLib artifact; parse it into per-unit +[`NetworkData`]; determine the eligible-bus pool; sample `number_of_batteries` +distinct host buses **uniformly without replacement** with `StableRNG(seed)` +(unless explicit `buses` are given); derive per-battery power/energy ratings +from declared system quantities; validate every bound; and return a typed +[`BatteryCase`]. + +Sizing rule (declared, price-free): the fleet charge/discharge power is +`fleet_power_fraction · Σ load` (pu), split equally across batteries; each +battery's energy capacity is `power · duration_hours` (pu·h). This depends only +on system load and the base, never on generator prices. + +`buses` (optional) is an explicit vector of original PGLib bus ids used in the +given order instead of sampling; its length must equal `number_of_batteries`. + +All numeric inputs are validated; invalid counts, buses, efficiencies, +capacities, SoC, self-discharge, or ambiguous case names raise actionable errors. +""" +function make_battery_case(case_name::AbstractString; + number_of_batteries::Integer = 20, + seed::Integer = 20260722, + duration_hours::Real = 4.0, + initial_soc::Real = 0.5, + charge_efficiency::Real = 0.95, + discharge_efficiency::Real = 0.95, + fleet_power_fraction::Real = 0.25, + self_discharge_rate::Real = 0.0, + e_min_fraction::Real = 0.0, + cycle_cost_per_mwh::Real = 2.0, + buses = nothing) + + # ── Validate scalar inputs up front (actionable messages) ───────────────── + number_of_batteries >= 0 || + error("number_of_batteries must be ≥ 0; got $number_of_batteries") + (isfinite(duration_hours) && duration_hours > 0) || + error("duration_hours must be finite and > 0; got $duration_hours") + (0 <= e_min_fraction < 1) || + error("e_min_fraction must satisfy 0 ≤ e_min_fraction < 1; got $e_min_fraction") + (e_min_fraction <= initial_soc <= 1) || + error("initial_soc must satisfy e_min_fraction ($e_min_fraction) ≤ initial_soc ≤ 1; " * + "got $initial_soc") + (0 < charge_efficiency <= 1) || + error("charge_efficiency must satisfy 0 < η_ch ≤ 1; got $charge_efficiency") + (0 < discharge_efficiency <= 1) || + error("discharge_efficiency must satisfy 0 < η_dis ≤ 1; got $discharge_efficiency") + (isfinite(fleet_power_fraction) && fleet_power_fraction >= 0) || + error("fleet_power_fraction must be finite and ≥ 0; got $fleet_power_fraction") + (isfinite(self_discharge_rate) && 0 <= self_discharge_rate < 1) || + error("self_discharge_rate σ must satisfy 0 ≤ σ < 1 (per hour); got $self_discharge_rate") + (isfinite(cycle_cost_per_mwh) && cycle_cost_per_mwh >= 0) || + error("cycle_cost_per_mwh must be finite and ≥ 0; got $cycle_cost_per_mwh") + + # ── Resolve + parse the PGLib network ───────────────────────────────────── + network, parse_meta = load_pglib_network(case_name) + eligible = eligible_load_bus_ids(network) + total_load_pu = sum(network.bus_pd) + + # ── Determine host buses (explicit or sampled) ──────────────────────────── + explicit = buses !== nothing + local selected::Vector{Int} + if explicit + selected = Int.(collect(buses)) + length(selected) == number_of_batteries || + error("explicit `buses` has $(length(selected)) entries but " * + "number_of_batteries = $number_of_batteries") + length(unique(selected)) == length(selected) || + error("explicit `buses` contains duplicate bus ids") + for bid in selected + haskey(network.bus_id_to_pos, bid) || + error("explicit bus id $bid is not an in-service bus of \"$(network.case_name)\"") + end + else + number_of_batteries <= length(eligible) || + error("cannot place $number_of_batteries batteries: only " * + "$(length(eligible)) eligible load buses in \"$(network.case_name)\". " * + "Reduce number_of_batteries or pass explicit `buses`.") + # Uniform sampling without replacement: a seeded shuffle of the eligible + # pool, first k entries. The shuffle order IS the stable placement order. + rng = StableRNG(UInt64(unsigned(Int64(seed)))) + selected = Random.shuffle(rng, eligible)[1:number_of_batteries] + end + + # ── Derive per-battery ratings from declared system quantities ──────────── + fleet_power = fleet_power_fraction * total_load_pu + per_power = number_of_batteries == 0 ? 0.0 : fleet_power / number_of_batteries + e_max = per_power * duration_hours + e_min = e_min_fraction * e_max + e_init = initial_soc * e_max + + batteries = BatteryData[] + for (i, bid) in enumerate(selected) + push!(batteries, BatteryData(i, bid, network.bus_id_to_pos[bid], + per_power, per_power, + e_min, e_max, e_init, + Float64(charge_efficiency), + Float64(discharge_efficiency), + Float64(self_discharge_rate), + Float64(cycle_cost_per_mwh))) + end + + bc = BatteryCase(network, batteries, network.case_name, Int(seed), + Int(number_of_batteries), Float64(duration_hours), + Float64(initial_soc), Float64(charge_efficiency), + Float64(discharge_efficiency), Float64(fleet_power_fraction), + Float64(self_discharge_rate), Float64(e_min_fraction), + Float64(cycle_cost_per_mwh), + explicit ? "explicit_buses" : ELIGIBLE_BUS_RULE, + eligible, selected, explicit, total_load_pu, parse_meta) + + validate_battery_case(bc) + return bc +end + +""" + validate_battery_case(bc) -> BatteryCase + +Post-construction invariants (defence in depth on top of `make_battery_case`'s +input checks): distinct valid host buses, ordered non-degenerate energy bounds, +initial SoC inside its band, sane efficiencies, nonnegative powers and +throughput cost, and a stable-order selection consistent with the batteries. +Throws on the first violation; returns `bc` when all hold. +""" +function validate_battery_case(bc::BatteryCase) + nd = bc.network + seen = Set{Int}() + for b in bc.batteries + haskey(nd.bus_id_to_pos, b.bus_id) || + error("battery $(b.id) is on unknown bus $(b.bus_id)") + nd.bus_id_to_pos[b.bus_id] == b.bus_pos || + error("battery $(b.id) bus_pos $(b.bus_pos) inconsistent with map") + b.bus_id in seen && error("duplicate battery bus $(b.bus_id)") + push!(seen, b.bus_id) + (b.p_charge_max >= 0 && b.p_discharge_max >= 0) || + error("battery $(b.id) has negative power rating") + (b.e_min <= b.e_max) || + error("battery $(b.id) has e_min ($(b.e_min)) > e_max ($(b.e_max))") + (b.e_min - 1e-12 <= b.e_init <= b.e_max + 1e-12) || + error("battery $(b.id) initial SoC $(b.e_init) outside [$(b.e_min), $(b.e_max)]") + (0 < b.eta_ch <= 1 && 0 < b.eta_dis <= 1) || + error("battery $(b.id) has an efficiency outside (0, 1]") + (0 <= b.sigma < 1) || + error("battery $(b.id) has self-discharge σ = $(b.sigma) outside [0, 1)") + (b.cycle_cost_per_mwh >= 0) || + error("battery $(b.id) has negative cycle cost") + end + length(bc.selected_bus_ids) == length(bc.batteries) || + error("selected_bus_ids length disagrees with batteries") + all(bc.selected_bus_ids[i] == bc.batteries[i].bus_id for i in 1:length(bc.batteries)) || + error("selected_bus_ids order disagrees with battery placement order") + return bc +end diff --git a/examples/BatteryStorageOPF/src/battery_opf_exa.jl b/examples/BatteryStorageOPF/src/battery_opf_exa.jl new file mode 100644 index 0000000..56a428c --- /dev/null +++ b/examples/BatteryStorageOPF/src/battery_opf_exa.jl @@ -0,0 +1,475 @@ +# battery_opf_exa.jl +# +# Full-horizon ExaModels AC-polar deterministic equivalent for the +# battery-storage OPF (BATTERY_STORAGE_OPF_PLAN.md §4). Built directly in +# ExaModels — no JuMP, no MOI. +# +# Model (T stages, stage length Δt hours): +# min Σ_t [ Σ_g (c2_g·pg² + c1_g·pg + c0_g) +# + Σ_b c_cycle·(pᶜʰ_{t,b} + pᵈⁱˢ_{t,b}) ] +# s.t. AC-polar power flow (ref angle, 4 branch-flow eqs, angle limits, +# apparent-power thermal limits at both ends); +# hard active balance incl. battery injection p_bat = pᵈⁱˢ − pᶜʰ; +# hard reactive balance (no reactive slack, unity-PF batteries); +# e_{1,b} = e_init,b; +# e_{t+1,b} = (1−σ_bΔt)·e_{t,b} + η_ch,b·Δt·pᶜʰ − (Δt/η_dis,b)·pᵈⁱˢ; +# 0 ≤ pᶜʰ ≤ p̄ᶜʰ, 0 ≤ pᵈⁱˢ ≤ p̄ᵈⁱˢ, e_min ≤ e ≤ e_max. +# +# There is NO load-shedding variable and NO reactive-slack variable: balance is +# hard on both axes. Batteries support arbitrary (non-consecutive) host-bus ids +# through the network's stable id→position maps. + +using ExaModels +using MadNLP +using NLPModels +using LinearAlgebra + +# ── Flat index helpers (stage-major: (t,i) → (t-1)*n + i) ───────────────────── +@inline _bidx(nB, t, b) = (t - 1) * nB + b # bus (t = 1..T) +@inline _gidx(nG, t, g) = (t - 1) * nG + g # generator (t = 1..T) +@inline _bridx(nBR, t, r) = (t - 1) * nBR + r # branch (t = 1..T) +@inline _kidx(nK, t, k) = (t - 1) * nK + k # battery power (t = 1..T) +@inline _eidx(nK, t, k) = (t - 1) * nK + k # battery SoC (t = 1..T+1) + +# ExaModelsPower-compatible branch coefficients c1..c8 (AC polar), matching the +# convention used throughout this project. See the docstring block below for the +# resulting power-flow expressions. +function _ac_branch_coeffs(br::BranchData, ::Type{T}) where {T} + r2x2 = br.br_r^2 + br.br_x^2 + g = r2x2 > 0 ? T(br.br_r / r2x2) : zero(T) + b = r2x2 > 0 ? T(-br.br_x / r2x2) : zero(T) + tap = T(br.tap); sh = T(br.shift) + tr = tap * cos(sh); ti = tap * sin(sh) + ttm = tr^2 + ti^2 + ttm = ttm > 0 ? ttm : one(T) + return ( + c1 = (-g * tr - b * ti) / ttm, + c2 = (-b * tr + g * ti) / ttm, + c3 = (-g * tr + b * ti) / ttm, + c4 = (-b * tr - g * ti) / ttm, + c5 = (g + T(br.g_fr)) / ttm, + c6 = (b + T(br.b_fr)) / ttm, + c7 = g + T(br.g_to), + c8 = b + T(br.b_to), + ) +end + +""" + BatteryExaProblem + +Holds the ExaModels deterministic equivalent for a [`BatteryCase`]. + +Fields: the `core`/`model`, the tunable parameters (`p_pd`, `p_qd`, `p_e0`), +problem sizes, horizon `T`, stage length `dt` (hours), the per-battery cycle-cost +coefficients (`cycle_coeffs`), and back-references to the case for extraction. +""" +struct BatteryExaProblem + core + model + p_pd # active demand parameter (length T*nBus) + p_qd # reactive demand parameter (length T*nBus) + p_e0 # initial-SoC parameter (length nBat) + nBus::Int + nGen::Int + nBranch::Int + nBat::Int + horizon::Int + dt::Float64 + # Per-battery cycle-cost objective coefficient (length nBat): entry k is + # cycle_cost_per_mwh_k · baseMVA · Δt, the $/pu weight on (pᶜʰ_k + pᵈⁱˢ_k). + cycle_coeffs::Vector{Float64} + case::BatteryCase + float_type::Type +end + +""" + build_battery_de(case, T; backend=nothing, float_type=Float64, + stage_hours=1.0, demand_profile=ones(T)) -> BatteryExaProblem + +Build the `T`-stage ExaModels AC-polar deterministic equivalent for `case`. + +Generator costs are PGLib polynomial USD/HOUR values, so each stage contributes +`Δt·(c2·pg² + c1·pg + c0)` to the objective (Δt = `stage_hours`); the battery +cycle cost `cᵦ·(pᶜʰ + pᵈⁱˢ)` already includes Δt through `cᵦ`. The reported +objective is therefore dollars over the whole horizon. + +* `stage_hours` — Δt, the physical length of one stage in hours (default 1.0). +* `demand_profile` — length-`T` vector of per-stage load multipliers applied to + BOTH active and reactive demand (preserving each bus's power factor); default + all ones (flat base demand). + +`backend=nothing` builds on the CPU. Requires `σ·Δt < 1` for every battery so +the self-discharge factor `(1 − σΔt)` stays positive. +""" +function build_battery_de(case::BatteryCase, T::Int; + backend = nothing, + float_type::Type{<:AbstractFloat} = Float64, + stage_hours::Real = 1.0, + demand_profile::AbstractVector = ones(T)) + T >= 1 || error("horizon T must be ≥ 1; got $T") + length(demand_profile) == T || + error("demand_profile must have length T=$T; got $(length(demand_profile))") + dt = Float64(stage_hours) + (isfinite(dt) && dt > 0) || + error("stage_hours (Δt) must be finite and > 0; got $dt") + for b in case.batteries + b.sigma * dt < 1 || + error("battery $(b.id) has σ·Δt = $(b.sigma*dt) ≥ 1; " * + "reduce stage_hours or self_discharge_rate") + end + + nd = case.network + nBus = nbus(nd); nGen = ngen(nd); nBranch = nbranch(nd) + nBat = length(case.batteries) + baseMVA = float_type(nd.baseMVA) + + # Concrete (immutable) ExaCore + the supported functional builder API + # (`add_var`/`add_par`/`add_obj`/`add_con`/`add_con!`), each returning + # `(new_core, handle)`. Handles carry their own offsets and stay valid as the + # core grows, so we thread `core` through and keep the handles. This is the + # non-deprecated path for ExaModels 0.11.2 (`ExaCore()` without `concrete` + # returns the deprecated LegacyExaCore and warns). + core = ExaModels.ExaCore(float_type; backend = backend, concrete = Val(true)) + + # ── Variables ───────────────────────────────────────────────────────────── + core, va = ExaModels.add_var(core, T * nBus) + core, vm = ExaModels.add_var(core, T * nBus; + lvar = float_type.(repeat([b.vmin for b in nd.buses], T)), + uvar = float_type.(repeat([b.vmax for b in nd.buses], T)), + start = ones(float_type, T * nBus)) + core, pg = ExaModels.add_var(core, T * nGen; + lvar = float_type.(repeat([g.pmin for g in nd.gens], T)), + uvar = float_type.(repeat([g.pmax for g in nd.gens], T))) + core, qg = ExaModels.add_var(core, T * nGen; + lvar = float_type.(repeat([isfinite(g.qmin) ? g.qmin : -1e4 for g in nd.gens], T)), + uvar = float_type.(repeat([isfinite(g.qmax) ? g.qmax : 1e4 for g in nd.gens], T))) + fr_lb = float_type.(repeat([isfinite(b.rate_a) ? -b.rate_a : -1e4 for b in nd.branches], T)) + fr_ub = float_type.(repeat([isfinite(b.rate_a) ? b.rate_a : 1e4 for b in nd.branches], T)) + core, p_fr = ExaModels.add_var(core, T * nBranch; lvar = fr_lb, uvar = fr_ub) + core, q_fr = ExaModels.add_var(core, T * nBranch; lvar = fr_lb, uvar = fr_ub) + core, p_to = ExaModels.add_var(core, T * nBranch; lvar = fr_lb, uvar = fr_ub) + core, q_to = ExaModels.add_var(core, T * nBranch; lvar = fr_lb, uvar = fr_ub) + + # Battery charge / discharge power (pu, non-negative, per-battery capped). + pch_ub = float_type.(repeat([b.p_charge_max for b in case.batteries], T)) + pdis_ub = float_type.(repeat([b.p_discharge_max for b in case.batteries], T)) + core, p_ch = ExaModels.add_var(core, T * nBat; lvar = float_type(0), uvar = pch_ub) + core, p_dis = ExaModels.add_var(core, T * nBat; lvar = float_type(0), uvar = pdis_ub) + # Battery SoC (pu·h): (T+1) points, bounded by [e_min, e_max]. + core, e = ExaModels.add_var(core, (T + 1) * nBat; + lvar = float_type.(repeat([b.e_min for b in case.batteries], T + 1)), + uvar = float_type.(repeat([b.e_max for b in case.batteries], T + 1)), + start = float_type.(repeat([b.e_init for b in case.batteries], T + 1))) + + # ── Parameters (per-stage demand + initial SoC) ─────────────────────────── + prof = Float64.(collect(demand_profile)) + init_pd = float_type.([nd.bus_pd[b] * prof[t] for t in 1:T for b in 1:nBus]) + init_qd = float_type.([nd.bus_qd[b] * prof[t] for t in 1:T for b in 1:nBus]) + core, p_pd = ExaModels.add_par(core, init_pd) + core, p_qd = ExaModels.add_par(core, init_qd) + core, p_e0 = ExaModels.add_par(core, float_type.([b.e_init for b in case.batteries])) + + br_ac = [_ac_branch_coeffs(br, float_type) for br in nd.branches] + + # ── Objective ───────────────────────────────────────────────────────────── + # Generator cost. PGLib polynomial costs are USD/HOUR at the stage dispatch, + # so the physical cost of a Δt-hour stage is Δt·(c2·pg² + c1·pg + c0). We bake + # Δt into every coefficient (including the constant c0) so the reported + # objective is dollars over the whole horizon. + gen_items = [(t = t, g = gp, + c2 = float_type(g.cost2 * dt), + c1 = float_type(g.cost1 * dt), + c0 = float_type(g.cost0 * dt)) + for t in 1:T for (gp, g) in enumerate(nd.gens)] + core, _ = ExaModels.add_obj(core, + it.c2 * pg[_gidx(nGen, it.t, it.g)]^2 + it.c1 * pg[_gidx(nGen, it.t, it.g)] + it.c0 + for it in gen_items) + + # Battery cycle cost, PER BATTERY: cᵦ = cycle_cost_per_mwh_b · baseMVA (pu→MW) + # · Δt (h), so cᵦ·(pᶜʰ + pᵈⁱˢ) is the $ degradation cost of that battery's + # throughput energy over the stage. Coefficients are computed per battery — the + # fleet need not share one cycle price. + if nBat > 0 + cyc_items = [(idx = _kidx(nBat, t, k), + c = float_type(bat.cycle_cost_per_mwh * nd.baseMVA * dt)) + for t in 1:T for (k, bat) in enumerate(case.batteries)] + if any(it -> it.c > 0, cyc_items) + core, _ = ExaModels.add_obj(core, + it.c * (p_ch[it.idx] + p_dis[it.idx]) for it in cyc_items) + end + end + + # ── Constraints ─────────────────────────────────────────────────────────── + # 1. Reference angle: va[t, ref] = 0 + ref_items = [(t = t, ref = ref) for t in 1:T for ref in nd.ref_bus_positions] + core, _ = ExaModels.add_con(core, va[_bidx(nBus, it.t, it.ref)] for it in ref_items) + + # 2. From-end active flow + pfr_items = [(t = t, f = br.f_pos, tb = br.t_pos, br = bp, + c3 = br_ac[bp].c3, c4 = br_ac[bp].c4, c5 = br_ac[bp].c5) + for t in 1:T for (bp, br) in enumerate(nd.branches)] + core, _ = ExaModels.add_con(core, + p_fr[_bridx(nBranch, it.t, it.br)] + - it.c5 * vm[_bidx(nBus, it.t, it.f)]^2 + - it.c3 * vm[_bidx(nBus, it.t, it.f)] * vm[_bidx(nBus, it.t, it.tb)] + * cos(va[_bidx(nBus, it.t, it.f)] - va[_bidx(nBus, it.t, it.tb)]) + - it.c4 * vm[_bidx(nBus, it.t, it.f)] * vm[_bidx(nBus, it.t, it.tb)] + * sin(va[_bidx(nBus, it.t, it.f)] - va[_bidx(nBus, it.t, it.tb)]) + for it in pfr_items) + + # 3. From-end reactive flow + qfr_items = [(t = t, f = br.f_pos, tb = br.t_pos, br = bp, + c3 = br_ac[bp].c3, c4 = br_ac[bp].c4, c6 = br_ac[bp].c6) + for t in 1:T for (bp, br) in enumerate(nd.branches)] + core, _ = ExaModels.add_con(core, + q_fr[_bridx(nBranch, it.t, it.br)] + + it.c6 * vm[_bidx(nBus, it.t, it.f)]^2 + + it.c4 * vm[_bidx(nBus, it.t, it.f)] * vm[_bidx(nBus, it.t, it.tb)] + * cos(va[_bidx(nBus, it.t, it.f)] - va[_bidx(nBus, it.t, it.tb)]) + - it.c3 * vm[_bidx(nBus, it.t, it.f)] * vm[_bidx(nBus, it.t, it.tb)] + * sin(va[_bidx(nBus, it.t, it.f)] - va[_bidx(nBus, it.t, it.tb)]) + for it in qfr_items) + + # 4. To-end active flow + pto_items = [(t = t, f = br.f_pos, tb = br.t_pos, br = bp, + c1 = br_ac[bp].c1, c2 = br_ac[bp].c2, c7 = br_ac[bp].c7) + for t in 1:T for (bp, br) in enumerate(nd.branches)] + core, _ = ExaModels.add_con(core, + p_to[_bridx(nBranch, it.t, it.br)] + - it.c7 * vm[_bidx(nBus, it.t, it.tb)]^2 + - it.c1 * vm[_bidx(nBus, it.t, it.tb)] * vm[_bidx(nBus, it.t, it.f)] + * cos(va[_bidx(nBus, it.t, it.tb)] - va[_bidx(nBus, it.t, it.f)]) + - it.c2 * vm[_bidx(nBus, it.t, it.tb)] * vm[_bidx(nBus, it.t, it.f)] + * sin(va[_bidx(nBus, it.t, it.tb)] - va[_bidx(nBus, it.t, it.f)]) + for it in pto_items) + + # 5. To-end reactive flow + qto_items = [(t = t, f = br.f_pos, tb = br.t_pos, br = bp, + c1 = br_ac[bp].c1, c2 = br_ac[bp].c2, c8 = br_ac[bp].c8) + for t in 1:T for (bp, br) in enumerate(nd.branches)] + core, _ = ExaModels.add_con(core, + q_to[_bridx(nBranch, it.t, it.br)] + + it.c8 * vm[_bidx(nBus, it.t, it.tb)]^2 + + it.c2 * vm[_bidx(nBus, it.t, it.tb)] * vm[_bidx(nBus, it.t, it.f)] + * cos(va[_bidx(nBus, it.t, it.tb)] - va[_bidx(nBus, it.t, it.f)]) + - it.c1 * vm[_bidx(nBus, it.t, it.tb)] * vm[_bidx(nBus, it.t, it.f)] + * sin(va[_bidx(nBus, it.t, it.tb)] - va[_bidx(nBus, it.t, it.f)]) + for it in qto_items) + + # 6. Angle-difference limits + ang_lb = float_type.(repeat([br.angmin for br in nd.branches], T)) + ang_ub = float_type.(repeat([br.angmax for br in nd.branches], T)) + ang_items = [(t = t, f = br.f_pos, tb = br.t_pos) for t in 1:T for br in nd.branches] + core, _ = ExaModels.add_con(core, + va[_bidx(nBus, it.t, it.f)] - va[_bidx(nBus, it.t, it.tb)] + for it in ang_items; lcon = ang_lb, ucon = ang_ub) + + # 7. Apparent-power thermal limits at both ends (p² + q² ≤ rate²), applied + # only to rate-limited branches (unlimited branches, rate = Inf, add no row — + # matching PowerModels' ACPPowerModel). + rated = [bp for bp in 1:nBranch if isfinite(nd.branches[bp].rate_a)] + if !isempty(rated) + th_items = [(t = t, br = bp) for t in 1:T for bp in rated] + th_ub = float_type.([nd.branches[it.br].rate_a^2 for it in th_items]) + th_lb = fill(float_type(-Inf), length(th_items)) + core, _ = ExaModels.add_con(core, + p_fr[_bridx(nBranch, it.t, it.br)]^2 + q_fr[_bridx(nBranch, it.t, it.br)]^2 + for it in th_items; lcon = th_lb, ucon = th_ub) + core, _ = ExaModels.add_con(core, + p_to[_bridx(nBranch, it.t, it.br)]^2 + q_to[_bridx(nBranch, it.t, it.br)]^2 + for it in th_items; lcon = th_lb, ucon = th_ub) + end + + # Precomputed augmentation items. NOTE: ExaModels' `add_con!` augmentation + # requires a `Base.Generator` (a SINGLE `for` over a precomputed vector); a + # double-`for` comprehension yields a `Base.Iterators.Flatten`, which the + # augmentation method does not accept. Hence every `=> ` term below iterates + # one flattened item vector. + gen_bus_items = [(brow = _bidx(nBus, t, g.bus_pos), gcol = _gidx(nGen, t, gp)) + for t in 1:T for (gp, g) in enumerate(nd.gens)] + fr_bus_items = [(brow = _bidx(nBus, t, br.f_pos), bcol = _bridx(nBranch, t, bp)) + for t in 1:T for (bp, br) in enumerate(nd.branches)] + to_bus_items = [(brow = _bidx(nBus, t, br.t_pos), bcol = _bridx(nBranch, t, bp)) + for t in 1:T for (bp, br) in enumerate(nd.branches)] + bat_bus_items = [(brow = _bidx(nBus, t, bat.bus_pos), kcol = _kidx(nBat, t, k)) + for t in 1:T for (k, bat) in enumerate(case.batteries)] + + # 8. Active balance: pd + gs·vm² − Σpg − Σ(p_dis − p_ch) + Σp_fr + Σp_to = 0 + kcl_p_init = [(t = t, b = b, gs = float_type(nd.buses[b].gs)) for t in 1:T for b in 1:nBus] + core, c_kcl_p = ExaModels.add_con(core, + p_pd[_bidx(nBus, it.t, it.b)] + it.gs * vm[_bidx(nBus, it.t, it.b)]^2 + for it in kcl_p_init) + core, _ = ExaModels.add_con!(core, c_kcl_p, it.brow => -pg[it.gcol] for it in gen_bus_items) + core, _ = ExaModels.add_con!(core, c_kcl_p, it.brow => p_fr[it.bcol] for it in fr_bus_items) + core, _ = ExaModels.add_con!(core, c_kcl_p, it.brow => p_to[it.bcol] for it in to_bus_items) + if nBat > 0 + # Battery active injection p_bat = p_dis − p_ch enters as −p_dis + p_ch. + core, _ = ExaModels.add_con!(core, c_kcl_p, it.brow => -p_dis[it.kcol] for it in bat_bus_items) + core, _ = ExaModels.add_con!(core, c_kcl_p, it.brow => p_ch[it.kcol] for it in bat_bus_items) + end + + # 9. Reactive balance (hard): qd − bs·vm² − Σqg + Σq_fr + Σq_to = 0 + kcl_q_init = [(t = t, b = b, bs = float_type(nd.buses[b].bs)) for t in 1:T for b in 1:nBus] + core, c_kcl_q = ExaModels.add_con(core, + p_qd[_bidx(nBus, it.t, it.b)] - it.bs * vm[_bidx(nBus, it.t, it.b)]^2 + for it in kcl_q_init) + core, _ = ExaModels.add_con!(core, c_kcl_q, it.brow => -qg[it.gcol] for it in gen_bus_items) + core, _ = ExaModels.add_con!(core, c_kcl_q, it.brow => q_fr[it.bcol] for it in fr_bus_items) + core, _ = ExaModels.add_con!(core, c_kcl_q, it.brow => q_to[it.bcol] for it in to_bus_items) + + # 10. Battery initial SoC: e[1,k] − e_init,k = 0 + if nBat > 0 + core, _ = ExaModels.add_con(core, + e[_eidx(nBat, 1, k)] - p_e0[k] for k in 1:nBat) + end + + # 11. Battery state equation (last constraint block): + # e[t+1,k] − (1−σΔt)·e[t,k] − η_ch·Δt·p_ch + (Δt/η_dis)·p_dis = 0 + if nBat > 0 + st_items = [(en = _eidx(nBat, t + 1, k), ec = _eidx(nBat, t, k), + pc = _kidx(nBat, t, k), pd_ = _kidx(nBat, t, k), + a = float_type(1 - bat.sigma * dt), + bch = float_type(bat.eta_ch * dt), + bdis = float_type(dt / bat.eta_dis)) + for t in 1:T for (k, bat) in enumerate(case.batteries)] + core, _ = ExaModels.add_con(core, + e[it.en] - it.a * e[it.ec] - it.bch * p_ch[it.pc] + it.bdis * p_dis[it.pd_] + for it in st_items) + end + + cycle_coeffs = Float64[b.cycle_cost_per_mwh * nd.baseMVA * dt for b in case.batteries] + + model = ExaModels.ExaModel(core) + return BatteryExaProblem(core, model, p_pd, p_qd, p_e0, + nBus, nGen, nBranch, nBat, T, dt, + cycle_coeffs, case, float_type) +end + +# ── Parameter setters ───────────────────────────────────────────────────────── + +""" + set_demand!(prob, pd::AbstractMatrix, qd::AbstractMatrix) + +Overwrite the per-stage active/reactive demand parameters. `pd`, `qd` are +`[T × nBus]` (pu). Both must be supplied so the reactive/active balance stay +consistent. +""" +function set_demand!(prob::BatteryExaProblem, pd::AbstractMatrix, qd::AbstractMatrix) + T, nB = prob.horizon, prob.nBus + size(pd) == (T, nB) || error("pd must be [T=$T × nBus=$nB]") + size(qd) == (T, nB) || error("qd must be [T=$T × nBus=$nB]") + ExaModels.set_parameter!(prob.core, prob.p_pd, + prob.float_type.([pd[t, b] for t in 1:T for b in 1:nB])) + ExaModels.set_parameter!(prob.core, prob.p_qd, + prob.float_type.([qd[t, b] for t in 1:T for b in 1:nB])) + return prob +end + +""" + set_initial_soc!(prob, e0::AbstractVector) + +Overwrite the initial state-of-charge parameter (length `nBat`, pu·h). +""" +function set_initial_soc!(prob::BatteryExaProblem, e0::AbstractVector) + length(e0) == prob.nBat || error("e0 must have length nBat=$(prob.nBat)") + ExaModels.set_parameter!(prob.core, prob.p_e0, prob.float_type.(collect(e0))) + return prob +end + +# ── Solve + structured extraction ───────────────────────────────────────────── + +solve_succeeded(status) = status == MadNLP.SOLVE_SUCCEEDED || + status == MadNLP.SOLVED_TO_ACCEPTABLE_LEVEL + +""" + solve_de!(prob; print_level=MadNLP.ERROR, kwargs...) -> result + +Solve the deterministic equivalent on the CPU with MadNLP. Returns the raw +MadNLP result (with `.status`, `.objective`, `.solution`, `.multipliers`). + +Named `solve_de!` rather than `solve!` to avoid clashing with the `solve!` +that JuMP/MadNLP re-export from CommonSolve. +""" +solve_de!(prob::BatteryExaProblem; print_level = MadNLP.ERROR, kwargs...) = + MadNLP.madnlp(prob.model; print_level = print_level, kwargs...) + +""" + battery_solution(prob, result) -> NamedTuple + +Reshape the flat solution into named `[·×T]` (or `[·×(T+1)]` for SoC) matrices: +`va, vm` (nBus), `pg, qg` (nGen), `p_fr, q_fr, p_to, q_to` (nBranch), +`p_ch, p_dis` (nBat), `soc` (nBat×(T+1)), and derived `p_bat = p_dis − p_ch`. +""" +function battery_solution(prob::BatteryExaProblem, result) + T = prob.horizon; nB = prob.nBus; nG = prob.nGen; nBR = prob.nBranch; nK = prob.nBat + sol = Array(result.solution) + off = 0 + take(n, m) = (v = reshape(sol[off .+ (1:n*m)], n, m); off += n*m; v) + va = take(nB, T) + vm = take(nB, T) + pg = take(nG, T) + qg = take(nG, T) + p_fr = take(nBR, T) + q_fr = take(nBR, T) + p_to = take(nBR, T) + q_to = take(nBR, T) + if nK > 0 + p_ch = take(nK, T) + p_dis = take(nK, T) + soc = take(nK, T + 1) + else + p_ch = zeros(eltype(sol), 0, T) + p_dis = zeros(eltype(sol), 0, T) + soc = zeros(eltype(sol), 0, T + 1) + end + return (va = va, vm = vm, pg = pg, qg = qg, + p_fr = p_fr, q_fr = q_fr, p_to = p_to, q_to = q_to, + p_ch = p_ch, p_dis = p_dis, soc = soc, p_bat = p_dis .- p_ch) +end + +""" + battery_balance_residuals(prob, sol) -> Matrix + +`[nBat × T]` residuals of the state equation +`e[t+1] − (1−σΔt)·e[t] − η_ch·Δt·p_ch + (Δt/η_dis)·p_dis`, which should be ~0. +""" +function battery_balance_residuals(prob::BatteryExaProblem, sol) + T = prob.horizon; nK = prob.nBat + res = zeros(Float64, nK, T) + for (k, bat) in enumerate(prob.case.batteries), t in 1:T + res[k, t] = sol.soc[k, t+1] - (1 - bat.sigma * prob.dt) * sol.soc[k, t] - + bat.eta_ch * prob.dt * sol.p_ch[k, t] + + (prob.dt / bat.eta_dis) * sol.p_dis[k, t] + end + return res +end + +""" + simultaneous_charge_discharge_power(sol) -> Matrix + +`[nBat × T]` **simultaneous charge/discharge power** in pu: the elementwise +smaller of the charge and discharge powers, `min(p_ch, p_dis)` (NOT a product). +It is the amount of power a battery is charging and discharging at the same time; +material positive entries flag unwanted simultaneous operation, which the +nonnegative cycle cost is designed to prevent. +""" +simultaneous_charge_discharge_power(sol) = min.(sol.p_ch, sol.p_dis) + +""" + max_primal_residual(prob, result) -> Float64 + +Largest constraint-bound violation of the returned point, evaluated +independently through the NLPModels interface (max over +`max(lcon − c, c − ucon, 0)`). +""" +function max_primal_residual(prob::BatteryExaProblem, result) + x = Array(result.solution) + c = NLPModels.cons(prob.model, x) + lcon = Array(prob.model.meta.lcon); ucon = Array(prob.model.meta.ucon) + c = Array(c) + viol = 0.0 + @inbounds for i in eachindex(c) + viol = max(viol, lcon[i] - c[i], c[i] - ucon[i], 0.0) + end + return viol +end diff --git a/examples/BatteryStorageOPF/src/manifest.jl b/examples/BatteryStorageOPF/src/manifest.jl new file mode 100644 index 0000000..9db2913 --- /dev/null +++ b/examples/BatteryStorageOPF/src/manifest.jl @@ -0,0 +1,321 @@ +# manifest.jl +# +# Deterministic manifest for a BatteryCase: everything needed to rebuild the +# exact same battery placement and parameters, plus provenance and attribution +# (see BATTERY_STORAGE_OPF_PLAN.md §5). +# +# Two representations: +# * a canonical CONTENT string → SHA-256 `manifest_hash` that depends only on +# the scientific content (case name, MATPOWER source-file SHA-256, seed, +# eligible-bus rule, selected buses, battery params, units, counts) and NOT on +# timestamps, absolute paths, or package versions, so "same seed ⇒ same hash" +# holds across runs of the same PGLib artifact; +# * a JSON manifest file that additionally records provenance, attribution, the +# license (CC BY 4.0), the content hash, and file hashes. + +using SHA +using JSON + +# ── PGLib attribution / upstream version (best effort) ──────────────────────── + +const PGLIB_ATTRIBUTION = string( + "Network data from the Power Grid Library for Benchmarking AC Optimal ", + "Power Flow Algorithms (PGLib-OPF), distributed via PGLib.jl. ", + "Cite: S. Babaeinejadsarookolaee et al., \"The Power Grid Library for ", + "Benchmarking AC Optimal Power Flow Algorithms\", arXiv:1908.02788.", +) + +# PGLib-OPF is released under the Creative Commons Attribution 4.0 license. +const PGLIB_LICENSE_NAME = "Creative Commons Attribution 4.0 International" +const PGLIB_LICENSE_URL = "https://creativecommons.org/licenses/by/4.0/" + +# The PGLib.jl artifact directory is named `pglib-opf-` (e.g. +# `pglib-opf-23.07`), so the upstream benchmark release is read straight from +# the path; fall back to the pinning PGLib.jl package version. +function _pglib_upstream_version() + m = match(r"pglib-opf-([0-9]+\.[0-9]+)", _pglib_case_dir()) + return m === nothing ? "pinned-by-PGLib.jl-" * _pkg_version("PGLib") : m.captures[1] +end + +# ── Canonical content + hash ────────────────────────────────────────────────── + +# Deterministic full-precision rendering of a Float64 (round-trippable shortest +# form is stable for equal values). +_fmt(x::Real) = string(Float64(x)) +_fmt(x::Integer) = string(x) +_fmt(x::AbstractString) = String(x) + +""" + canonical_content(bc) -> String + +Ordered, human-inspectable string capturing exactly the scientific content that +defines the case: the PGLib case name, the SHA-256 of the exact MATPOWER source +bytes, the seed and eligible-bus rule, the ordered battery placement, and every +battery parameter with units. Its SHA-256 is [`manifest_hash`](@ref). +Deliberately excludes timestamps, absolute paths, and package versions so the +hash is reproducible; including the MATPOWER source hash makes the hash sensitive +to the exact network bytes. +""" +function canonical_content(bc::BatteryCase) + io = IOBuffer() + nd = bc.network + println(io, "schema=battery_storage_opf/2") + println(io, "case_name=", bc.case_name) + println(io, "matpower_file=", basename(bc.parse_meta.filepath)) + println(io, "matpower_sha256=", bc.parse_meta.matpower_sha256) + println(io, "baseMVA=", _fmt(nd.baseMVA)) + println(io, "nbus=", nbus(nd), " ngen=", ngen(nd), + " nbranch=", nbranch(nd), " nload=", nload(nd)) + println(io, "total_load_pu=", _fmt(bc.total_load_pu)) + println(io, "seed=", bc.seed) + println(io, "eligible_bus_rule=", bc.eligible_bus_rule) + println(io, "explicit_buses=", bc.explicit_buses) + println(io, "number_of_batteries=", bc.number_of_batteries) + println(io, "duration_hours=", _fmt(bc.duration_hours)) + println(io, "initial_soc=", _fmt(bc.initial_soc)) + println(io, "charge_efficiency=", _fmt(bc.charge_efficiency)) + println(io, "discharge_efficiency=", _fmt(bc.discharge_efficiency)) + println(io, "fleet_power_fraction=", _fmt(bc.fleet_power_fraction)) + println(io, "self_discharge_rate=", _fmt(bc.self_discharge_rate)) + println(io, "e_min_fraction=", _fmt(bc.e_min_fraction)) + println(io, "cycle_cost_per_mwh=", _fmt(bc.cycle_cost_per_mwh)) + println(io, "units=power:pu[baseMVA];energy:pu_hours;time:hours") + println(io, "selected_bus_ids=", join(bc.selected_bus_ids, ",")) + for b in bc.batteries + println(io, "battery ", b.id, + " bus=", b.bus_id, + " pch_max=", _fmt(b.p_charge_max), + " pdis_max=", _fmt(b.p_discharge_max), + " e_min=", _fmt(b.e_min), + " e_max=", _fmt(b.e_max), + " e_init=", _fmt(b.e_init), + " eta_ch=", _fmt(b.eta_ch), + " eta_dis=", _fmt(b.eta_dis), + " sigma=", _fmt(b.sigma), + " cycle_cost_per_mwh=", _fmt(b.cycle_cost_per_mwh)) + end + return String(take!(io)) +end + +""" + manifest_hash(bc) -> String + +Lowercase hex SHA-256 of [`canonical_content`](@ref). Identical inputs (same +PGLib case, seed, and sizing parameters) reproduce the same hash. +""" +manifest_hash(bc::BatteryCase) = bytes2hex(sha256(canonical_content(bc))) + +_sha256_file(path) = bytes2hex(open(sha256, path)) + +# ── JSON manifest ───────────────────────────────────────────────────────────── + +""" + battery_manifest(bc) -> Dict + +Assemble the full machine-readable manifest: scientific content, provenance +(package + Julia + upstream PGLib versions), attribution, units, the horizon / +terminal-treatment note, and the content hash. File hashes are added by +[`write_manifest`](@ref) once files exist on disk. +""" +function battery_manifest(bc::BatteryCase) + nd = bc.network + return Dict( + "schema" => "battery_storage_opf/2", + "content_hash_sha256" => manifest_hash(bc), + "pglib" => Dict( + "case_name" => bc.case_name, + "matpower_file" => basename(bc.parse_meta.filepath), + "matpower_path" => bc.parse_meta.filepath, + "matpower_sha256" => bc.parse_meta.matpower_sha256, + "upstream_release" => _pglib_upstream_version(), + "attribution" => PGLIB_ATTRIBUTION, + "license" => PGLIB_LICENSE_NAME, + "license_url" => PGLIB_LICENSE_URL, + ), + "versions" => Dict( + "julia" => string(VERSION), + "PGLib" => bc.parse_meta.pglib_version, + "PowerModels" => bc.parse_meta.powermodels_version, + ), + "network" => Dict( + "baseMVA" => nd.baseMVA, + "nbus" => nbus(nd), "ngen" => ngen(nd), + "nbranch" => nbranch(nd), "nload" => nload(nd), + "total_load_pu" => bc.total_load_pu, + "per_unit_input" => nd.per_unit_input, + ), + "placement" => Dict( + "seed" => bc.seed, + "eligible_bus_rule" => bc.eligible_bus_rule, + "explicit_buses" => bc.explicit_buses, + "n_eligible_buses" => length(bc.eligible_bus_ids), + "selected_bus_ids" => bc.selected_bus_ids, + ), + "battery_parameters" => Dict( + "number_of_batteries" => bc.number_of_batteries, + "duration_hours" => bc.duration_hours, + "initial_soc" => bc.initial_soc, + "charge_efficiency" => bc.charge_efficiency, + "discharge_efficiency" => bc.discharge_efficiency, + "fleet_power_fraction" => bc.fleet_power_fraction, + "self_discharge_rate" => bc.self_discharge_rate, + "e_min_fraction" => bc.e_min_fraction, + "cycle_cost_per_mwh" => bc.cycle_cost_per_mwh, + "per_battery_p_charge_max_pu" => + isempty(bc.batteries) ? 0.0 : bc.batteries[1].p_charge_max, + "per_battery_p_discharge_max_pu" => + isempty(bc.batteries) ? 0.0 : bc.batteries[1].p_discharge_max, + "per_battery_e_max_pu_h" => + isempty(bc.batteries) ? 0.0 : bc.batteries[1].e_max, + "per_battery_e_init_pu_h" => + isempty(bc.batteries) ? 0.0 : bc.batteries[1].e_init, + ), + "batteries" => [Dict( + "id" => b.id, "bus_id" => b.bus_id, "bus_pos" => b.bus_pos, + "p_charge_max_pu" => b.p_charge_max, + "p_discharge_max_pu" => b.p_discharge_max, + "e_min_pu_h" => b.e_min, "e_max_pu_h" => b.e_max, + "e_init_pu_h" => b.e_init, + "eta_ch" => b.eta_ch, "eta_dis" => b.eta_dis, + "sigma_per_h" => b.sigma, + "cycle_cost_per_mwh" => b.cycle_cost_per_mwh, + ) for b in bc.batteries], + "units" => Dict( + "power" => "per-unit on baseMVA", + "energy" => "per-unit-hours (pu·h)", + "time" => "hours", + "cost" => "USD; generator cost per pu power, battery cost per MWh throughput", + ), + "horizon" => Dict( + "note" => string( + "Phase 1 deterministic foundation: horizon T and stage length ", + "Δt (hours) are chosen at model-build time (build_battery_de). ", + "The stochastic load process, paired protocol, and terminal ", + "treatment are defined in later phases."), + ), + ) +end + +""" + write_manifest(bc, path; extra_files = String[]) -> String + +Write the JSON manifest to `path`, adding SHA-256 hashes of any `extra_files` +(e.g. a human-readable battery file) and of the manifest's own canonical +content. Returns `path`. +""" +function write_manifest(bc::BatteryCase, path::AbstractString; extra_files = String[]) + man = battery_manifest(bc) + man["generated_at_utc"] = _utc_now_string() + fh = Dict{String,String}() + for f in extra_files + isfile(f) && (fh[basename(f)] = _sha256_file(f)) + end + man["file_hashes_sha256"] = fh + open(path, "w") do io + JSON.print(io, man, 2) + end + return path +end + +# ISO-8601 UTC timestamp without pulling in Dates' TimeZones; Libc.strftime is +# stdlib and sufficient for a provenance stamp. +function _utc_now_string() + t = round(Int, time()) + return Libc.strftime("%Y-%m-%dT%H:%M:%SZ", t) +end + +# ── Human-readable battery file ─────────────────────────────────────────────── + +""" + write_battery_file(bc, path) -> String + +Write a human-readable CSV of the battery fleet (one row per battery, original +bus id preserved). Returns `path`. +""" +function write_battery_file(bc::BatteryCase, path::AbstractString) + open(path, "w") do io + println(io, "# BatteryStorageOPF fleet for PGLib case \"", bc.case_name, + "\" (seed=", bc.seed, ", baseMVA=", bc.network.baseMVA, ")") + println(io, "# power/energy are per-unit on baseMVA; energy in pu·h") + println(io, "battery_id,bus_id,p_charge_max_pu,p_discharge_max_pu,", + "e_min_pu_h,e_max_pu_h,e_init_pu_h,eta_ch,eta_dis,sigma_per_h,cycle_cost_per_mwh") + for b in bc.batteries + println(io, b.id, ",", b.bus_id, ",", b.p_charge_max, ",", + b.p_discharge_max, ",", b.e_min, ",", b.e_max, ",", + b.e_init, ",", b.eta_ch, ",", b.eta_dis, ",", b.sigma, + ",", b.cycle_cost_per_mwh) + end + end + return path +end + +# ── Reconstruction ──────────────────────────────────────────────────────────── + +""" + reconstruct_case(manifest_path) -> BatteryCase + +Rebuild the case recorded in a JSON manifest and verify it, returning the case +only when ALL of the following match the manifest: + +1. **Source network bytes** — the SHA-256 of the currently resolved MATPOWER + file equals the manifest's recorded `matpower_sha256`. This is checked FIRST, + directly against the resolved artifact, so a tampered/moved/updated network + file is rejected before anything else. +2. **Ordered placement** — the reconstructed battery buses match the recorded + `selected_bus_ids` in the same order. +3. **Battery parameters** — captured by the content hash: re-running + `make_battery_case` with the recorded case name, seed, and sizing parameters + reproduces the recorded `content_hash_sha256` (which itself includes the + source-file hash). + +Any mismatch raises an error, so a returned case is verified identical in source +network bytes, ordered placement, and battery parameters to the recorded one. +""" +function reconstruct_case(manifest_path::AbstractString) + man = JSON.parsefile(manifest_path) + bp = man["battery_parameters"] + pl = man["placement"] + pg = man["pglib"] + + # 1. Verify the source network bytes FIRST, against the currently resolved + # MATPOWER file, before trusting anything else in the manifest. + recorded_src = String(pg["matpower_sha256"]) + _, filepath = resolve_pglib_case(String(pg["case_name"])) + current_src = _sha256_file(filepath) + current_src == recorded_src || error( + "source-file hash mismatch for \"$(pg["case_name"])\": manifest recorded " * + "$recorded_src but the resolved MATPOWER file hashes to $current_src. " * + "The network data differs from when the manifest was written.") + + explicit = Bool(pl["explicit_buses"]) + kwargs = ( + number_of_batteries = Int(bp["number_of_batteries"]), + seed = Int(pl["seed"]), + duration_hours = Float64(bp["duration_hours"]), + initial_soc = Float64(bp["initial_soc"]), + charge_efficiency = Float64(bp["charge_efficiency"]), + discharge_efficiency = Float64(bp["discharge_efficiency"]), + fleet_power_fraction = Float64(bp["fleet_power_fraction"]), + self_discharge_rate = Float64(bp["self_discharge_rate"]), + e_min_fraction = Float64(bp["e_min_fraction"]), + cycle_cost_per_mwh = Float64(bp["cycle_cost_per_mwh"]), + ) + bc = if explicit + make_battery_case(String(pg["case_name"]); + buses = Int.(pl["selected_bus_ids"]), kwargs...) + else + make_battery_case(String(pg["case_name"]); kwargs...) + end + + # 2. Ordered placement. + Int.(pl["selected_bus_ids"]) == bc.selected_bus_ids || + error("reconstruction produced a different battery placement order") + + # 3. Battery parameters (via the content hash, which embeds the source hash). + got = manifest_hash(bc) + want = String(man["content_hash_sha256"]) + got == want || error( + "reconstruction content-hash mismatch: manifest recorded $want but " * + "rebuilt $got. Battery parameters differ from when the manifest was written.") + return bc +end diff --git a/examples/BatteryStorageOPF/src/network_data.jl b/examples/BatteryStorageOPF/src/network_data.jl new file mode 100644 index 0000000..ae9951e --- /dev/null +++ b/examples/BatteryStorageOPF/src/network_data.jl @@ -0,0 +1,413 @@ +# network_data.jl +# +# Typed parsing of a PGLib / PowerModels AC network into the flat, per-unit +# structures the ExaModels AC-polar builder consumes. +# +# Design rules honored here (see BATTERY_STORAGE_OPF_PLAN.md §5): +# * PGLib component identifiers are NEVER assumed consecutive or equal to +# their array position. Every component keeps its original PGLib `index` +# and we build explicit, stable ID → position maps (`*_id_to_pos`). +# * All unit conversion happens HERE, in one documented data layer, so model +# code sees only per-unit quantities on the `baseMVA` base with angles in +# radians. Nothing downstream re-scales. +# +# We parse the raw MATPOWER data exactly as `PowerModels.parse_file` returns it +# (mixed units, `per_unit = false`: powers in MW/MVAr, voltages in pu, angles +# already converted to radians by the parser). The conversion below is gated on +# the observed `per_unit` flag so a pre-converted dict is also handled safely. + +using PowerModels +using PGLib +using SHA + +# ── Typed, per-unit network components ──────────────────────────────────────── +# Every struct stores the original PGLib id AND the resolved 1-based array +# position of any component it references. + +""" + BusData + +One AC bus, per unit on `baseMVA`. + +* `id` : original PGLib bus index (may be non-consecutive). +* `bus_type` : PowerModels bus type (1 = PQ, 2 = PV, 3 = reference/slack). +* `gs`, `bs` : shunt conductance / susceptance at the bus (pu). +* `vmin`,`vmax`: voltage-magnitude limits (pu). +""" +struct BusData + id::Int + bus_type::Int + gs::Float64 + bs::Float64 + vmin::Float64 + vmax::Float64 +end + +""" + GenData + +One in-service generator, per unit on `baseMVA`. + +* `id` : original PGLib generator index. +* `bus_id`,`bus_pos` : the bus it injects into (original id and array position). +* `pmin`,`pmax` : active-power limits (pu). +* `qmin`,`qmax` : reactive-power limits (pu). +* `cost2`,`cost1`,`cost0`: polynomial cost so that the \$/hour cost of `pg` pu is + `cost2·pg² + cost1·pg + cost0`. Converted once from the MATPOWER \$/MW model. +""" +struct GenData + id::Int + bus_id::Int + bus_pos::Int + pmin::Float64 + pmax::Float64 + qmin::Float64 + qmax::Float64 + cost2::Float64 + cost1::Float64 + cost0::Float64 +end + +""" + BranchData + +One in-service branch, per unit on `baseMVA`, with the raw AC-polar parameters +used by [`_ac_branch_coeffs`](@ref). + +* `id` : original PGLib branch index. +* `f_id`,`f_pos` : from-bus original id and array position. +* `t_id`,`t_pos` : to-bus original id and array position. +* `br_r`,`br_x` : series resistance / reactance (pu). +* `g_fr`,`b_fr`,`g_to`,`b_to`: line-charging shunts (pu). +* `tap`,`shift` : transformer turns ratio and phase shift (rad). +* `rate_a` : apparent-power thermal limit (pu); `Inf` if unlimited. +* `angmin`,`angmax` : angle-difference limits (rad). +""" +struct BranchData + id::Int + f_id::Int + f_pos::Int + t_id::Int + t_pos::Int + br_r::Float64 + br_x::Float64 + g_fr::Float64 + b_fr::Float64 + g_to::Float64 + b_to::Float64 + tap::Float64 + shift::Float64 + rate_a::Float64 + angmin::Float64 + angmax::Float64 +end + +""" + LoadData + +One in-service load, per unit on `baseMVA`. + +* `id` : original PGLib load index. +* `bus_id`,`bus_pos` : the bus it draws from (original id and array position). +* `pd`,`qd` : active / reactive demand (pu). +""" +struct LoadData + id::Int + bus_id::Int + bus_pos::Int + pd::Float64 + qd::Float64 +end + +""" + NetworkData + +Fully parsed, per-unit AC network. Components are stored sorted by original id; +`*_id_to_pos` give the stable inverse maps. `bus_pd`/`bus_qd` aggregate the +loads onto buses (length `nbus`, positional). +""" +struct NetworkData + case_name::String + baseMVA::Float64 + buses::Vector{BusData} + gens::Vector{GenData} + branches::Vector{BranchData} + loads::Vector{LoadData} + ref_bus_positions::Vector{Int} + bus_id_to_pos::Dict{Int,Int} + gen_id_to_pos::Dict{Int,Int} + branch_id_to_pos::Dict{Int,Int} + load_id_to_pos::Dict{Int,Int} + bus_pd::Vector{Float64} # aggregated active demand per bus (pu) + bus_qd::Vector{Float64} # aggregated reactive demand per bus (pu) + per_unit_input::Bool # whether the source dict was already per-unit +end + +nbus(nd::NetworkData) = length(nd.buses) +ngen(nd::NetworkData) = length(nd.gens) +nbranch(nd::NetworkData) = length(nd.branches) +nload(nd::NetworkData) = length(nd.loads) + +# ── PGLib case-name resolution ──────────────────────────────────────────────── + +""" + _pglib_case_dir() -> String + +Absolute directory holding the `pglib_opf_*.m` benchmark files that ship with +the pinned `PGLib.jl` artifact. +""" +_pglib_case_dir() = PGLib.PGLib_opf + +""" + available_pglib_cases() -> Vector{String} + +Sorted canonical short names (the `pglib_opf_` prefix and `.m` suffix stripped) +of every case in the pinned PGLib artifact, e.g. `"case300_ieee"`. +""" +function available_pglib_cases() + dir = _pglib_case_dir() + names = String[] + for f in readdir(dir) + (endswith(f, ".m") && startswith(f, "pglib_opf_")) || continue + push!(names, replace(replace(f, r"\.m$" => ""), r"^pglib_opf_" => "")) + end + return sort!(names) +end + +""" + resolve_pglib_case(name) -> (canonical_name, filepath) + +Resolve a user-supplied PGLib case name to its canonical short name and the +absolute `.m` file path, unambiguously. + +Accepted forms (all mapped to the same case): `"case300_ieee"`, +`"pglib_opf_case300_ieee"`, `"pglib_opf_case300_ieee.m"`. + +Errors: +* a name matching no case lists the closest available names; +* a name matching several cases (only possible via a partial/loose query) is + rejected with the full ambiguous set. Exact canonical matches are never + ambiguous. +""" +function resolve_pglib_case(name::AbstractString) + dir = _pglib_case_dir() + cases = available_pglib_cases() + + # Normalize the query to a canonical short name. + q = String(name) + q = replace(q, r"\.m$" => "") + q = replace(q, r"^pglib_opf_" => "") + + # Exact canonical match wins outright (never ambiguous). + if q in cases + return q, joinpath(dir, "pglib_opf_" * q * ".m") + end + + # Otherwise treat the query as a substring and demand a unique hit. + hits = filter(c -> occursin(q, c), cases) + if isempty(hits) + # Offer nearby suggestions by shared prefix to make the error actionable. + prefix = first(q, min(length(q), 6)) + near = filter(c -> startswith(c, prefix), cases) + suffix = isempty(near) ? "" : "\n Did you mean: " * join(first(near, 8), ", ") + error("PGLib case \"$name\" not found in $(length(cases)) available cases." * + suffix * + "\n Use available_pglib_cases() to list them all.") + elseif length(hits) > 1 + error("PGLib case \"$name\" is ambiguous; it matches $(length(hits)) cases:\n " * + join(hits, ", ") * + "\n Pass an exact canonical name (e.g. one of the above).") + end + c = only(hits) + return c, joinpath(dir, "pglib_opf_" * c * ".m") +end + +# ── Parsing + one documented unit-conversion layer ──────────────────────────── + +# Extract the polynomial generator cost as (cost2, cost1, cost0) with pg in pu. +# MATPOWER model-2 polynomials are in \$ with power in MW; converting to pu +# multiplies the degree-k coefficient by baseMVA^k. Piecewise-linear (model 1) +# cost is not supported by this example and errors loudly. +function _gen_cost_pu(gen, sbase::Float64) + model = Int(get(gen, "model", 2)) + model == 2 || error("generator $(get(gen,"index","?")) uses cost model $model; " * + "only MATPOWER polynomial cost (model 2) is supported") + cost = Float64.(get(gen, "cost", Float64[])) + ncost = Int(get(gen, "ncost", length(cost))) + # Right-align: MATPOWER lists highest-order coefficient first. + c2 = c1 = c0 = 0.0 + if ncost >= 3 + c2, c1, c0 = cost[end-2], cost[end-1], cost[end] + elseif ncost == 2 + c1, c0 = cost[end-1], cost[end] + elseif ncost == 1 + c0 = cost[end] + end + return (c2 * sbase^2, c1 * sbase, c0) +end + +""" + parse_network(data::Dict, case_name) -> NetworkData + +Parse a PowerModels network dict into per-unit [`NetworkData`], keeping only +in-service components (bus_type ≠ 4, and unit/branch/load status = 1) and +building explicit stable id → position maps. + +Power quantities are divided by `baseMVA` iff the dict is not already per-unit +(`data["per_unit"] == false`, the state `PowerModels.parse_file` returns). +""" +function parse_network(data::AbstractDict, case_name::AbstractString) + sbase = Float64(data["baseMVA"]) + per_unit = Bool(get(data, "per_unit", false)) + # Scale factor applied to MW/MVAr quantities (1.0 when already per-unit). + s = per_unit ? 1.0 : 1.0 / sbase + + # ── Shunt admittance (PowerModels keeps shunts as a SEPARATE component, not + # on the bus). Aggregate in-service shunt gs/bs per original bus id so they + # enter the power balance as gs·vm² (active) and −bs·vm² (reactive). Shunt + # gs/bs are already per-unit; the same `s` gate applies for consistency. + shunt_gs = Dict{Int,Float64}(); shunt_bs = Dict{Int,Float64}() + for sh in values(get(data, "shunt", Dict{String,Any}())) + Int(get(sh, "status", 1)) == 1 || continue + bid = Int(sh["shunt_bus"]) + shunt_gs[bid] = get(shunt_gs, bid, 0.0) + Float64(get(sh, "gs", 0.0)) * s + shunt_bs[bid] = get(shunt_bs, bid, 0.0) + Float64(get(sh, "bs", 0.0)) * s + end + + # ── Buses (drop isolated bus_type == 4) ─────────────────────────────────── + bus_raw = collect(values(data["bus"])) + filter!(b -> Int(b["bus_type"]) != 4, bus_raw) + sort!(bus_raw, by = b -> Int(b["index"])) + buses = BusData[] + bus_id_to_pos = Dict{Int,Int}() + for (pos, b) in enumerate(bus_raw) + id = Int(b["index"]) + bus_id_to_pos[id] = pos + # Bus-level gs/bs (rare) plus any separate shunt components at this bus. + gs = Float64(get(b, "gs", 0.0)) * s + get(shunt_gs, id, 0.0) + bs = Float64(get(b, "bs", 0.0)) * s + get(shunt_bs, id, 0.0) + push!(buses, BusData(id, Int(b["bus_type"]), gs, bs, + Float64(get(b, "vmin", 0.9)), + Float64(get(b, "vmax", 1.1)))) + end + ref_bus_positions = [bus_id_to_pos[b.id] for b in buses if b.bus_type == 3] + isempty(ref_bus_positions) && + error("network \"$case_name\" has no reference (type-3) bus") + + # ── Generators (in-service only) ────────────────────────────────────────── + gen_raw = collect(values(data["gen"])) + filter!(g -> Int(get(g, "gen_status", 1)) == 1, gen_raw) + sort!(gen_raw, by = g -> Int(g["index"])) + gens = GenData[] + gen_id_to_pos = Dict{Int,Int}() + for (pos, g) in enumerate(gen_raw) + id = Int(g["index"]) + bus_id = Int(g["gen_bus"]) + haskey(bus_id_to_pos, bus_id) || + error("generator $id references out-of-service/unknown bus $bus_id") + c2, c1, c0 = _gen_cost_pu(g, per_unit ? 1.0 : sbase) + gen_id_to_pos[id] = pos + push!(gens, GenData(id, bus_id, bus_id_to_pos[bus_id], + Float64(get(g, "pmin", 0.0)) * s, + Float64(g["pmax"]) * s, + Float64(get(g, "qmin", -Inf)) * s, + Float64(get(g, "qmax", Inf)) * s, + c2, c1, c0)) + end + + # ── Branches (in-service only) ──────────────────────────────────────────── + br_raw = collect(values(data["branch"])) + filter!(br -> Int(get(br, "br_status", 1)) == 1, br_raw) + sort!(br_raw, by = br -> Int(br["index"])) + branches = BranchData[] + branch_id_to_pos = Dict{Int,Int}() + for (pos, br) in enumerate(br_raw) + id = Int(br["index"]) + f_id = Int(br["f_bus"]); t_id = Int(br["t_bus"]) + (haskey(bus_id_to_pos, f_id) && haskey(bus_id_to_pos, t_id)) || + error("branch $id references an out-of-service/unknown bus " * + "($f_id → $t_id)") + tap = Float64(get(br, "tap", 1.0)); tap = tap ≈ 0 ? 1.0 : tap + rate = Float64(get(br, "rate_a", 0.0)) + rate_pu = rate ≈ 0 ? Inf : rate * s # 0 ⇒ unlimited (PowerModels convention) + branch_id_to_pos[id] = pos + push!(branches, BranchData(id, f_id, bus_id_to_pos[f_id], + t_id, bus_id_to_pos[t_id], + Float64(get(br, "br_r", 0.0)), + Float64(br["br_x"]), + Float64(get(br, "g_fr", 0.0)), + Float64(get(br, "b_fr", 0.0)), + Float64(get(br, "g_to", 0.0)), + Float64(get(br, "b_to", 0.0)), + tap, Float64(get(br, "shift", 0.0)), + rate_pu, + Float64(get(br, "angmin", -pi)), + Float64(get(br, "angmax", pi)))) + end + + # ── Loads (in-service only) ─────────────────────────────────────────────── + load_raw = collect(values(data["load"])) + filter!(l -> Int(get(l, "status", 1)) == 1, load_raw) + sort!(load_raw, by = l -> Int(l["index"])) + loads = LoadData[] + load_id_to_pos = Dict{Int,Int}() + bus_pd = zeros(Float64, length(buses)) + bus_qd = zeros(Float64, length(buses)) + for (pos, l) in enumerate(load_raw) + id = Int(l["index"]) + bus_id = Int(l["load_bus"]) + haskey(bus_id_to_pos, bus_id) || + error("load $id references an out-of-service/unknown bus $bus_id") + bpos = bus_id_to_pos[bus_id] + pd = Float64(get(l, "pd", 0.0)) * s + qd = Float64(get(l, "qd", 0.0)) * s + load_id_to_pos[id] = pos + push!(loads, LoadData(id, bus_id, bpos, pd, qd)) + bus_pd[bpos] += pd + bus_qd[bpos] += qd + end + + return NetworkData(String(case_name), sbase, buses, gens, branches, loads, + ref_bus_positions, bus_id_to_pos, gen_id_to_pos, + branch_id_to_pos, load_id_to_pos, bus_pd, bus_qd, per_unit) +end + +""" + load_pglib_network(name) -> (NetworkData, parse_meta) + +Resolve `name` in the pinned PGLib artifact, parse the `.m` file with +PowerModels, and return the typed [`NetworkData`] plus a small metadata +NamedTuple (`canonical_name`, `filepath`, `pglib_version`, `powermodels_version`) +recorded in the manifest. +""" +function load_pglib_network(name::AbstractString) + canonical, filepath = resolve_pglib_case(name) + data = PowerModels.parse_file(filepath) + nd = parse_network(data, canonical) + meta = (canonical_name = canonical, + filepath = filepath, + # SHA-256 of the exact MATPOWER source bytes (see manifest.jl); this + # pins provenance to the resolved network file. + matpower_sha256 = bytes2hex(open(SHA.sha256, filepath)), + pglib_version = _pkg_version("PGLib"), + powermodels_version = _pkg_version("PowerModels")) + return nd, meta +end + +# Resolve an installed dependency's version string by reading the active +# environment's Manifest.toml with the TOML stdlib. We deliberately avoid +# `using Pkg` at runtime: on this cluster Pkg's native precompile image is +# broken, so the example is kept Pkg-free (Pkg is only used, with +# --pkgimages=no, by the one-shot setup_env.jl). +function _pkg_version(name::AbstractString) + manifest = Base.active_project() === nothing ? nothing : + joinpath(dirname(Base.active_project()), "Manifest.toml") + (manifest === nothing || !isfile(manifest)) && return "unknown" + data = TOML.parsefile(manifest) + deps = get(data, "deps", data) # manifest format 2.0 nests under "deps" + entry = get(deps, name, nothing) + entry === nothing && return "unknown" + # Each package maps to a 1-element array of tables. + rec = entry isa AbstractVector ? first(entry) : entry + return string(get(rec, "version", "unknown")) +end diff --git a/examples/BatteryStorageOPF/src/reference_powermodels.jl b/examples/BatteryStorageOPF/src/reference_powermodels.jl new file mode 100644 index 0000000..ef7ec0c --- /dev/null +++ b/examples/BatteryStorageOPF/src/reference_powermodels.jl @@ -0,0 +1,79 @@ +# reference_powermodels.jl +# +# Independent base-ACP reference. PowerModels builds and solves the standard +# ACPPowerModel from the SAME PGLib file, on an entirely separate modeling stack +# (PowerModels/JuMP/Ipopt). With zero batteries (or zero battery power) our +# ExaModels deterministic equivalent must reproduce this objective within a +# declared tolerance — the model-correctness gate. + +using PowerModels +using JuMP +using Ipopt + +# Silence PowerModels' info logging during solves. +PowerModels.silence() + +""" + reference_ac_opf(case_name; print_level=0) -> NamedTuple + +Solve the base ACP OPF of PGLib `case_name` with PowerModels + Ipopt (no +batteries). Returns `(objective, status, termination, data)` where `objective` +is the operating cost in USD and `data` is the parsed PowerModels dict. +""" +function reference_ac_opf(case_name::AbstractString; print_level::Int = 0) + _, filepath = resolve_pglib_case(case_name) + data = PowerModels.parse_file(filepath) + optimizer = JuMP.optimizer_with_attributes(Ipopt.Optimizer, + "print_level" => print_level, + "tol" => 1e-8) + result = PowerModels.solve_ac_opf(data, optimizer) + return (objective = Float64(result["objective"]), + status = result["termination_status"], + solve_time = get(result, "solve_time", NaN), + data = data) +end + +""" + exa_base_objective(case_name; float_type=Float64, + madnlp_kwargs=(print_level=MadNLP.ERROR, tol=1e-8)) + -> NamedTuple + +Build a single-stage, zero-battery ExaModels deterministic equivalent for +`case_name` and solve it on the CPU, returning `(objective, status, prob, +result)`. This is the ExaModels side of the base-ACP parity check. +""" +function exa_base_objective(case_name::AbstractString; + float_type::Type{<:AbstractFloat} = Float64, + madnlp_kwargs = (print_level = MadNLP.ERROR, tol = 1e-8)) + case = make_battery_case(case_name; number_of_batteries = 0) + prob = build_battery_de(case, 1; float_type = float_type) + result = solve_de!(prob; madnlp_kwargs...) + return (objective = Float64(result.objective), + status = result.status, prob = prob, result = result) +end + +""" + check_base_acp_parity(case_name; rtol=1e-3, kwargs...) -> NamedTuple + +Compare the zero-battery ExaModels objective against the PowerModels/Ipopt +reference for `case_name`. Returns +`(reference, exa, abs_diff, rel_diff, within, rtol, ...)`. + +`rtol` default is 1e-3: AC-OPF is nonconvex, so the two independent +solver/model stacks can in principle settle at numerically distinct—but +physically equivalent—KKT points. In practice, with the shunt admittance and +generator costs modeled identically, agreement is far tighter — measured +≈1e-10 on case14_ieee and ≈1e-12 on case300_ieee — so the loose default only +guards against environment-dependent solver noise. +""" +function check_base_acp_parity(case_name::AbstractString; rtol::Real = 1e-3, kwargs...) + ref = reference_ac_opf(case_name) + exa = exa_base_objective(case_name; kwargs...) + absd = abs(exa.objective - ref.objective) + reld = absd / max(abs(ref.objective), eps()) + return (case_name = case_name, + reference = ref.objective, exa = exa.objective, + abs_diff = absd, rel_diff = reld, + within = reld <= rtol, rtol = Float64(rtol), + reference_status = ref.status, exa_status = exa.status) +end diff --git a/examples/BatteryStorageOPF/test/runtests.jl b/examples/BatteryStorageOPF/test/runtests.jl new file mode 100644 index 0000000..0ee6f07 --- /dev/null +++ b/examples/BatteryStorageOPF/test/runtests.jl @@ -0,0 +1,272 @@ +# runtests.jl — example-local tests for the Phase-1 battery-storage foundation. +# +# Run (from examples/BatteryStorageOPF): +# module load julia +# julia --pkgimages=no --project=. test/runtests.jl +# +# Fast checks (construction / manifest / mapping / validation) use a small PGLib +# case; solve-based checks use case14_ieee, with a construction+residual smoke +# and placement/count assertions on case300_ieee. + +include(joinpath(@__DIR__, "..", "src", "BatteryStorageOPF.jl")) +using .BatteryStorageOPF +using Test +using MadNLP +using JSON + +const SMALL = "case14_ieee" # small solve case +const BIG = "case300_ieee" # headline case + +@testset "BatteryStorageOPF Phase 1" begin + + # ── Reproducible placement + manifest hash ─────────────────────────────── + @testset "identical seed ⇒ identical placement and hash" begin + a = make_battery_case(SMALL; number_of_batteries = 3, seed = 123) + b = make_battery_case(SMALL; number_of_batteries = 3, seed = 123) + @test a.selected_bus_ids == b.selected_bus_ids + @test manifest_hash(a) == manifest_hash(b) + # Order is stable and consistent with the battery vector. + @test [bat.bus_id for bat in a.batteries] == a.selected_bus_ids + end + + @testset "different seed ⇒ different placement (when possible)" begin + # 3 batteries drawn from >3 eligible buses: distinct seeds should give a + # different ordered placement (and hence a different hash). + c1 = make_battery_case(SMALL; number_of_batteries = 3, seed = 1) + c2 = make_battery_case(SMALL; number_of_batteries = 3, seed = 2) + @test length(c1.eligible_bus_ids) > 3 + @test c1.selected_bus_ids != c2.selected_bus_ids + @test manifest_hash(c1) != manifest_hash(c2) + end + + # ── Input validation ───────────────────────────────────────────────────── + @testset "invalid inputs fail with clear errors" begin + @test_throws ErrorException make_battery_case("no_such_case_xyz") + @test_throws ErrorException make_battery_case(SMALL; number_of_batteries = 2, + charge_efficiency = 1.5) + @test_throws ErrorException make_battery_case(SMALL; number_of_batteries = 2, + discharge_efficiency = 0.0) + @test_throws ErrorException make_battery_case(SMALL; number_of_batteries = 2, + duration_hours = -1.0) + @test_throws ErrorException make_battery_case(SMALL; number_of_batteries = 2, + initial_soc = 1.5) + @test_throws ErrorException make_battery_case(SMALL; number_of_batteries = 2, + e_min_fraction = 0.6, initial_soc = 0.5) + @test_throws ErrorException make_battery_case(SMALL; number_of_batteries = 2, + self_discharge_rate = 1.2) + # Too many batteries for the eligible pool. + @test_throws ErrorException make_battery_case(SMALL; number_of_batteries = 10_000) + # Explicit bad bus. + @test_throws ErrorException make_battery_case(SMALL; number_of_batteries = 1, + buses = [-999]) + # Explicit duplicate buses. + elig = eligible_load_bus_ids(make_battery_case(SMALL; number_of_batteries = 0).network) + @test_throws ErrorException make_battery_case(SMALL; number_of_batteries = 2, + buses = [elig[1], elig[1]]) + end + + # ── Non-consecutive identifier mapping (synthetic, exact) ──────────────── + @testset "arbitrary / non-consecutive id mapping" begin + # Hand-built PowerModels-style dict with deliberately non-consecutive, + # out-of-order bus ids and an isolated (type-4) bus that must be dropped. + data = Dict{String,Any}( + "baseMVA" => 100.0, "per_unit" => false, + "bus" => Dict( + "1" => Dict("index" => 100, "bus_type" => 3, "vmin" => 0.9, "vmax" => 1.1), + "2" => Dict("index" => 5, "bus_type" => 1, "vmin" => 0.9, "vmax" => 1.1), + "3" => Dict("index" => 42, "bus_type" => 1, "vmin" => 0.9, "vmax" => 1.1), + "4" => Dict("index" => 7, "bus_type" => 4, "vmin" => 0.9, "vmax" => 1.1), + ), + "gen" => Dict("1" => Dict("index" => 9, "gen_bus" => 100, "pmax" => 500.0, + "pmin" => 0.0, "model" => 2, "ncost" => 3, + "cost" => [0.1, 20.0, 5.0])), + "branch" => Dict( + "1" => Dict("index" => 3, "f_bus" => 100, "t_bus" => 5, "br_x" => 0.1, + "br_r" => 0.01, "rate_a" => 3.0), + "2" => Dict("index" => 1, "f_bus" => 5, "t_bus" => 42, "br_x" => 0.2, + "br_r" => 0.02, "rate_a" => 0.0)), # 0 ⇒ unlimited + "load" => Dict( + "1" => Dict("index" => 2, "load_bus" => 5, "pd" => 100.0, "qd" => 20.0), + "2" => Dict("index" => 1, "load_bus" => 42, "pd" => 50.0, "qd" => 10.0)), + ) + nd = parse_network(data, "synthetic") + # Buses sorted by original id; type-4 dropped. + @test [b.id for b in nd.buses] == [5, 42, 100] + @test nbus(nd) == 3 + @test nd.bus_id_to_pos[100] == 3 && nd.bus_id_to_pos[5] == 1 + # Gen/branch/load references resolved to positions, ids preserved. + # Components are stored sorted by original id, so look them up by id map + # (never by insertion order). + @test nd.gens[nd.gen_id_to_pos[9]].bus_pos == nd.bus_id_to_pos[100] + br3 = nd.branches[nd.branch_id_to_pos[3]] # branch id 3: bus 100 → bus 5 + @test br3.f_pos == nd.bus_id_to_pos[100] + @test br3.t_pos == nd.bus_id_to_pos[5] + @test isfinite(br3.rate_a) # rate_a = 3 ⇒ limited + br1 = nd.branches[nd.branch_id_to_pos[1]] # branch id 1: rate_a = 0 + @test isinf(br1.rate_a) # 0 rate ⇒ unlimited + # Per-unit conversion (÷ baseMVA) applied to loads and gen limits. + @test nd.bus_pd[nd.bus_id_to_pos[5]] ≈ 1.0 + @test nd.gens[1].pmax ≈ 5.0 + # Cost converted to pu: c1_pu = 20 · 100, c2_pu = 0.1 · 100². + @test nd.gens[1].cost1 ≈ 2000.0 + @test nd.gens[1].cost2 ≈ 1000.0 + @test 100 in nd.ref_bus_positions .|> (p -> nd.buses[p].id) + end + + # ── case300 structure + placement ──────────────────────────────────────── + @testset "case300 has 300 buses and 20 valid battery buses" begin + case = make_battery_case(BIG; number_of_batteries = 20, seed = 20260722) + @test nbus(case.network) == 300 + @test length(case.batteries) == 20 + @test length(unique(case.selected_bus_ids)) == 20 + # Every battery bus is a valid, in-service load bus. + elig = Set(eligible_load_bus_ids(case.network)) + @test all(b -> b.bus_id in elig, case.batteries) + @test all(b -> haskey(case.network.bus_id_to_pos, b.bus_id), case.batteries) + # case300 genuinely has non-consecutive bus ids (position ≠ id somewhere). + @test any(i -> case.network.buses[i].id != i, 1:nbus(case.network)) + validate_battery_case(case) # must not throw + end + + # ── Manifest round-trip / verified reconstruction / provenance ─────────── + @testset "manifest write, verified reconstruction, and tampering" begin + case = make_battery_case(SMALL; number_of_batteries = 3, seed = 77) + dir = mktempdir() + man = joinpath(dir, "manifest.json") + bat = joinpath(dir, "batteries.csv") + write_battery_file(case, bat) + write_manifest(case, man; extra_files = [bat]) + @test isfile(man) && isfile(bat) + + # Provenance fields are present and explicit. + m = JSON.parsefile(man) + @test haskey(m["pglib"], "matpower_file") + @test length(String(m["pglib"]["matpower_sha256"])) == 64 + @test m["pglib"]["license"] == "Creative Commons Attribution 4.0 International" + @test m["pglib"]["license_url"] == "https://creativecommons.org/licenses/by/4.0/" + @test haskey(m["pglib"], "upstream_release") + @test haskey(m["versions"], "PGLib") && haskey(m["versions"], "PowerModels") && + haskey(m["versions"], "julia") + # The MATPOWER source hash participates in the scientific content hash. + @test occursin(String(m["pglib"]["matpower_sha256"]), canonical_content(case)) + + # Normal reconstruction succeeds and verifies source bytes + placement + # + battery parameters. + rc = reconstruct_case(man) + @test rc.selected_bus_ids == case.selected_bus_ids + @test manifest_hash(rc) == manifest_hash(case) + + # Identical inputs ⇒ identical placement and manifest hash. + again = make_battery_case(SMALL; number_of_batteries = 3, seed = 77) + @test again.selected_bus_ids == case.selected_bus_ids + @test manifest_hash(again) == manifest_hash(case) + + # Tampering with the recorded source-file hash must fail reconstruction. + m["pglib"]["matpower_sha256"] = repeat("0", 64) + tampered = joinpath(dir, "tampered.json") + open(io -> JSON.print(io, m, 2), tampered, "w") + @test_throws ErrorException reconstruct_case(tampered) + end + + # ── Solve: status, residuals, no simultaneous charge/discharge ─────────── + @testset "case14 solve: status + residuals + battery operation" begin + case = make_battery_case(SMALL; number_of_batteries = 3, seed = 5, + fleet_power_fraction = 0.3, duration_hours = 4.0) + prob = build_battery_de(case, 3; stage_hours = 1.0, + demand_profile = [0.9, 1.1, 1.0]) + result = solve_de!(prob; print_level = MadNLP.ERROR, tol = 1e-8) + @test solve_succeeded(result.status) + sol = battery_solution(prob, result) + @test max_primal_residual(prob, result) < 1e-5 + @test maximum(abs, battery_balance_residuals(prob, sol)) < 1e-6 + # Cycle cost ⇒ no material simultaneous charge & discharge. + @test maximum(simultaneous_charge_discharge_power(sol)) < 1e-5 + # SoC stays within bounds. + @test all(case.batteries[1].e_min - 1e-6 .<= sol.soc .<= case.batteries[1].e_max + 1e-6) + end + + # ── Base-ACP parity (zero batteries and zero power) ────────────────────── + @testset "zero-battery / zero-power base-ACP parity" begin + # Small case: strict agreement (measured ≈1e-10 relative). + p0 = check_base_acp_parity(SMALL; rtol = 1e-6) + @test p0.within + # Headline case300: same check, conservative tolerance (measured ≈1e-12). + pbig = check_base_acp_parity(BIG; rtol = 1e-4) + @test pbig.within + # Zero battery POWER (fleet_power_fraction = 0) with 3 placed batteries + # must also reproduce the base objective. + ref = reference_ac_opf(SMALL).objective + case0 = make_battery_case(SMALL; number_of_batteries = 3, seed = 9, + fleet_power_fraction = 0.0) + prob0 = build_battery_de(case0, 1) + r0 = solve_de!(prob0; print_level = MadNLP.ERROR, tol = 1e-8) + @test solve_succeeded(r0.status) + @test abs(r0.objective - ref) / abs(ref) < 1e-5 + end + + # ── case300 construction + residual smoke ──────────────────────────────── + @testset "case300 construction + residual smoke" begin + case = make_battery_case(BIG; number_of_batteries = 20, seed = 20260722) + prob = build_battery_de(case, 2; stage_hours = 1.0, + demand_profile = [1.0, 1.02]) + result = solve_de!(prob; print_level = MadNLP.ERROR, tol = 1e-6, max_iter = 1000) + @test solve_succeeded(result.status) + sol = battery_solution(prob, result) + @test max_primal_residual(prob, result) < 1e-4 + @test maximum(abs, battery_balance_residuals(prob, sol)) < 1e-6 + @test maximum(simultaneous_charge_discharge_power(sol)) < 1e-4 + end + + # ── Stage-duration (Δt) generator-cost scaling ─────────────────────────── + # PGLib polynomial costs are USD/hour, so a Δt-hour stage costs Δt× the + # one-hour dispatch. These regressions fail under an implementation that + # omits Δt from the generator cost. + @testset "stage-duration (Δt) cost scaling" begin + ref1h = reference_ac_opf(SMALL).objective # independent 1-hour ACP + case0 = make_battery_case(SMALL; number_of_batteries = 0) + madnlp = (print_level = MadNLP.ERROR, tol = 1e-8) + + # Δt = 1 (retained parity): single stage equals the one-hour reference. + p1 = build_battery_de(case0, 1; stage_hours = 1.0) + r1 = solve_de!(p1; madnlp...) + @test solve_succeeded(r1.status) + @test abs(r1.objective - ref1h) / abs(ref1h) < 1e-5 + + # T=1, Δt=2: objective is ≈ 2× the one-hour reference. + p2 = build_battery_de(case0, 1; stage_hours = 2.0) + r2 = solve_de!(p2; madnlp...) + @test solve_succeeded(r2.status) + @test abs(r2.objective - 2 * ref1h) / abs(2 * ref1h) < 1e-5 + + # T=2, Δt=0.5, flat demand: two half-hour stages sum to the one-hour ref. + p3 = build_battery_de(case0, 2; stage_hours = 0.5, demand_profile = [1.0, 1.0]) + r3 = solve_de!(p3; madnlp...) + @test solve_succeeded(r3.status) + @test abs(r3.objective - ref1h) / abs(ref1h) < 1e-5 + + # Nonpositive / nonfinite stage_hours are rejected. + @test_throws ErrorException build_battery_de(case0, 1; stage_hours = 0.0) + @test_throws ErrorException build_battery_de(case0, 1; stage_hours = -1.0) + @test_throws ErrorException build_battery_de(case0, 1; stage_hours = Inf) + @test_throws ErrorException build_battery_de(case0, 1; stage_hours = NaN) + end + + # ── Per-battery cycle-cost coefficients (not the first battery's) ───────── + @testset "per-battery cycle-cost coefficients" begin + # Two batteries whose cycle price we can distinguish: build with distinct + # per-battery cycle costs by editing the case's battery vector. + case = make_battery_case(SMALL; number_of_batteries = 2, seed = 3) + b1, b2 = case.batteries + case.batteries[1] = BatteryData(b1.id, b1.bus_id, b1.bus_pos, + b1.p_charge_max, b1.p_discharge_max, b1.e_min, b1.e_max, b1.e_init, + b1.eta_ch, b1.eta_dis, b1.sigma, 1.0) # $1/MWh + case.batteries[2] = BatteryData(b2.id, b2.bus_id, b2.bus_pos, + b2.p_charge_max, b2.p_discharge_max, b2.e_min, b2.e_max, b2.e_init, + b2.eta_ch, b2.eta_dis, b2.sigma, 7.0) # $7/MWh + prob = build_battery_de(case, 2; stage_hours = 1.5) + # Coefficient k = cycle_cost_per_mwh_k · baseMVA · Δt, per battery. + @test prob.cycle_coeffs[1] ≈ 1.0 * case.network.baseMVA * 1.5 + @test prob.cycle_coeffs[2] ≈ 7.0 * case.network.baseMVA * 1.5 + @test prob.cycle_coeffs[1] != prob.cycle_coeffs[2] + end +end diff --git a/examples/HydroPowerModels/Project.toml b/examples/HydroPowerModels/Project.toml deleted file mode 100644 index 30e1a40..0000000 --- a/examples/HydroPowerModels/Project.toml +++ /dev/null @@ -1,21 +0,0 @@ -[deps] -CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b" -CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" -CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" -CUDSS_jll = "4889d778-9329-5762-9fec-0578a5d30366" -ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" -DecisionRulesExa = "7c3e91a4-d8f2-4b6a-9e15-a2c4f7b80d53" -ExaModels = "1037b233-b668-4ce9-9b63-f9f681f55dd2" -Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c" -JLD2 = "033835bb-8acc-5ee8-8aae-3f567f8a3819" -JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" -KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" -MadNLP = "2621e9c9-9eb4-46b1-8089-e8c72242dfb6" -MadNLPGPU = "d72a61cc-809d-412f-99be-fd81f4b8a598" -Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" -Wandb = "ad70616a-06c9-5745-b1f1-6a5f42545108" -Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" -cuDNN = "02a925ec-e4fe-4b08-9a7e-0d78e3d38ccd" - -[sources] -DecisionRulesExa = {path = "../.."} diff --git a/examples/HydroPowerModels/README.md b/examples/HydroPowerModels/README.md deleted file mode 100644 index 65f91a6..0000000 --- a/examples/HydroPowerModels/README.md +++ /dev/null @@ -1,111 +0,0 @@ -# HydroPowerModels Example - -Multi-stage hydrothermal scheduling using DecisionRulesExa.jl with DC or AC OPF formulations. - -## Problem description - -A hydro-dominated power system (Bolivia test case) is operated over a planning horizon of up to 96 stages. At each stage, the operator must decide generator dispatch, reservoir outflows, and spillage subject to: - -- **Power flow constraints** (DC linearization or full AC polar OPF) -- **Reservoir dynamics** (water balance with stochastic inflows) -- **Generator and transmission limits** - -The TS-DDR policy (an LSTM network) predicts target reservoir levels at each stage. The deterministic-equivalent NLP projects these targets onto the feasible set via slack-penalized target constraints. Training uses envelope-theorem gradients: dual multipliers on the target constraints give the policy gradient without differentiating through the solver. - -## Formulations - -Set `FORMULATION` in `train_hydro_exa.jl`: - -| Formulation | `FORMULATION` | Variables per stage | Description | -|---|---|---|---| -| DC OPF | `:dc` | ~500 | Linear power flow, fast solves | -| AC Polar OPF | `:ac_polar` | ~2000 | Full nonlinear AC power flow | - -## Data - -The `bolivia/` directory contains: - -- `PowerModels.json` — power system topology (39 buses, 55 branches, 19 generators) -- `hydro.json` — hydro unit parameters (7 reservoirs) -- `inflows.csv` — historical inflow scenarios (144 stages x 200 scenarios x 7 reservoirs) -- `_demand.csv` — per-stage bus demand scaling - -Pre-solved deterministic-equivalent references (MOF format) are provided for validation: -- `DCPPowerModel.mof.json` -- `ACPPowerModel.mof.json` - -## Files - -| File | Description | -|---|---| -| `train_hydro_exa.jl` | Main training script with penalty scheduling, parallel GPU solves, and W&B logging | -| `train_hydro_exa_critic.jl` | Critic/control-variate variant of the main training script; uses normalized hydro features, a replay buffer, and cheap critic rollouts | -| `hydro_power_data.jl` | Data parsing (PowerModels JSON, hydro JSON, inflows CSV) | -| `hydro_power_exa.jl` | ExaModels problem builder for DC and AC OPF formulations | -| `eval_exa_de.jl` | Validation script comparing ExaModels results against JuMP reference | -| `Project.toml` | Example-specific dependencies (W&B, JLD2, CUDA, etc.) | - -## Running - -### GPU training (recommended) - -```julia -# From this directory: -julia --project -t auto train_hydro_exa.jl -``` - -Set `USE_GPU = true` in `train_hydro_exa.jl` (default). Requires a CUDA-capable GPU. - -### GPU training with critic control variate - -```julia -# From this directory: -julia --project -t auto train_hydro_exa_critic.jl -``` - -The critic script keeps the dual-multiplier actor update but adds a damped -control variate (`critic_cv_weight = 0.5`) trained on the stage-wise rollout -objective without target penalty. Its default critic rollout uses -`policy_state = :target`; set `CRITIC_POLICY_STATE = :realized` for closed-loop -critic labels. Deterministic-equivalent critic fitting remains available as an -ablation through `DeterministicEquivalentCriticTarget()`. - -### CPU training - -Set `USE_GPU = false` in `train_hydro_exa.jl`, then run the same command. - -### Configuration - -Key parameters in `train_hydro_exa.jl`: - -| Parameter | Default | Description | -|---|---|---| -| `FORMULATION` | `:ac_polar` | OPF formulation (`:dc` or `:ac_polar`) | -| `NUM_STAGES` | 96 | Planning horizon | -| `NUM_EPOCHS` | 20 | Training epochs | -| `NUM_BATCHES` | 100 | Gradient steps per epoch | -| `NUM_WORKERS` | 4 | Parallel GPU solver instances | -| `LAYERS` | `[128, 128]` | LSTM hidden layer sizes | -| `LR` | 1e-3 | Learning rate | -| `DEFICIT_COST` | 1e5 | Load-shedding penalty ($/pu) | - -### Training features - -- **Penalty scheduling**: target penalty multiplier ramps through phases (0.1 -> 1.0 -> 10.0 -> 30.0) over training -- **Sample scheduling**: `num_train_per_batch` increases from `NUM_WORKERS` to `8 * NUM_WORKERS` -- **Evaluation scheduling**: rollout evaluation starts with 4 scenarios and ramps to 32 at halfway -- **Parallel solves**: independent NLP copies solved concurrently via `Threads.@spawn` worker pool -- **Parallel rollout**: evaluation scenarios distributed across CPU stage-problem copies -- **Critic variant**: optional scalar critic with value and gradient matching, - replay-buffer training, and cheap critic actor samples -- **W&B logging**: training loss, rollout objectives, violation share, penalty multiplier - -## Validation - -Compare the ExaModels formulation against a JuMP/MadNLP reference: - -```julia -julia --project -t auto eval_exa_de.jl -``` - -This loads a pre-solved JuMP reference and solves the same problem in ExaModels, printing a side-by-side comparison of objectives and reservoir trajectories. diff --git a/examples/HydroPowerModels/bolivia/ACPPowerModel.mof.json b/examples/HydroPowerModels/bolivia/ACPPowerModel.mof.json deleted file mode 100644 index 5e63547..0000000 --- a/examples/HydroPowerModels/bolivia/ACPPowerModel.mof.json +++ /dev/null @@ -1,39045 +0,0 @@ -{ - "name": "MathOptFormat Model", - "version": { - "major": 1, - "minor": 7 - }, - "variables": [ - { - "name": "reservoir[1]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[2]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[3]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[4]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[5]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[6]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[7]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[8]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[9]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[10]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[11]_in", - "primal_start": 0.0 - }, - { - "name": "inflow[1]", - "primal_start": 0.0 - }, - { - "name": "inflow[2]", - "primal_start": 0.0 - }, - { - "name": "inflow[3]", - "primal_start": 0.0 - }, - { - "name": "inflow[4]", - "primal_start": 0.0 - }, - { - "name": "inflow[5]", - "primal_start": 0.0 - }, - { - "name": "inflow[6]", - "primal_start": 0.0 - }, - { - "name": "inflow[7]", - "primal_start": 0.0 - }, - { - "name": "inflow[8]", - "primal_start": 0.0 - }, - { - "name": "inflow[9]", - "primal_start": 0.0 - }, - { - "name": "inflow[10]", - "primal_start": 0.0 - }, - { - "name": "inflow[11]", - "primal_start": 0.0 - }, - { - "name": "0_vm[5]", - "primal_start": 1.0 - }, - { - "name": "0_vm[16]", - "primal_start": 1.0 - }, - { - "name": "0_vm[20]", - "primal_start": 1.0 - }, - { - "name": "0_vm[12]", - "primal_start": 1.0 - }, - { - "name": "0_vm[24]", - "primal_start": 1.0 - }, - { - "name": "0_vm[28]", - "primal_start": 1.0 - }, - { - "name": "0_vm[8]", - "primal_start": 1.0 - }, - { - "name": "0_vm[17]", - "primal_start": 1.0 - }, - { - "name": "0_vm[1]", - "primal_start": 1.0 - }, - { - "name": "0_vm[23]", - "primal_start": 1.0 - }, - { - "name": "0_vm[22]", - "primal_start": 1.0 - }, - { - "name": "0_vm[19]", - "primal_start": 1.0 - }, - { - "name": "0_vm[6]", - "primal_start": 1.0 - }, - { - "name": "0_vm[11]", - "primal_start": 1.0 - }, - { - "name": "0_vm[9]", - "primal_start": 1.0 - }, - { - "name": "0_vm[14]", - "primal_start": 1.0 - }, - { - "name": "0_vm[3]", - "primal_start": 1.0 - }, - { - "name": "0_vm[7]", - "primal_start": 1.0 - }, - { - "name": "0_vm[25]", - "primal_start": 1.0 - }, - { - "name": "0_vm[4]", - "primal_start": 1.0 - }, - { - "name": "0_vm[13]", - "primal_start": 1.0 - }, - { - "name": "0_vm[15]", - "primal_start": 1.0 - }, - { - "name": "0_vm[2]", - "primal_start": 1.0 - }, - { - "name": "0_vm[27]", - "primal_start": 1.0 - }, - { - "name": "0_vm[21]", - "primal_start": 1.0 - }, - { - "name": "0_vm[26]", - "primal_start": 1.0 - }, - { - "name": "0_vm[10]", - "primal_start": 1.0 - }, - { - "name": "0_vm[18]", - "primal_start": 1.0 - }, - { - "name": "0_pg[5]", - "primal_start": 0.0 - }, - { - "name": "0_pg[16]", - "primal_start": 0.0 - }, - { - "name": "0_pg[20]", - "primal_start": 0.0 - }, - { - "name": "0_pg[12]", - "primal_start": 0.0 - }, - { - "name": "0_pg[24]", - "primal_start": 0.0 - }, - { - "name": "0_pg[28]", - "primal_start": 0.0 - }, - { - "name": "0_pg[8]", - "primal_start": 0.0 - }, - { - "name": "0_pg[17]", - "primal_start": 0.0 - }, - { - "name": "0_pg[30]", - "primal_start": 0.0 - }, - { - "name": "0_pg[1]", - "primal_start": 0.0 - }, - { - "name": "0_pg[23]", - "primal_start": 0.0 - }, - { - "name": "0_pg[32]", - "primal_start": 0.0 - }, - { - "name": "0_pg[22]", - "primal_start": 0.0 - }, - { - "name": "0_pg[6]", - "primal_start": 0.0 - }, - { - "name": "0_pg[19]", - "primal_start": 0.0 - }, - { - "name": "0_pg[11]", - "primal_start": 0.0 - }, - { - "name": "0_pg[31]", - "primal_start": 0.0 - }, - { - "name": "0_pg[9]", - "primal_start": 0.0 - }, - { - "name": "0_pg[14]", - "primal_start": 0.0 - }, - { - "name": "0_pg[3]", - "primal_start": 0.0 - }, - { - "name": "0_pg[29]", - "primal_start": 0.0 - }, - { - "name": "0_pg[33]", - "primal_start": 0.0 - }, - { - "name": "0_pg[25]", - "primal_start": 0.0 - }, - { - "name": "0_pg[7]", - "primal_start": 0.0 - }, - { - "name": "0_pg[34]", - "primal_start": 0.0 - }, - { - "name": "0_pg[4]", - "primal_start": 0.0 - }, - { - "name": "0_pg[13]", - "primal_start": 0.0 - }, - { - "name": "0_pg[15]", - "primal_start": 0.0 - }, - { - "name": "0_pg[2]", - "primal_start": 0.0 - }, - { - "name": "0_pg[27]", - "primal_start": 0.0 - }, - { - "name": "0_pg[21]", - "primal_start": 0.0 - }, - { - "name": "0_pg[26]", - "primal_start": 0.0 - }, - { - "name": "0_pg[10]", - "primal_start": 0.0 - }, - { - "name": "0_pg[18]", - "primal_start": 0.0 - }, - { - "name": "0_qg[5]", - "primal_start": 0.0 - }, - { - "name": "0_qg[16]", - "primal_start": 0.0 - }, - { - "name": "0_qg[20]", - "primal_start": 0.0 - }, - { - "name": "0_qg[12]", - "primal_start": 0.0 - }, - { - "name": "0_qg[24]", - "primal_start": 0.0 - }, - { - "name": "0_qg[28]", - "primal_start": 0.0 - }, - { - "name": "0_qg[8]", - "primal_start": 0.0 - }, - { - "name": "0_qg[17]", - "primal_start": 0.0 - }, - { - "name": "0_qg[30]", - "primal_start": 0.0 - }, - { - "name": "0_qg[1]", - "primal_start": 0.0 - }, - { - "name": "0_qg[23]", - "primal_start": 0.0 - }, - { - "name": "0_qg[32]", - "primal_start": 0.0 - }, - { - "name": "0_qg[22]", - "primal_start": 0.0 - }, - { - "name": "0_qg[6]", - "primal_start": 0.0 - }, - { - "name": "0_qg[19]", - "primal_start": 0.0 - }, - { - "name": "0_qg[11]", - "primal_start": 0.0 - }, - { - "name": "0_qg[31]", - "primal_start": 0.0 - }, - { - "name": "0_qg[9]", - "primal_start": 0.0 - }, - { - "name": "0_qg[14]", - "primal_start": 0.0 - }, - { - "name": "0_qg[3]", - "primal_start": 0.0 - }, - { - "name": "0_qg[29]", - "primal_start": 0.0 - }, - { - "name": "0_qg[33]", - "primal_start": 0.0 - }, - { - "name": "0_qg[25]", - "primal_start": 0.0 - }, - { - "name": "0_qg[7]", - "primal_start": 0.0 - }, - { - "name": "0_qg[34]", - "primal_start": 0.0 - }, - { - "name": "0_qg[4]", - "primal_start": 0.0 - }, - { - "name": "0_qg[13]", - "primal_start": 0.0 - }, - { - "name": "0_qg[15]", - "primal_start": 0.0 - }, - { - "name": "0_qg[2]", - "primal_start": 0.0 - }, - { - "name": "0_qg[27]", - "primal_start": 0.0 - }, - { - "name": "0_qg[21]", - "primal_start": 0.0 - }, - { - "name": "0_qg[26]", - "primal_start": 0.0 - }, - { - "name": "0_qg[10]", - "primal_start": 0.0 - }, - { - "name": "0_qg[18]", - "primal_start": 0.0 - }, - { - "name": "0_p[(5, 5, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(16, 13, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(20, 16, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(12, 9, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(24, 21, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(28, 25, 26)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(8, 7, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(17, 14, 15)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(30, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(1, 2, 1)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(23, 20, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(22, 16, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(19, 14, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(6, 5, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(11, 9, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(31, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(9, 7, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(14, 11, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(3, 3, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(29, 17, 27)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(7, 6, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(25, 22, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(4, 4, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(13, 9, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(15, 12, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(2, 2, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(27, 24, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(21, 18, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(26, 23, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(10, 8, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(18, 14, 20)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(5, 6, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(16, 14, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(20, 17, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(12, 12, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(24, 22, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(28, 26, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(8, 8, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(17, 15, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(30, 28, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(1, 1, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(23, 21, 20)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(22, 19, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(19, 16, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(6, 11, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(11, 10, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(31, 28, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(9, 10, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(14, 18, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(3, 4, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(29, 27, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(7, 7, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(25, 23, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(4, 5, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(13, 16, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(15, 13, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(2, 3, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(27, 25, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(21, 16, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(26, 24, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(10, 9, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(18, 20, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(5, 5, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(16, 13, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(20, 16, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(12, 9, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(24, 21, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(28, 25, 26)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(8, 7, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(17, 14, 15)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(30, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(1, 2, 1)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(23, 20, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(22, 16, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(19, 14, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(6, 5, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(11, 9, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(31, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(9, 7, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(14, 11, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(3, 3, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(29, 17, 27)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(7, 6, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(25, 22, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(4, 4, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(13, 9, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(15, 12, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(2, 2, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(27, 24, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(21, 18, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(26, 23, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(10, 8, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(18, 14, 20)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(5, 6, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(16, 14, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(20, 17, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(12, 12, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(24, 22, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(28, 26, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(8, 8, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(17, 15, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(30, 28, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(1, 1, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(23, 21, 20)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(22, 19, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(19, 16, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(6, 11, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(11, 10, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(31, 28, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(9, 10, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(14, 18, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(3, 4, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(29, 27, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(7, 7, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(25, 23, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(4, 5, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(13, 16, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(15, 13, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(2, 3, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(27, 25, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(21, 16, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(26, 24, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(10, 9, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(18, 20, 14)]", - "primal_start": 0.0 - }, - { - "name": "reservoir[1]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[2]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[3]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[4]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[5]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[6]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[7]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[8]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[9]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[10]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[11]_out", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[1]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[2]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[3]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[4]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[5]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[6]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[7]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[8]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[9]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[10]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[11]", - "primal_start": 0.0 - }, - { - "name": "outflow[1]", - "primal_start": 0.0 - }, - { - "name": "outflow[2]", - "primal_start": 0.0 - }, - { - "name": "outflow[3]", - "primal_start": 0.0 - }, - { - "name": "outflow[4]", - "primal_start": 0.0 - }, - { - "name": "outflow[5]", - "primal_start": 0.0 - }, - { - "name": "outflow[6]", - "primal_start": 0.0 - }, - { - "name": "outflow[7]", - "primal_start": 0.0 - }, - { - "name": "outflow[8]", - "primal_start": 0.0 - }, - { - "name": "outflow[9]", - "primal_start": 0.0 - }, - { - "name": "outflow[10]", - "primal_start": 0.0 - }, - { - "name": "outflow[11]", - "primal_start": 0.0 - }, - { - "name": "spill[1]", - "primal_start": 0.0 - }, - { - "name": "spill[2]", - "primal_start": 0.0 - }, - { - "name": "spill[3]", - "primal_start": 0.0 - }, - { - "name": "spill[4]", - "primal_start": 0.0 - }, - { - "name": "spill[5]", - "primal_start": 0.0 - }, - { - "name": "spill[6]", - "primal_start": 0.0 - }, - { - "name": "spill[7]", - "primal_start": 0.0 - }, - { - "name": "spill[8]", - "primal_start": 0.0 - }, - { - "name": "spill[9]", - "primal_start": 0.0 - }, - { - "name": "spill[10]", - "primal_start": 0.0 - }, - { - "name": "spill[11]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[1]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[2]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[3]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[4]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[5]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[6]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[7]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[8]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[9]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[10]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[11]", - "primal_start": 0.0 - }, - { - "name": "deficit[1]", - "primal_start": 0.0 - }, - { - "name": "deficit[2]", - "primal_start": 0.0 - }, - { - "name": "deficit[3]", - "primal_start": 0.0 - }, - { - "name": "deficit[4]", - "primal_start": 0.0 - }, - { - "name": "deficit[5]", - "primal_start": 0.0 - }, - { - "name": "deficit[6]", - "primal_start": 0.0 - }, - { - "name": "deficit[7]", - "primal_start": 0.0 - }, - { - "name": "deficit[8]", - "primal_start": 0.0 - }, - { - "name": "deficit[9]", - "primal_start": 0.0 - }, - { - "name": "deficit[10]", - "primal_start": 0.0 - }, - { - "name": "deficit[11]", - "primal_start": 0.0 - }, - { - "name": "deficit[12]", - "primal_start": 0.0 - }, - { - "name": "deficit[13]", - "primal_start": 0.0 - }, - { - "name": "deficit[14]", - "primal_start": 0.0 - }, - { - "name": "deficit[15]", - "primal_start": 0.0 - }, - { - "name": "deficit[16]", - "primal_start": 0.0 - }, - { - "name": "deficit[17]", - "primal_start": 0.0 - }, - { - "name": "deficit[18]", - "primal_start": 0.0 - }, - { - "name": "deficit[19]", - "primal_start": 0.0 - }, - { - "name": "deficit[20]", - "primal_start": 0.0 - }, - { - "name": "deficit[21]", - "primal_start": 0.0 - }, - { - "name": "deficit[22]", - "primal_start": 0.0 - }, - { - "name": "deficit[23]", - "primal_start": 0.0 - }, - { - "name": "deficit[24]", - "primal_start": 0.0 - }, - { - "name": "deficit[25]", - "primal_start": 0.0 - }, - { - "name": "deficit[26]", - "primal_start": 0.0 - }, - { - "name": "deficit[27]", - "primal_start": 0.0 - }, - { - "name": "deficit[28]", - "primal_start": 0.0 - }, - { - "name": "0_va[5]", - "primal_start": 0.0 - }, - { - "name": "0_va[16]", - "primal_start": 0.0 - }, - { - "name": "0_va[20]", - "primal_start": 0.0 - }, - { - "name": "0_va[12]", - "primal_start": 0.0 - }, - { - "name": "0_va[24]", - "primal_start": 0.0 - }, - { - "name": "0_va[28]", - "primal_start": 0.0 - }, - { - "name": "0_va[8]", - "primal_start": 0.0 - }, - { - "name": "0_va[17]", - "primal_start": 0.0 - }, - { - "name": "0_va[1]", - "primal_start": 0.0 - }, - { - "name": "0_va[23]", - "primal_start": 0.0 - }, - { - "name": "0_va[22]", - "primal_start": 0.0 - }, - { - "name": "0_va[19]", - "primal_start": 0.0 - }, - { - "name": "0_va[6]", - "primal_start": 0.0 - }, - { - "name": "0_va[11]", - "primal_start": 0.0 - }, - { - "name": "0_va[9]", - "primal_start": 0.0 - }, - { - "name": "0_va[14]", - "primal_start": 0.0 - }, - { - "name": "0_va[3]", - "primal_start": 0.0 - }, - { - "name": "0_va[7]", - "primal_start": 0.0 - }, - { - "name": "0_va[25]", - "primal_start": 0.0 - }, - { - "name": "0_va[4]", - "primal_start": 0.0 - }, - { - "name": "0_va[13]", - "primal_start": 0.0 - }, - { - "name": "0_va[15]", - "primal_start": 0.0 - }, - { - "name": "0_va[2]", - "primal_start": 0.0 - }, - { - "name": "0_va[27]", - "primal_start": 0.0 - }, - { - "name": "0_va[21]", - "primal_start": 0.0 - }, - { - "name": "0_va[26]", - "primal_start": 0.0 - }, - { - "name": "0_va[10]", - "primal_start": 0.0 - }, - { - "name": "0_va[18]", - "primal_start": 0.0 - } - ], - "objective": { - "sense": "min", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 6000.0, - "variable": "deficit[1]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[2]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[3]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[4]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[5]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[6]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[7]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[8]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[9]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[10]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[11]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[12]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[13]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[14]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[15]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[16]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[17]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[18]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[19]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[20]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[21]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[22]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[23]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[24]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[25]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[26]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[27]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[28]" - }, - { - "coefficient": 2268.0, - "variable": "0_pg[5]" - }, - { - "coefficient": 2059.0, - "variable": "0_pg[16]" - }, - { - "coefficient": 1780.0, - "variable": "0_pg[20]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[12]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[24]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[28]" - }, - { - "coefficient": 1754.0, - "variable": "0_pg[8]" - }, - { - "coefficient": 2059.0, - "variable": "0_pg[17]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[30]" - }, - { - "coefficient": 1918.0, - "variable": "0_pg[1]" - }, - { - "coefficient": 4244.0, - "variable": "0_pg[23]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[32]" - }, - { - "coefficient": 1517.0, - "variable": "0_pg[22]" - }, - { - "coefficient": 2131.0, - "variable": "0_pg[6]" - }, - { - "coefficient": 1780.0, - "variable": "0_pg[19]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[11]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[31]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[9]" - }, - { - "coefficient": 1404.0, - "variable": "0_pg[14]" - }, - { - "coefficient": 2184.0, - "variable": "0_pg[3]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[29]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[33]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[25]" - }, - { - "coefficient": 1822.0, - "variable": "0_pg[7]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[34]" - }, - { - "coefficient": 2179.0, - "variable": "0_pg[4]" - }, - { - "coefficient": 1404.0, - "variable": "0_pg[13]" - }, - { - "coefficient": 2077.0, - "variable": "0_pg[15]" - }, - { - "coefficient": 2120.0, - "variable": "0_pg[2]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[27]" - }, - { - "coefficient": 1598.0, - "variable": "0_pg[21]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[26]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[10]" - }, - { - "coefficient": 2059.0, - "variable": "0_pg[18]" - } - ], - "constant": 0.0 - } - }, - "constraints": [ - { - "name": "c1", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.4213950047523992, - "0_vm[5]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.4213950047523992, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 12.485777918589607, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(5, 5, 6)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c2", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 12.485777918589607, - "0_vm[5]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 12.485777918589607, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.4213950047523992, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(5, 5, 6)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c3", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.4213950047523992, - "0_vm[6]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[6]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.4213950047523992, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[6]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 12.485777918589607, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(5, 6, 5)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c4", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 12.485777918589607, - "0_vm[6]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[6]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 12.485777918589607, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[6]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.4213950047523992, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(5, 6, 5)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c5", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.46024690223052, - "0_vm[13]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[13]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.46024690223052, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[13]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 6.795713842466891, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(16, 13, 14)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c6", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 6.787563842466891, - "0_vm[13]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[13]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 6.795713842466891, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[13]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.46024690223052, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(16, 13, 14)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c7", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.46024690223052, - "0_vm[14]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.46024690223052, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 6.795713842466891, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(16, 14, 13)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c8", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 6.787563842466891, - "0_vm[14]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 6.795713842466891, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.46024690223052, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(16, 14, 13)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c9", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.7456627284627748, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.7456627284627748, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 10.149298248521102, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(20, 16, 17)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c10", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 10.149298248521102, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 10.149298248521102, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.7456627284627748, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(20, 16, 17)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c11", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.7456627284627748, - "0_vm[17]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[17]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.7456627284627748, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[17]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 10.149298248521102, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(20, 17, 16)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c12", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 10.149298248521102, - "0_vm[17]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[17]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 10.149298248521102, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[17]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.7456627284627748, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(20, 17, 16)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c13", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.3473152225768015, - "0_vm[9]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.3473152225768015, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 6.481250938450924, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(12, 9, 12)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c14", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 6.472700938450925, - "0_vm[9]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 6.481250938450924, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.3473152225768015, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(12, 9, 12)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c15", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.3473152225768015, - "0_vm[12]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[12]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.3473152225768015, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[12]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 6.481250938450924, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(12, 12, 9)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c16", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 6.472700938450925, - "0_vm[12]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[12]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 6.481250938450924, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[12]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.3473152225768015, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(12, 12, 9)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c17", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.13631367642289954, - "0_vm[21]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[21]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[22]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.13631367642289954, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[21]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[22]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 4.2328983731321435, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(24, 21, 22)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c18", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 4.2328983731321435, - "0_vm[21]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[21]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[22]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 4.2328983731321435, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[21]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[22]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.13631367642289954, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(24, 21, 22)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c19", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.13631367642289954, - "0_vm[22]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[22]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[22]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.13631367642289954, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[22]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[22]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 4.2328983731321435, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(24, 22, 21)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c20", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 4.2328983731321435, - "0_vm[22]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[22]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[22]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 4.2328983731321435, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[22]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[22]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.13631367642289954, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(24, 22, 21)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c21", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.0916977112407253, - "0_vm[25]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[25]", - "0_vm[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[25]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.0916977112407253, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[25]", - "0_vm[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[25]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 2.091029561081878, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(28, 25, 26)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c22", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.088179561081878, - "0_vm[25]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[25]", - "0_vm[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[25]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 2.091029561081878, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[25]", - "0_vm[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[25]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.0916977112407253, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(28, 25, 26)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c23", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.0916977112407253, - "0_vm[26]", - "0_vm[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[26]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[25]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.0916977112407253, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[26]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[25]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 2.091029561081878, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(28, 26, 25)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c24", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.088179561081878, - "0_vm[26]", - "0_vm[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[26]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[25]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 2.091029561081878, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[26]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[25]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[26]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.0916977112407253, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(28, 26, 25)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c25", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 15.980730481506358, - "0_vm[7]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -15.980730481506358, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 45.39453875906154, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(8, 7, 8)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c26", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 45.39333875906154, - "0_vm[7]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 45.39453875906154, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -15.980730481506358, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(8, 7, 8)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c27", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 15.980730481506358, - "0_vm[8]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[8]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -15.980730481506358, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[8]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 45.39453875906154, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(8, 8, 7)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c28", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 45.39333875906154, - "0_vm[8]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[8]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 45.39453875906154, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[8]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -15.980730481506358, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(8, 8, 7)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c29", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.4325735387749903, - "0_vm[14]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.4325735387749903, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 19.8968547052082, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(17, 14, 15)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c30", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 19.8968547052082, - "0_vm[14]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 19.8968547052082, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.4325735387749903, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(17, 14, 15)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c31", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.4325735387749903, - "0_vm[15]", - "0_vm[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[15]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.4325735387749903, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[15]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 19.8968547052082, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(17, 15, 14)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c32", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 19.8968547052082, - "0_vm[15]", - "0_vm[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[15]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 19.8968547052082, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[15]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[15]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.4325735387749903, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(17, 15, 14)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c33", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.8777625235737184, - "0_vm[19]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.8777625235737184, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 9.121944633618186, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(30, 19, 28)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c34", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 9.097144633618186, - "0_vm[19]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 9.121944633618186, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.8777625235737184, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(30, 19, 28)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c35", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.8777625235737184, - "0_vm[28]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[28]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.8777625235737184, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[28]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 9.121944633618186, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(30, 28, 19)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c36", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 9.097144633618186, - "0_vm[28]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[28]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 9.121944633618186, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[28]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.8777625235737184, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(30, 28, 19)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c37", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.28958087993976717, - "0_vm[2]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[2]", - "0_vm[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[1]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.28958087993976717, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[2]", - "0_vm[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[1]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 9.363115118052471, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(1, 2, 1)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c38", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 9.363115118052471, - "0_vm[2]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[2]", - "0_vm[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[1]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 9.363115118052471, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[2]", - "0_vm[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[1]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.28958087993976717, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(1, 2, 1)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c39", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.28958087993976717, - "0_vm[1]", - "0_vm[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[1]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[1]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.28958087993976717, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[1]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[1]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 9.363115118052471, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(1, 1, 2)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c40", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 9.363115118052471, - "0_vm[1]", - "0_vm[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[1]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[1]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 9.363115118052471, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[1]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[1]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.28958087993976717, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(1, 1, 2)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c41", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.128676282013955, - "0_vm[20]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[20]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.128676282013955, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[20]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 3.33399327650884, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(23, 20, 21)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c42", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 3.3189932765088397, - "0_vm[20]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[20]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 3.33399327650884, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[20]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.128676282013955, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(23, 20, 21)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c43", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.128676282013955, - "0_vm[21]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[21]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.128676282013955, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[21]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 3.33399327650884, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(23, 21, 20)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c44", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 3.3189932765088397, - "0_vm[21]", - "0_vm[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[21]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 3.33399327650884, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[21]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[21]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.128676282013955, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(23, 21, 20)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c45", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.8287243608560181, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.8287243608560181, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 2.8140484527509644, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(22, 16, 19)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c46", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.7777484527509646, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 2.8140484527509644, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.8287243608560181, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(22, 16, 19)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c47", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.8287243608560181, - "0_vm[19]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.8287243608560181, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 2.8140484527509644, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(22, 19, 16)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c48", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.7777484527509646, - "0_vm[19]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 2.8140484527509644, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.8287243608560181, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(22, 19, 16)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c49", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.2416585439004273, - "0_vm[14]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.2416585439004273, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 3.667991302391842, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(19, 14, 16)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c50", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 3.654341302391842, - "0_vm[14]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 3.667991302391842, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.2416585439004273, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(19, 14, 16)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c51", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.2416585439004273, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.2416585439004273, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 3.667991302391842, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(19, 16, 14)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c52", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 3.654341302391842, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 3.667991302391842, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.2416585439004273, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(19, 16, 14)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c53", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 3.027806843733998, - "0_vm[5]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -3.027806843733998, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 20.88296190751831, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(6, 5, 11)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c54", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 20.83991190751831, - "0_vm[5]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 20.88296190751831, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -3.027806843733998, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(6, 5, 11)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c55", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 3.027806843733998, - "0_vm[11]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[11]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -3.027806843733998, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[11]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 20.88296190751831, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(6, 11, 5)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c56", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 20.83991190751831, - "0_vm[11]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[11]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 20.88296190751831, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[11]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -3.027806843733998, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(6, 11, 5)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c57", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 17.788682717374634, - "0_vm[9]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -17.788682717374634, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 52.44594387363901, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(11, 9, 10)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c58", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 52.44499387363901, - "0_vm[9]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 52.44594387363901, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -17.788682717374634, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(11, 9, 10)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c59", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 17.788682717374634, - "0_vm[10]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[10]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -17.788682717374634, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[10]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 52.44594387363901, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(11, 10, 9)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c60", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 52.44499387363901, - "0_vm[10]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[10]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 52.44594387363901, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[10]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -17.788682717374634, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(11, 10, 9)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c61", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.9656776626482336, - "0_vm[19]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.9656776626482336, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 5.498037005409949, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(31, 19, 28)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c62", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 5.487437005409949, - "0_vm[19]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 5.498037005409949, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[19]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.9656776626482336, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(31, 19, 28)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c63", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.9656776626482336, - "0_vm[28]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[28]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.9656776626482336, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[28]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 5.498037005409949, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(31, 28, 19)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c64", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 5.487437005409949, - "0_vm[28]", - "0_vm[28]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[28]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 5.498037005409949, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[28]", - "0_vm[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[28]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[19]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.9656776626482336, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(31, 28, 19)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c65", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.3418494649701906, - "0_vm[7]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.3418494649701906, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 6.467289330533839, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(9, 7, 10)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c66", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 6.458739330533839, - "0_vm[7]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 6.467289330533839, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.3418494649701906, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(9, 7, 10)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c67", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.3418494649701906, - "0_vm[10]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[10]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.3418494649701906, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[10]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 6.467289330533839, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(9, 10, 7)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c68", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 6.458739330533839, - "0_vm[10]", - "0_vm[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[10]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 6.467289330533839, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[10]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[10]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.3418494649701906, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(9, 10, 7)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c69", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.2592269273704175, - "0_vm[11]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[11]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[11]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.2592269273704175, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[11]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[11]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 8.698708713000553, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(14, 11, 18)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c70", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 8.595708713000553, - "0_vm[11]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[11]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[11]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 8.698708713000553, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[11]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[11]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.2592269273704175, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(14, 11, 18)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c71", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.2592269273704175, - "0_vm[18]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[18]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[11]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.2592269273704175, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[18]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[11]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 8.698708713000553, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(14, 18, 11)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c72", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 8.595708713000553, - "0_vm[18]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[18]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[11]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 8.698708713000553, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[18]", - "0_vm[11]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[11]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.2592269273704175, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(14, 18, 11)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c73", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.5442206253457624, - "0_vm[3]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.5442206253457624, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 17.010777436904807, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(3, 3, 4)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c74", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 16.954277436904807, - "0_vm[3]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 17.010777436904807, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.5442206253457624, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(3, 3, 4)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c75", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.5442206253457624, - "0_vm[4]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[4]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.5442206253457624, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[4]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 17.010777436904807, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(3, 4, 3)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c76", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 16.954277436904807, - "0_vm[4]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[4]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 17.010777436904807, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[4]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.5442206253457624, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(3, 4, 3)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c77", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.5382017465334347, - "0_vm[17]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[17]", - "0_vm[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[17]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.5382017465334347, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[17]", - "0_vm[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[17]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 1.6861921183958626, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(29, 17, 27)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c78", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.6861921183958626, - "0_vm[17]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[17]", - "0_vm[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[17]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 1.6861921183958626, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[17]", - "0_vm[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[17]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.5382017465334347, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(29, 17, 27)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c79", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.5382017465334347, - "0_vm[27]", - "0_vm[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[27]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[17]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.5382017465334347, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[27]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[17]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 1.6861921183958626, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(29, 27, 17)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c80", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.6861921183958626, - "0_vm[27]", - "0_vm[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[27]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[17]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 1.6861921183958626, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[27]", - "0_vm[17]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[17]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[27]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.5382017465334347, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(29, 27, 17)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c81", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 10.614654857863137, - "0_vm[6]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[6]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[6]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -10.614654857863137, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[6]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[6]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 31.512256609281188, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(7, 6, 7)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c82", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 31.510656609281188, - "0_vm[6]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[6]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[6]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 31.512256609281188, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[6]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[6]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -10.614654857863137, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(7, 6, 7)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c83", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 10.614654857863137, - "0_vm[7]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[6]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -10.614654857863137, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[6]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 31.512256609281188, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(7, 7, 6)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c84", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 31.510656609281188, - "0_vm[7]", - "0_vm[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[6]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 31.512256609281188, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[7]", - "0_vm[6]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[6]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[7]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -10.614654857863137, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(7, 7, 6)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c85", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 4.66785040912336, - "0_vm[22]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[22]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[23]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -4.66785040912336, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[22]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[23]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 8.939086077602251, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(25, 22, 23)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c86", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 8.938436077602251, - "0_vm[22]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[22]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[23]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 8.939086077602251, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[22]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[23]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -4.66785040912336, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(25, 22, 23)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c87", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 4.66785040912336, - "0_vm[23]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[23]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[23]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -4.66785040912336, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[23]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[23]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 8.939086077602251, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(25, 23, 22)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c88", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 8.938436077602251, - "0_vm[23]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[23]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[23]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 8.939086077602251, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[23]", - "0_vm[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[23]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[22]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -4.66785040912336, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(25, 23, 22)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c89", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.434853977156145, - "0_vm[4]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[4]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.434853977156145, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[4]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 16.36003009370084, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(4, 4, 5)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c90", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 16.30153009370084, - "0_vm[4]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[4]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 16.36003009370084, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[4]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.434853977156145, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(4, 4, 5)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c91", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.434853977156145, - "0_vm[5]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.434853977156145, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 16.36003009370084, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(4, 5, 4)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c92", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 16.30153009370084, - "0_vm[5]", - "0_vm[5]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 16.36003009370084, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[5]", - "0_vm[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[5]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[4]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.434853977156145, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(4, 5, 4)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c93", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.64335500582701, - "0_vm[9]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.64335500582701, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 1.8998888915041532, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(13, 9, 16)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c94", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.8735888915041532, - "0_vm[9]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 1.8998888915041532, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.64335500582701, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(13, 9, 16)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c95", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.64335500582701, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.64335500582701, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 1.8998888915041532, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(13, 16, 9)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c96", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.8735888915041532, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 1.8998888915041532, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.64335500582701, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(13, 16, 9)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c97", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.5424832182137913, - "0_vm[12]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[12]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.5424832182137913, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[12]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 7.029547007720768, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(15, 12, 13)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c98", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 7.021647007720768, - "0_vm[12]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[12]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 7.029547007720768, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[12]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.5424832182137913, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(15, 12, 13)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c99", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.5424832182137913, - "0_vm[13]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[13]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.5424832182137913, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[13]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 7.029547007720768, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(15, 13, 12)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c100", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 7.021647007720768, - "0_vm[13]", - "0_vm[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[13]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 7.029547007720768, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[13]", - "0_vm[12]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[12]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[13]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.5424832182137913, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(15, 13, 12)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c101", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.070955528571676, - "0_vm[2]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[2]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.070955528571676, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[2]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 7.165952433825185, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(2, 2, 3)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c102", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 7.031952433825185, - "0_vm[2]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[2]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 7.165952433825185, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[2]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.070955528571676, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(2, 2, 3)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c103", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.070955528571676, - "0_vm[3]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.070955528571676, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 7.165952433825185, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(2, 3, 2)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c104", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 7.031952433825185, - "0_vm[3]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 7.165952433825185, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[2]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.070955528571676, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(2, 3, 2)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c105", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.4978494338705233, - "0_vm[24]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[24]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.4978494338705233, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[24]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 2.868957761798156, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(27, 24, 25)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c106", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.866907761798156, - "0_vm[24]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[24]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 2.868957761798156, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[24]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.4978494338705233, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(27, 24, 25)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c107", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.4978494338705233, - "0_vm[25]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[25]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -1.4978494338705233, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[25]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 2.868957761798156, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(27, 25, 24)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c108", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.866907761798156, - "0_vm[25]", - "0_vm[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[25]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 2.868957761798156, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[25]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[25]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -1.4978494338705233, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(27, 25, 24)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c109", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.26161249681590054, - "0_vm[18]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[18]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.26161249681590054, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[18]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 11.73125512037617, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(21, 18, 16)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c110", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 11.73125512037617, - "0_vm[18]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[18]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 11.73125512037617, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[18]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.26161249681590054, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(21, 18, 16)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c111", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.26161249681590054, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.26161249681590054, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 11.73125512037617, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(21, 16, 18)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c112", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 11.73125512037617, - "0_vm[16]", - "0_vm[16]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 11.73125512037617, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[16]", - "0_vm[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[16]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[18]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.26161249681590054, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(21, 16, 18)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c113", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.9263284811715553, - "0_vm[23]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[23]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.9263284811715553, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[23]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 5.604798539074481, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(26, 23, 24)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c114", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 5.603748539074481, - "0_vm[23]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[23]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 5.604798539074481, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[23]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.9263284811715553, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(26, 23, 24)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c115", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.9263284811715553, - "0_vm[24]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[24]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.9263284811715553, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[24]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 5.604798539074481, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(26, 24, 23)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c116", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 5.603748539074481, - "0_vm[24]", - "0_vm[24]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[24]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 5.604798539074481, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[24]", - "0_vm[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[24]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[23]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.9263284811715553, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(26, 24, 23)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c117", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.450918029773461, - "0_vm[8]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[8]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.450918029773461, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[8]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 6.776372942488066, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(10, 8, 9)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c118", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 6.768172942488065, - "0_vm[8]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[8]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 6.776372942488066, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[8]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.450918029773461, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(10, 8, 9)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c119", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.450918029773461, - "0_vm[9]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -2.450918029773461, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 6.776372942488066, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(10, 9, 8)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c120", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 6.768172942488065, - "0_vm[9]", - "0_vm[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 6.776372942488066, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[9]", - "0_vm[8]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[8]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[9]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -2.450918029773461, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(10, 9, 8)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c121", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.9733135131308841, - "0_vm[14]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.9733135131308841, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 2.875699016068521, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(18, 14, 20)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c122", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.8582990160685213, - "0_vm[14]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 2.875699016068521, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[14]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.9733135131308841, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(18, 14, 20)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c123", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.9733135131308841, - "0_vm[20]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[20]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - -0.9733135131308841, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[20]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 14 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 12 - }, - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - 2.875699016068521, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(18, 20, 14)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c124", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 2.8582990160685213, - "0_vm[20]", - "0_vm[20]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[20]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 5 - }, - { - "type": "node", - "index": 6 - } - ] - }, - { - "type": "cos", - "args": [ - { - "type": "node", - "index": 7 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 4 - }, - { - "type": "node", - "index": 8 - } - ] - }, - { - "type": "*", - "args": [ - 2.875699016068521, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[20]", - "0_vm[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[20]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[14]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 14 - }, - { - "type": "node", - "index": 15 - } - ] - }, - { - "type": "sin", - "args": [ - { - "type": "node", - "index": 16 - } - ] - }, - { - "type": "*", - "args": [ - { - "type": "node", - "index": 13 - }, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "*", - "args": [ - -0.9733135131308841, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(18, 20, 14)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c1_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c2_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(5, 5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(6, 5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(4, 5, 4)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c3_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(5, 5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(6, 5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(4, 5, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c4_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(20, 16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(22, 16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(19, 16, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(13, 16, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(21, 16, 18)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[16]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.21439096103324617 - } - }, - { - "name": "c5_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(20, 16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(22, 16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(19, 16, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(13, 16, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(21, 16, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.02572691532398954 - } - }, - { - "name": "c6_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(23, 20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(18, 20, 14)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[20]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0015565421870758504 - } - }, - { - "name": "c7_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(23, 20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(18, 20, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.00018678506244910206 - } - }, - { - "name": "c8_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(15, 12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(12, 12, 9)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[12]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.05738794110411041 - } - }, - { - "name": "c9_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(15, 12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(12, 12, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.006886552932493249 - } - }, - { - "name": "c10_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(27, 24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(26, 24, 23)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[24]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.01804043447630477 - } - }, - { - "name": "c11_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(27, 24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(26, 24, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0021648521371565727 - } - }, - { - "name": "c12_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[28]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[30]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[29]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(30, 28, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(31, 28, 19)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[28]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c13_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[28]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[30]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[29]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(30, 28, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(31, 28, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c14_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[25]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(10, 8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(8, 8, 7)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c15_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[25]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(10, 8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(8, 8, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c16_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(29, 17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(20, 17, 16)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[17]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.267753330934522 - } - }, - { - "name": "c17_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(29, 17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(20, 17, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.03213039971214264 - } - }, - { - "name": "c18_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[5]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[8]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[1]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[6]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[9]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[3]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[7]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[4]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[2]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[10]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 2)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.6075543555612704 - } - }, - { - "name": "c19_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[5]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[8]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[1]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[6]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[9]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[3]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[7]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[4]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[2]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[10]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.19290652266735245 - } - }, - { - "name": "c20_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[21]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(26, 23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(25, 23, 22)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[23]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0004825663866386638 - } - }, - { - "name": "c21_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[21]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(26, 23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(25, 23, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -5.790796639663966e-5 - } - }, - { - "name": "c22_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[34]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(25, 22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(24, 22, 21)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[22]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.12074817048704867 - } - }, - { - "name": "c23_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[34]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(25, 22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(24, 22, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.01448978045844584 - } - }, - { - "name": "c24_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[20]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[32]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[19]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[31]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[33]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(30, 19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(31, 19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(22, 19, 16)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.4735118986170044 - } - }, - { - "name": "c25_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[20]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[32]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[19]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[31]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[33]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(30, 19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(31, 19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(22, 19, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.1768214278340405 - } - }, - { - "name": "c26_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(7, 6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(5, 6, 5)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c27_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(7, 6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(5, 6, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c28_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(14, 11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(6, 11, 5)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c29_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(14, 11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(6, 11, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c30_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[16]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[17]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[15]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[18]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(12, 9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(11, 9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(13, 9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(10, 9, 8)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.21593913974111698 - } - }, - { - "name": "c31_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[16]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[17]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[15]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[18]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(12, 9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(11, 9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(13, 9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(10, 9, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.025912696768934037 - } - }, - { - "name": "c32_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(17, 14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(19, 14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(18, 14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(16, 14, 13)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[14]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c33_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(17, 14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(19, 14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(18, 14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(16, 14, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c34_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[12]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[11]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[14]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[13]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c35_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[12]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[11]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[14]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[13]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c36_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[24]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(8, 7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(9, 7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(7, 7, 6)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c37_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[24]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(8, 7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(9, 7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(7, 7, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c38_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(28, 25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(27, 25, 24)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[25]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0004825663866386638 - } - }, - { - "name": "c39_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(28, 25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(27, 25, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -5.790796639663966e-5 - } - }, - { - "name": "c40_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(4, 4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 4, 3)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.02040724338005229 - } - }, - { - "name": "c41_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(4, 4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 4, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.002448869205606275 - } - }, - { - "name": "c42_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(16, 13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(15, 13, 12)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[13]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0004825663866386638 - } - }, - { - "name": "c43_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(16, 13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(15, 13, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -5.790796639663966e-5 - } - }, - { - "name": "c44_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(17, 15, 14)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[15]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.10015864047547611 - } - }, - { - "name": "c45_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(17, 15, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.012019036857057132 - } - }, - { - "name": "c46_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(1, 2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c47_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(1, 2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c48_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[27]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(29, 27, 17)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[27]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c49_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[27]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(29, 27, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c50_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(24, 21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(23, 21, 20)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[21]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c51_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(24, 21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(23, 21, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c52_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[23]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[22]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(28, 26, 25)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[26]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.1700922829782978 - } - }, - { - "name": "c53_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[23]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[22]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(28, 26, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.020411073957395734 - } - }, - { - "name": "c54_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[26]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(11, 10, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(9, 10, 7)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.5563327884359863 - } - }, - { - "name": "c55_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[26]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(11, 10, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(9, 10, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.06675993461231836 - } - }, - { - "name": "c56_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(21, 18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(14, 18, 11)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[18]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c57_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(21, 18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(14, 18, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[1]" - }, - { - "coefficient": -0.0036, - "variable": "outflow[2]" - }, - { - "coefficient": 1.0, - "variable": "spill[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[2]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[2]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[2]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[2]" - }, - { - "coefficient": 1.0, - "variable": "spill[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[3]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[3]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[3]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[3]" - }, - { - "coefficient": 1.0, - "variable": "spill[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[4]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[4]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[4]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[4]" - }, - { - "coefficient": 1.0, - "variable": "spill[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[5]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[5]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[5]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[5]" - }, - { - "coefficient": 1.0, - "variable": "spill[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[6]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[6]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[6]_out" - }, - { - "coefficient": -0.0036, - "variable": "outflow[5]" - }, - { - "coefficient": 0.0036, - "variable": "outflow[6]" - }, - { - "coefficient": -1.0, - "variable": "spill[5]" - }, - { - "coefficient": 1.0, - "variable": "spill[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[7]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[7]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[7]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[7]" - }, - { - "coefficient": 1.0, - "variable": "spill[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[8]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[8]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[8]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[8]" - }, - { - "coefficient": 1.0, - "variable": "spill[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[9]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[9]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[9]_out" - }, - { - "coefficient": -0.0036, - "variable": "outflow[8]" - }, - { - "coefficient": 0.0036, - "variable": "outflow[9]" - }, - { - "coefficient": -1.0, - "variable": "spill[8]" - }, - { - "coefficient": 1.0, - "variable": "spill[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[10]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[10]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[10]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[10]" - }, - { - "coefficient": 1.0, - "variable": "spill[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[11]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[11]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[11]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[11]" - }, - { - "coefficient": 1.0, - "variable": "spill[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[24]" - }, - { - "coefficient": -6.9953, - "variable": "outflow[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[25]" - }, - { - "coefficient": -5.117, - "variable": "outflow[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[26]" - }, - { - "coefficient": -9.677, - "variable": "outflow[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[27]" - }, - { - "coefficient": -5.06, - "variable": "outflow[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[28]" - }, - { - "coefficient": -8.11, - "variable": "outflow[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[29]" - }, - { - "coefficient": -6.35, - "variable": "outflow[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[30]" - }, - { - "coefficient": -3.2, - "variable": "outflow[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[31]" - }, - { - "coefficient": -4.81, - "variable": "outflow[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[32]" - }, - { - "coefficient": -4.47, - "variable": "outflow[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[33]" - }, - { - "coefficient": -1.2, - "variable": "outflow[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[34]" - }, - { - "coefficient": -2.5, - "variable": "outflow[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "min_volume_violation_bound[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[1]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[2]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[3]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[4]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[5]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[6]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[7]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[8]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[9]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[10]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[11]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[2]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[3]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[4]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[5]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[6]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[7]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[8]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[9]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[10]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[11]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c1_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[5]" - }, - { - "coefficient": -1.0, - "variable": "0_va[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c2_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[14]" - }, - { - "coefficient": 1.0, - "variable": "0_va[13]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c3_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[16]" - }, - { - "coefficient": -1.0, - "variable": "0_va[17]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c4_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[12]" - }, - { - "coefficient": 1.0, - "variable": "0_va[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c5_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[22]" - }, - { - "coefficient": 1.0, - "variable": "0_va[21]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c6_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[25]" - }, - { - "coefficient": -1.0, - "variable": "0_va[26]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c7_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[8]" - }, - { - "coefficient": 1.0, - "variable": "0_va[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c8_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[14]" - }, - { - "coefficient": -1.0, - "variable": "0_va[15]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c9_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[28]" - }, - { - "coefficient": 1.0, - "variable": "0_va[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c10_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[1]" - }, - { - "coefficient": 1.0, - "variable": "0_va[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c11_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[20]" - }, - { - "coefficient": -1.0, - "variable": "0_va[21]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c12_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[16]" - }, - { - "coefficient": -1.0, - "variable": "0_va[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c13_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[16]" - }, - { - "coefficient": 1.0, - "variable": "0_va[14]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c14_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[5]" - }, - { - "coefficient": -1.0, - "variable": "0_va[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c15_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[9]" - }, - { - "coefficient": -1.0, - "variable": "0_va[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c16_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[7]" - }, - { - "coefficient": -1.0, - "variable": "0_va[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c17_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[11]" - }, - { - "coefficient": -1.0, - "variable": "0_va[18]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c18_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[3]" - }, - { - "coefficient": -1.0, - "variable": "0_va[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c19_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[17]" - }, - { - "coefficient": -1.0, - "variable": "0_va[27]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c20_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[6]" - }, - { - "coefficient": -1.0, - "variable": "0_va[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c21_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[23]" - }, - { - "coefficient": 1.0, - "variable": "0_va[22]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c22_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[5]" - }, - { - "coefficient": 1.0, - "variable": "0_va[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c23_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[16]" - }, - { - "coefficient": 1.0, - "variable": "0_va[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c24_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[12]" - }, - { - "coefficient": -1.0, - "variable": "0_va[13]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c25_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]" - }, - { - "coefficient": 1.0, - "variable": "0_va[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c26_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[24]" - }, - { - "coefficient": -1.0, - "variable": "0_va[25]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c27_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[16]" - }, - { - "coefficient": 1.0, - "variable": "0_va[18]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c28_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[24]" - }, - { - "coefficient": 1.0, - "variable": "0_va[23]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c29_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[8]" - }, - { - "coefficient": -1.0, - "variable": "0_va[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c30_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[20]" - }, - { - "coefficient": 1.0, - "variable": "0_va[14]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c1_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(5, 5, 6)]", - "variable_2": "0_p[(5, 5, 6)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(5, 5, 6)]", - "variable_2": "0_q[(5, 5, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.48999999999999994 - } - }, - { - "name": "c2_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(5, 6, 5)]", - "variable_2": "0_p[(5, 6, 5)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(5, 6, 5)]", - "variable_2": "0_q[(5, 6, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.48999999999999994 - } - }, - { - "name": "c3_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(16, 13, 14)]", - "variable_2": "0_p[(16, 13, 14)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(16, 13, 14)]", - "variable_2": "0_q[(16, 13, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c4_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(16, 14, 13)]", - "variable_2": "0_p[(16, 14, 13)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(16, 14, 13)]", - "variable_2": "0_q[(16, 14, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c5_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(20, 16, 17)]", - "variable_2": "0_p[(20, 16, 17)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(20, 16, 17)]", - "variable_2": "0_q[(20, 16, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c6_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(20, 17, 16)]", - "variable_2": "0_p[(20, 17, 16)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(20, 17, 16)]", - "variable_2": "0_q[(20, 17, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c7_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(12, 9, 12)]", - "variable_2": "0_p[(12, 9, 12)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(12, 9, 12)]", - "variable_2": "0_q[(12, 9, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c8_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(12, 12, 9)]", - "variable_2": "0_p[(12, 12, 9)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(12, 12, 9)]", - "variable_2": "0_q[(12, 12, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c9_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(24, 21, 22)]", - "variable_2": "0_p[(24, 21, 22)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(24, 21, 22)]", - "variable_2": "0_q[(24, 21, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c10_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(24, 22, 21)]", - "variable_2": "0_p[(24, 22, 21)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(24, 22, 21)]", - "variable_2": "0_q[(24, 22, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c11_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(28, 25, 26)]", - "variable_2": "0_p[(28, 25, 26)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(28, 25, 26)]", - "variable_2": "0_q[(28, 25, 26)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.016900000000000002 - } - }, - { - "name": "c12_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(28, 26, 25)]", - "variable_2": "0_p[(28, 26, 25)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(28, 26, 25)]", - "variable_2": "0_q[(28, 26, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.016900000000000002 - } - }, - { - "name": "c13_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(8, 7, 8)]", - "variable_2": "0_p[(8, 7, 8)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(8, 7, 8)]", - "variable_2": "0_q[(8, 7, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c14_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(8, 8, 7)]", - "variable_2": "0_p[(8, 8, 7)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(8, 8, 7)]", - "variable_2": "0_q[(8, 8, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c15_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(17, 14, 15)]", - "variable_2": "0_p[(17, 14, 15)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(17, 14, 15)]", - "variable_2": "0_q[(17, 14, 15)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "name": "c16_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(17, 15, 14)]", - "variable_2": "0_p[(17, 15, 14)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(17, 15, 14)]", - "variable_2": "0_q[(17, 15, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "name": "c17_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(30, 19, 28)]", - "variable_2": "0_p[(30, 19, 28)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(30, 19, 28)]", - "variable_2": "0_q[(30, 19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c18_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(30, 28, 19)]", - "variable_2": "0_p[(30, 28, 19)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(30, 28, 19)]", - "variable_2": "0_q[(30, 28, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c19_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 2, 1)]", - "variable_2": "0_p[(1, 2, 1)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 2, 1)]", - "variable_2": "0_q[(1, 2, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.48999999999999994 - } - }, - { - "name": "c20_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 2)]", - "variable_2": "0_p[(1, 1, 2)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 2)]", - "variable_2": "0_q[(1, 1, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.48999999999999994 - } - }, - { - "name": "c21_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(23, 20, 21)]", - "variable_2": "0_p[(23, 20, 21)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(23, 20, 21)]", - "variable_2": "0_q[(23, 20, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.22089999999999999 - } - }, - { - "name": "c22_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(23, 21, 20)]", - "variable_2": "0_p[(23, 21, 20)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(23, 21, 20)]", - "variable_2": "0_q[(23, 21, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.22089999999999999 - } - }, - { - "name": "c23_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(22, 16, 19)]", - "variable_2": "0_p[(22, 16, 19)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(22, 16, 19)]", - "variable_2": "0_q[(22, 16, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.1236000000000002 - } - }, - { - "name": "c24_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(22, 19, 16)]", - "variable_2": "0_p[(22, 19, 16)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(22, 19, 16)]", - "variable_2": "0_q[(22, 19, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.1236000000000002 - } - }, - { - "name": "c25_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(19, 14, 16)]", - "variable_2": "0_p[(19, 14, 16)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(19, 14, 16)]", - "variable_2": "0_q[(19, 14, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c26_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(19, 16, 14)]", - "variable_2": "0_p[(19, 16, 14)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(19, 16, 14)]", - "variable_2": "0_q[(19, 16, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c27_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(6, 5, 11)]", - "variable_2": "0_p[(6, 5, 11)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(6, 5, 11)]", - "variable_2": "0_q[(6, 5, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c28_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(6, 11, 5)]", - "variable_2": "0_p[(6, 11, 5)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(6, 11, 5)]", - "variable_2": "0_q[(6, 11, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c29_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(11, 9, 10)]", - "variable_2": "0_p[(11, 9, 10)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(11, 9, 10)]", - "variable_2": "0_q[(11, 9, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c30_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(11, 10, 9)]", - "variable_2": "0_p[(11, 10, 9)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(11, 10, 9)]", - "variable_2": "0_q[(11, 10, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c31_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(31, 19, 28)]", - "variable_2": "0_p[(31, 19, 28)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(31, 19, 28)]", - "variable_2": "0_q[(31, 19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c32_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(31, 28, 19)]", - "variable_2": "0_p[(31, 28, 19)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(31, 28, 19)]", - "variable_2": "0_q[(31, 28, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c33_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(9, 7, 10)]", - "variable_2": "0_p[(9, 7, 10)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(9, 7, 10)]", - "variable_2": "0_q[(9, 7, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c34_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(9, 10, 7)]", - "variable_2": "0_p[(9, 10, 7)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(9, 10, 7)]", - "variable_2": "0_q[(9, 10, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c35_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(14, 11, 18)]", - "variable_2": "0_p[(14, 11, 18)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(14, 11, 18)]", - "variable_2": "0_q[(14, 11, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c36_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(14, 18, 11)]", - "variable_2": "0_p[(14, 18, 11)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(14, 18, 11)]", - "variable_2": "0_q[(14, 18, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c37_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 3, 4)]", - "variable_2": "0_p[(3, 3, 4)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 3, 4)]", - "variable_2": "0_q[(3, 3, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c38_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 4, 3)]", - "variable_2": "0_p[(3, 4, 3)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 4, 3)]", - "variable_2": "0_q[(3, 4, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c39_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(29, 17, 27)]", - "variable_2": "0_p[(29, 17, 27)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(29, 17, 27)]", - "variable_2": "0_q[(29, 17, 27)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 4.0 - } - }, - { - "name": "c40_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(29, 27, 17)]", - "variable_2": "0_p[(29, 27, 17)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(29, 27, 17)]", - "variable_2": "0_q[(29, 27, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 4.0 - } - }, - { - "name": "c41_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(7, 6, 7)]", - "variable_2": "0_p[(7, 6, 7)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(7, 6, 7)]", - "variable_2": "0_q[(7, 6, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c42_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(7, 7, 6)]", - "variable_2": "0_p[(7, 7, 6)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(7, 7, 6)]", - "variable_2": "0_q[(7, 7, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c43_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(25, 22, 23)]", - "variable_2": "0_p[(25, 22, 23)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(25, 22, 23)]", - "variable_2": "0_q[(25, 22, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.10890000000000001 - } - }, - { - "name": "c44_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(25, 23, 22)]", - "variable_2": "0_p[(25, 23, 22)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(25, 23, 22)]", - "variable_2": "0_q[(25, 23, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.10890000000000001 - } - }, - { - "name": "c45_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(4, 4, 5)]", - "variable_2": "0_p[(4, 4, 5)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(4, 4, 5)]", - "variable_2": "0_q[(4, 4, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c46_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(4, 5, 4)]", - "variable_2": "0_p[(4, 5, 4)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(4, 5, 4)]", - "variable_2": "0_q[(4, 5, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c47_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(13, 9, 16)]", - "variable_2": "0_p[(13, 9, 16)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(13, 9, 16)]", - "variable_2": "0_q[(13, 9, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c48_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(13, 16, 9)]", - "variable_2": "0_p[(13, 16, 9)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(13, 16, 9)]", - "variable_2": "0_q[(13, 16, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c49_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(15, 12, 13)]", - "variable_2": "0_p[(15, 12, 13)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(15, 12, 13)]", - "variable_2": "0_q[(15, 12, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c50_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(15, 13, 12)]", - "variable_2": "0_p[(15, 13, 12)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(15, 13, 12)]", - "variable_2": "0_q[(15, 13, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c51_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]", - "variable_2": "0_p[(2, 2, 3)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]", - "variable_2": "0_q[(2, 2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c52_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]", - "variable_2": "0_p[(2, 3, 2)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]", - "variable_2": "0_q[(2, 3, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.6900000000000002 - } - }, - { - "name": "c53_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(27, 24, 25)]", - "variable_2": "0_p[(27, 24, 25)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(27, 24, 25)]", - "variable_2": "0_q[(27, 24, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.016900000000000002 - } - }, - { - "name": "c54_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(27, 25, 24)]", - "variable_2": "0_p[(27, 25, 24)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(27, 25, 24)]", - "variable_2": "0_q[(27, 25, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.016900000000000002 - } - }, - { - "name": "c55_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(21, 18, 16)]", - "variable_2": "0_p[(21, 18, 16)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(21, 18, 16)]", - "variable_2": "0_q[(21, 18, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c56_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(21, 16, 18)]", - "variable_2": "0_p[(21, 16, 18)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(21, 16, 18)]", - "variable_2": "0_q[(21, 16, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c57_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(26, 23, 24)]", - "variable_2": "0_p[(26, 23, 24)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(26, 23, 24)]", - "variable_2": "0_q[(26, 23, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.016900000000000002 - } - }, - { - "name": "c58_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(26, 24, 23)]", - "variable_2": "0_p[(26, 24, 23)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(26, 24, 23)]", - "variable_2": "0_q[(26, 24, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.016900000000000002 - } - }, - { - "name": "c59_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(10, 8, 9)]", - "variable_2": "0_p[(10, 8, 9)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(10, 8, 9)]", - "variable_2": "0_q[(10, 8, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c60_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(10, 9, 8)]", - "variable_2": "0_p[(10, 9, 8)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(10, 9, 8)]", - "variable_2": "0_q[(10, 9, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.5476 - } - }, - { - "name": "c61_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(18, 14, 20)]", - "variable_2": "0_p[(18, 14, 20)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(18, 14, 20)]", - "variable_2": "0_q[(18, 14, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.22089999999999999 - } - }, - { - "name": "c62_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(18, 20, 14)]", - "variable_2": "0_p[(18, 20, 14)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(18, 20, 14)]", - "variable_2": "0_q[(18, 20, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.22089999999999999 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[2]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[3]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[4]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[5]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[6]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[7]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[8]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[9]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[10]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[11]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[1]" - }, - "set": { - "type": "EqualTo", - "value": 1.3538975481813056 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[2]" - }, - "set": { - "type": "EqualTo", - "value": 19.68323492663498 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[3]" - }, - "set": { - "type": "EqualTo", - "value": 0.3754523636596491 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[4]" - }, - "set": { - "type": "EqualTo", - "value": 7.658748883214739 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[5]" - }, - "set": { - "type": "EqualTo", - "value": 8.021893816349996 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[6]" - }, - "set": { - "type": "EqualTo", - "value": 12.790574440438007 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[7]" - }, - "set": { - "type": "EqualTo", - "value": 0.4180195852494776 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[8]" - }, - "set": { - "type": "EqualTo", - "value": 11.305606204953921 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[9]" - }, - "set": { - "type": "EqualTo", - "value": 9.120936811607633 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[10]" - }, - "set": { - "type": "EqualTo", - "value": 1.8640401422793809 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[11]" - }, - "set": { - "type": "EqualTo", - "value": 3.327895699300981 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[16]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[20]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[12]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[24]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[28]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[17]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[23]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[22]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[19]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[14]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[25]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[13]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[15]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[27]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[21]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[26]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[18]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[16]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[20]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[12]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[24]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[28]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[17]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[30]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[23]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[32]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[22]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[19]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[31]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[14]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[29]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[33]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[25]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[34]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[13]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[15]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[27]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[21]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[26]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[18]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[5]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[16]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[20]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[12]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[24]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[28]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[8]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[17]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[30]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[23]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[32]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[22]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[6]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[19]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[11]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[31]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[9]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[14]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[29]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[33]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[25]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[7]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[34]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[4]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[13]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[15]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[27]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[21]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[26]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[10]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[18]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 5, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 13, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 16, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 9, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 21, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 25, 26)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 7, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 14, 15)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 2, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 20, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 16, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 14, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 5, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 9, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 7, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 11, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 3, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 17, 27)]" - }, - "set": { - "type": "GreaterThan", - "lower": -2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 6, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 22, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 4, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 9, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 12, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 24, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 18, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 23, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 8, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 14, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 6, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 14, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 17, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 12, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 22, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 26, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 8, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 15, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 28, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 21, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 19, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 16, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 11, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 10, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 28, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 10, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 18, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 4, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 27, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 7, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 23, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 5, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 16, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 13, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 25, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 16, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 24, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 9, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 20, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(5, 5, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(16, 13, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(20, 16, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(12, 9, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(24, 21, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(28, 25, 26)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(8, 7, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(17, 14, 15)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(30, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 2, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(23, 20, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(22, 16, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(19, 14, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(6, 5, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(11, 9, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(31, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(9, 7, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(14, 11, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 3, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(29, 17, 27)]" - }, - "set": { - "type": "GreaterThan", - "lower": -2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(7, 6, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(25, 22, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(4, 4, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(13, 9, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(15, 12, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(27, 24, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(21, 18, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(26, 23, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(10, 8, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(18, 14, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(5, 6, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(16, 14, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(20, 17, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(12, 12, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(24, 22, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(28, 26, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(8, 8, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(17, 15, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(30, 28, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(23, 21, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(22, 19, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(19, 16, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(6, 11, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(11, 10, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(31, 28, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(9, 10, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(14, 18, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 4, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(29, 27, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(7, 7, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(25, 23, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(4, 5, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(13, 16, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(15, 13, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(27, 25, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(21, 16, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(26, 24, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(10, 9, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(18, 20, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[2]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[3]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[4]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[5]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[6]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[7]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[8]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[9]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[10]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[11]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[12]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[13]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[14]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[15]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[16]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[17]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[18]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[19]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[20]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[21]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[22]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[23]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[24]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[25]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[26]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[27]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[28]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[5]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[16]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[20]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[12]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[24]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[28]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[8]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[17]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[23]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[22]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[19]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[6]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[11]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[9]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[14]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[7]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[25]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[4]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[13]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[15]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[27]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[21]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[26]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[10]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[18]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[5]" - }, - "set": { - "type": "LessThan", - "upper": 0.153 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[16]" - }, - "set": { - "type": "LessThan", - "upper": 0.149 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[20]" - }, - "set": { - "type": "LessThan", - "upper": 0.07339999999999999 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[12]" - }, - "set": { - "type": "LessThan", - "upper": 0.3381 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[24]" - }, - "set": { - "type": "LessThan", - "upper": 0.72 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[28]" - }, - "set": { - "type": "LessThan", - "upper": 0.7090000000000001 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[8]" - }, - "set": { - "type": "LessThan", - "upper": 0.1888 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[17]" - }, - "set": { - "type": "LessThan", - "upper": 0.149 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[30]" - }, - "set": { - "type": "LessThan", - "upper": 0.04 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]" - }, - "set": { - "type": "LessThan", - "upper": 0.1826 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[23]" - }, - "set": { - "type": "LessThan", - "upper": 0.10800000000000001 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[32]" - }, - "set": { - "type": "LessThan", - "upper": 0.4917 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[22]" - }, - "set": { - "type": "LessThan", - "upper": 0.1494 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[6]" - }, - "set": { - "type": "LessThan", - "upper": 0.1696 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[19]" - }, - "set": { - "type": "LessThan", - "upper": 0.07339999999999999 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[11]" - }, - "set": { - "type": "LessThan", - "upper": 0.3381 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[31]" - }, - "set": { - "type": "LessThan", - "upper": 0.3367 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[9]" - }, - "set": { - "type": "LessThan", - "upper": 0.5175 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[14]" - }, - "set": { - "type": "LessThan", - "upper": 0.4497 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]" - }, - "set": { - "type": "LessThan", - "upper": 0.1523 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[29]" - }, - "set": { - "type": "LessThan", - "upper": 1.08 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[33]" - }, - "set": { - "type": "LessThan", - "upper": 0.0101 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[25]" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[7]" - }, - "set": { - "type": "LessThan", - "upper": 0.1757 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[34]" - }, - "set": { - "type": "LessThan", - "upper": 0.081 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[4]" - }, - "set": { - "type": "LessThan", - "upper": 0.1623 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[13]" - }, - "set": { - "type": "LessThan", - "upper": 0.4497 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[15]" - }, - "set": { - "type": "LessThan", - "upper": 0.1483 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]" - }, - "set": { - "type": "LessThan", - "upper": 0.1593 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[27]" - }, - "set": { - "type": "LessThan", - "upper": 0.184 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[21]" - }, - "set": { - "type": "LessThan", - "upper": 0.1134 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[26]" - }, - "set": { - "type": "LessThan", - "upper": 0.076 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[10]" - }, - "set": { - "type": "LessThan", - "upper": 0.5175 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[18]" - }, - "set": { - "type": "LessThan", - "upper": 0.149 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[5]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[16]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[20]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[12]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[24]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[28]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[8]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[17]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[30]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[23]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[32]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[22]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[6]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[19]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[11]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[31]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[9]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[14]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[29]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[33]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[25]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[7]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[34]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[4]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[13]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[15]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[27]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[21]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[26]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[10]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[18]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 5, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 13, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 16, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 9, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 21, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 25, 26)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 7, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 14, 15)]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 2, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 20, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 16, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 14, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 5, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 9, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 7, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 11, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 3, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 17, 27)]" - }, - "set": { - "type": "LessThan", - "upper": 2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 6, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 22, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 4, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 9, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 12, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 24, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 18, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 23, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 8, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 14, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 6, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 14, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 17, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 12, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 22, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 26, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 8, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 15, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 28, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 21, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 19, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 16, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 11, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 10, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 28, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 10, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 18, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 4, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 27, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 7, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 23, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 5, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 16, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 13, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 25, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 16, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 24, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 9, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 20, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(5, 5, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(16, 13, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(20, 16, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(12, 9, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(24, 21, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(28, 25, 26)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(8, 7, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(17, 14, 15)]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(30, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 2, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(23, 20, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(22, 16, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(19, 14, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(6, 5, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(11, 9, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(31, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(9, 7, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(14, 11, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 3, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(29, 17, 27)]" - }, - "set": { - "type": "LessThan", - "upper": 2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(7, 6, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(25, 22, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(4, 4, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(13, 9, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(15, 12, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(27, 24, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(21, 18, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(26, 23, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(10, 8, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(18, 14, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(5, 6, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(16, 14, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(20, 17, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(12, 12, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(24, 22, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(28, 26, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(8, 8, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(17, 15, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(30, 28, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(23, 21, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(22, 19, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(19, 16, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(6, 11, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(11, 10, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(31, 28, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(9, 10, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(14, 18, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 4, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(29, 27, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(7, 7, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(25, 23, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(4, 5, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(13, 16, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(15, 13, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(27, 25, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(21, 16, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(26, 24, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(10, 9, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(18, 20, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.1 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[2]_out" - }, - "set": { - "type": "LessThan", - "upper": 137.99 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[3]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.042 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[4]_out" - }, - "set": { - "type": "LessThan", - "upper": 16.76 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[5]_out" - }, - "set": { - "type": "LessThan", - "upper": 10.35 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[6]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.32 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[7]_out" - }, - "set": { - "type": "LessThan", - "upper": 9.72 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[8]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.07 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[9]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.04 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[10]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[11]_out" - }, - "set": { - "type": "LessThan", - "upper": 2.93 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]" - }, - "set": { - "type": "LessThan", - "upper": 10.2926 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[2]" - }, - "set": { - "type": "LessThan", - "upper": 10.5531 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[3]" - }, - "set": { - "type": "LessThan", - "upper": 0.7854 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[4]" - }, - "set": { - "type": "LessThan", - "upper": 3.63 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[5]" - }, - "set": { - "type": "LessThan", - "upper": 8.74 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[6]" - }, - "set": { - "type": "LessThan", - "upper": 17.01 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[7]" - }, - "set": { - "type": "LessThan", - "upper": 1.25 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[8]" - }, - "set": { - "type": "LessThan", - "upper": 7.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[9]" - }, - "set": { - "type": "LessThan", - "upper": 11.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[10]" - }, - "set": { - "type": "LessThan", - "upper": 0.84 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[11]" - }, - "set": { - "type": "LessThan", - "upper": 3.24 - } - } - ] -} diff --git a/examples/HydroPowerModels/bolivia/DCPPowerModel.mof.json b/examples/HydroPowerModels/bolivia/DCPPowerModel.mof.json deleted file mode 100644 index b9cd177..0000000 --- a/examples/HydroPowerModels/bolivia/DCPPowerModel.mof.json +++ /dev/null @@ -1,7018 +0,0 @@ -{ - "name": "MathOptFormat Model", - "version": { - "major": 1, - "minor": 7 - }, - "variables": [ - { - "name": "reservoir[1]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[2]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[3]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[4]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[5]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[6]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[7]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[8]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[9]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[10]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[11]_in", - "primal_start": 0.0 - }, - { - "name": "inflow[1]", - "primal_start": 0.0 - }, - { - "name": "inflow[2]", - "primal_start": 0.0 - }, - { - "name": "inflow[3]", - "primal_start": 0.0 - }, - { - "name": "inflow[4]", - "primal_start": 0.0 - }, - { - "name": "inflow[5]", - "primal_start": 0.0 - }, - { - "name": "inflow[6]", - "primal_start": 0.0 - }, - { - "name": "inflow[7]", - "primal_start": 0.0 - }, - { - "name": "inflow[8]", - "primal_start": 0.0 - }, - { - "name": "inflow[9]", - "primal_start": 0.0 - }, - { - "name": "inflow[10]", - "primal_start": 0.0 - }, - { - "name": "inflow[11]", - "primal_start": 0.0 - }, - { - "name": "0_pg[5]", - "primal_start": 0.0 - }, - { - "name": "0_pg[16]", - "primal_start": 0.0 - }, - { - "name": "0_pg[20]", - "primal_start": 0.0 - }, - { - "name": "0_pg[12]", - "primal_start": 0.0 - }, - { - "name": "0_pg[24]", - "primal_start": 0.0 - }, - { - "name": "0_pg[28]", - "primal_start": 0.0 - }, - { - "name": "0_pg[8]", - "primal_start": 0.0 - }, - { - "name": "0_pg[17]", - "primal_start": 0.0 - }, - { - "name": "0_pg[30]", - "primal_start": 0.0 - }, - { - "name": "0_pg[1]", - "primal_start": 0.0 - }, - { - "name": "0_pg[23]", - "primal_start": 0.0 - }, - { - "name": "0_pg[32]", - "primal_start": 0.0 - }, - { - "name": "0_pg[22]", - "primal_start": 0.0 - }, - { - "name": "0_pg[6]", - "primal_start": 0.0 - }, - { - "name": "0_pg[19]", - "primal_start": 0.0 - }, - { - "name": "0_pg[11]", - "primal_start": 0.0 - }, - { - "name": "0_pg[31]", - "primal_start": 0.0 - }, - { - "name": "0_pg[9]", - "primal_start": 0.0 - }, - { - "name": "0_pg[14]", - "primal_start": 0.0 - }, - { - "name": "0_pg[3]", - "primal_start": 0.0 - }, - { - "name": "0_pg[29]", - "primal_start": 0.0 - }, - { - "name": "0_pg[33]", - "primal_start": 0.0 - }, - { - "name": "0_pg[25]", - "primal_start": 0.0 - }, - { - "name": "0_pg[7]", - "primal_start": 0.0 - }, - { - "name": "0_pg[34]", - "primal_start": 0.0 - }, - { - "name": "0_pg[4]", - "primal_start": 0.0 - }, - { - "name": "0_pg[13]", - "primal_start": 0.0 - }, - { - "name": "0_pg[15]", - "primal_start": 0.0 - }, - { - "name": "0_pg[2]", - "primal_start": 0.0 - }, - { - "name": "0_pg[27]", - "primal_start": 0.0 - }, - { - "name": "0_pg[21]", - "primal_start": 0.0 - }, - { - "name": "0_pg[26]", - "primal_start": 0.0 - }, - { - "name": "0_pg[10]", - "primal_start": 0.0 - }, - { - "name": "0_pg[18]", - "primal_start": 0.0 - }, - { - "name": "0_p[(5, 5, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(16, 13, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(20, 16, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(12, 9, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(24, 21, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(28, 25, 26)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(8, 7, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(17, 14, 15)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(30, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(1, 2, 1)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(23, 20, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(22, 16, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(19, 14, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(6, 5, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(11, 9, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(31, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(9, 7, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(14, 11, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(3, 3, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(29, 17, 27)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(7, 6, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(25, 22, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(4, 4, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(13, 9, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(15, 12, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(2, 2, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(27, 24, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(21, 18, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(26, 23, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(10, 8, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(18, 14, 20)]", - "primal_start": 0.0 - }, - { - "name": "reservoir[1]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[2]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[3]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[4]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[5]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[6]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[7]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[8]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[9]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[10]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[11]_out", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[1]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[2]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[3]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[4]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[5]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[6]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[7]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[8]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[9]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[10]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[11]", - "primal_start": 0.0 - }, - { - "name": "outflow[1]", - "primal_start": 0.0 - }, - { - "name": "outflow[2]", - "primal_start": 0.0 - }, - { - "name": "outflow[3]", - "primal_start": 0.0 - }, - { - "name": "outflow[4]", - "primal_start": 0.0 - }, - { - "name": "outflow[5]", - "primal_start": 0.0 - }, - { - "name": "outflow[6]", - "primal_start": 0.0 - }, - { - "name": "outflow[7]", - "primal_start": 0.0 - }, - { - "name": "outflow[8]", - "primal_start": 0.0 - }, - { - "name": "outflow[9]", - "primal_start": 0.0 - }, - { - "name": "outflow[10]", - "primal_start": 0.0 - }, - { - "name": "outflow[11]", - "primal_start": 0.0 - }, - { - "name": "spill[1]", - "primal_start": 0.0 - }, - { - "name": "spill[2]", - "primal_start": 0.0 - }, - { - "name": "spill[3]", - "primal_start": 0.0 - }, - { - "name": "spill[4]", - "primal_start": 0.0 - }, - { - "name": "spill[5]", - "primal_start": 0.0 - }, - { - "name": "spill[6]", - "primal_start": 0.0 - }, - { - "name": "spill[7]", - "primal_start": 0.0 - }, - { - "name": "spill[8]", - "primal_start": 0.0 - }, - { - "name": "spill[9]", - "primal_start": 0.0 - }, - { - "name": "spill[10]", - "primal_start": 0.0 - }, - { - "name": "spill[11]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[1]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[2]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[3]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[4]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[5]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[6]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[7]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[8]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[9]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[10]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[11]", - "primal_start": 0.0 - }, - { - "name": "deficit[1]", - "primal_start": 0.0 - }, - { - "name": "deficit[2]", - "primal_start": 0.0 - }, - { - "name": "deficit[3]", - "primal_start": 0.0 - }, - { - "name": "deficit[4]", - "primal_start": 0.0 - }, - { - "name": "deficit[5]", - "primal_start": 0.0 - }, - { - "name": "deficit[6]", - "primal_start": 0.0 - }, - { - "name": "deficit[7]", - "primal_start": 0.0 - }, - { - "name": "deficit[8]", - "primal_start": 0.0 - }, - { - "name": "deficit[9]", - "primal_start": 0.0 - }, - { - "name": "deficit[10]", - "primal_start": 0.0 - }, - { - "name": "deficit[11]", - "primal_start": 0.0 - }, - { - "name": "deficit[12]", - "primal_start": 0.0 - }, - { - "name": "deficit[13]", - "primal_start": 0.0 - }, - { - "name": "deficit[14]", - "primal_start": 0.0 - }, - { - "name": "deficit[15]", - "primal_start": 0.0 - }, - { - "name": "deficit[16]", - "primal_start": 0.0 - }, - { - "name": "deficit[17]", - "primal_start": 0.0 - }, - { - "name": "deficit[18]", - "primal_start": 0.0 - }, - { - "name": "deficit[19]", - "primal_start": 0.0 - }, - { - "name": "deficit[20]", - "primal_start": 0.0 - }, - { - "name": "deficit[21]", - "primal_start": 0.0 - }, - { - "name": "deficit[22]", - "primal_start": 0.0 - }, - { - "name": "deficit[23]", - "primal_start": 0.0 - }, - { - "name": "deficit[24]", - "primal_start": 0.0 - }, - { - "name": "deficit[25]", - "primal_start": 0.0 - }, - { - "name": "deficit[26]", - "primal_start": 0.0 - }, - { - "name": "deficit[27]", - "primal_start": 0.0 - }, - { - "name": "deficit[28]", - "primal_start": 0.0 - }, - { - "name": "0_va[5]", - "primal_start": 0.0 - }, - { - "name": "0_va[16]", - "primal_start": 0.0 - }, - { - "name": "0_va[20]", - "primal_start": 0.0 - }, - { - "name": "0_va[12]", - "primal_start": 0.0 - }, - { - "name": "0_va[24]", - "primal_start": 0.0 - }, - { - "name": "0_va[28]", - "primal_start": 0.0 - }, - { - "name": "0_va[8]", - "primal_start": 0.0 - }, - { - "name": "0_va[17]", - "primal_start": 0.0 - }, - { - "name": "0_va[1]", - "primal_start": 0.0 - }, - { - "name": "0_va[23]", - "primal_start": 0.0 - }, - { - "name": "0_va[22]", - "primal_start": 0.0 - }, - { - "name": "0_va[19]", - "primal_start": 0.0 - }, - { - "name": "0_va[6]", - "primal_start": 0.0 - }, - { - "name": "0_va[11]", - "primal_start": 0.0 - }, - { - "name": "0_va[9]", - "primal_start": 0.0 - }, - { - "name": "0_va[14]", - "primal_start": 0.0 - }, - { - "name": "0_va[3]", - "primal_start": 0.0 - }, - { - "name": "0_va[7]", - "primal_start": 0.0 - }, - { - "name": "0_va[25]", - "primal_start": 0.0 - }, - { - "name": "0_va[4]", - "primal_start": 0.0 - }, - { - "name": "0_va[13]", - "primal_start": 0.0 - }, - { - "name": "0_va[15]", - "primal_start": 0.0 - }, - { - "name": "0_va[2]", - "primal_start": 0.0 - }, - { - "name": "0_va[27]", - "primal_start": 0.0 - }, - { - "name": "0_va[21]", - "primal_start": 0.0 - }, - { - "name": "0_va[26]", - "primal_start": 0.0 - }, - { - "name": "0_va[10]", - "primal_start": 0.0 - }, - { - "name": "0_va[18]", - "primal_start": 0.0 - } - ], - "objective": { - "sense": "min", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 6000.0, - "variable": "deficit[1]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[2]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[3]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[4]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[5]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[6]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[7]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[8]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[9]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[10]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[11]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[12]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[13]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[14]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[15]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[16]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[17]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[18]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[19]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[20]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[21]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[22]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[23]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[24]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[25]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[26]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[27]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[28]" - }, - { - "coefficient": 2268.0, - "variable": "0_pg[5]" - }, - { - "coefficient": 2059.0, - "variable": "0_pg[16]" - }, - { - "coefficient": 1780.0, - "variable": "0_pg[20]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[12]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[24]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[28]" - }, - { - "coefficient": 1754.0, - "variable": "0_pg[8]" - }, - { - "coefficient": 2059.0, - "variable": "0_pg[17]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[30]" - }, - { - "coefficient": 1918.0, - "variable": "0_pg[1]" - }, - { - "coefficient": 4244.0, - "variable": "0_pg[23]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[32]" - }, - { - "coefficient": 1517.0, - "variable": "0_pg[22]" - }, - { - "coefficient": 2131.0, - "variable": "0_pg[6]" - }, - { - "coefficient": 1780.0, - "variable": "0_pg[19]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[11]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[31]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[9]" - }, - { - "coefficient": 1404.0, - "variable": "0_pg[14]" - }, - { - "coefficient": 2184.0, - "variable": "0_pg[3]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[29]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[33]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[25]" - }, - { - "coefficient": 1822.0, - "variable": "0_pg[7]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[34]" - }, - { - "coefficient": 2179.0, - "variable": "0_pg[4]" - }, - { - "coefficient": 1404.0, - "variable": "0_pg[13]" - }, - { - "coefficient": 2077.0, - "variable": "0_pg[15]" - }, - { - "coefficient": 2120.0, - "variable": "0_pg[2]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[27]" - }, - { - "coefficient": 1598.0, - "variable": "0_pg[21]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[26]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[10]" - }, - { - "coefficient": 2059.0, - "variable": "0_pg[18]" - } - ], - "constant": 0.0 - } - }, - "constraints": [ - { - "name": "c1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(5, 5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(6, 5, 11)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(4, 4, 5)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c3", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(20, 16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(22, 16, 19)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(19, 14, 16)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(13, 9, 16)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(21, 18, 16)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[16]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.21439096103324617 - } - }, - { - "name": "c4", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(23, 20, 21)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(18, 14, 20)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[20]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0015565421870758504 - } - }, - { - "name": "c5", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_p[(12, 9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(15, 12, 13)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[12]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.05738794110411041 - } - }, - { - "name": "c6", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(27, 24, 25)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(26, 23, 24)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[24]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.01804043447630477 - } - }, - { - "name": "c7", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[28]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[30]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[29]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(30, 19, 28)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(31, 19, 28)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[28]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c8", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[25]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(8, 7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(10, 8, 9)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c9", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_p[(20, 16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(29, 17, 27)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[17]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.267753330934522 - } - }, - { - "name": "c10", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[5]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[8]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[1]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[6]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[9]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[3]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[7]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[4]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[2]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[10]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(1, 2, 1)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.6075543555612704 - } - }, - { - "name": "c11", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[21]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(25, 22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(26, 23, 24)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[23]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0004825663866386638 - } - }, - { - "name": "c12", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[34]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(24, 21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(25, 22, 23)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[22]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.12074817048704867 - } - }, - { - "name": "c13", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[20]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[32]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[19]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[31]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[33]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(30, 19, 28)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(22, 16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(31, 19, 28)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.4735118986170044 - } - }, - { - "name": "c14", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_p[(5, 5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(7, 6, 7)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c15", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_p[(6, 5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(14, 11, 18)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c16", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[16]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[17]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[15]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[18]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(12, 9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(11, 9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(13, 9, 16)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(10, 8, 9)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.21593913974111698 - } - }, - { - "name": "c17", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_p[(16, 13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(17, 14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(19, 14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(18, 14, 20)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[14]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c18", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[12]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[11]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[14]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[13]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 3, 4)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(2, 2, 3)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c19", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[24]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(8, 7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(9, 7, 10)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(7, 6, 7)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c20", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(28, 25, 26)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(27, 24, 25)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[25]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0004825663866386638 - } - }, - { - "name": "c21", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_p[(3, 3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(4, 4, 5)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.02040724338005229 - } - }, - { - "name": "c22", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(16, 13, 14)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(15, 12, 13)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[13]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0004825663866386638 - } - }, - { - "name": "c23", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_p[(17, 14, 15)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[15]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.10015864047547611 - } - }, - { - "name": "c24", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(1, 2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c25", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[27]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(29, 17, 27)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[27]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c26", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(24, 21, 22)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(23, 20, 21)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[21]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c27", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[23]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[22]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(28, 25, 26)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[26]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.1700922829782978 - } - }, - { - "name": "c28", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[26]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(11, 9, 10)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(9, 7, 10)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.5563327884359863 - } - }, - { - "name": "c29", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_p[(14, 11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(21, 18, 16)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[18]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c30", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(5, 5, 6)]" - }, - { - "coefficient": -12.485777918589607, - "variable": "0_va[5]" - }, - { - "coefficient": 12.485777918589607, - "variable": "0_va[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c31", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(16, 13, 14)]" - }, - { - "coefficient": 6.795713842466891, - "variable": "0_va[14]" - }, - { - "coefficient": -6.795713842466891, - "variable": "0_va[13]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c32", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(20, 16, 17)]" - }, - { - "coefficient": -10.149298248521102, - "variable": "0_va[16]" - }, - { - "coefficient": 10.149298248521102, - "variable": "0_va[17]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c33", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(12, 9, 12)]" - }, - { - "coefficient": 6.481250938450924, - "variable": "0_va[12]" - }, - { - "coefficient": -6.481250938450924, - "variable": "0_va[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c34", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(24, 21, 22)]" - }, - { - "coefficient": 4.2328983731321435, - "variable": "0_va[22]" - }, - { - "coefficient": -4.2328983731321435, - "variable": "0_va[21]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c35", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(28, 25, 26)]" - }, - { - "coefficient": -2.091029561081878, - "variable": "0_va[25]" - }, - { - "coefficient": 2.091029561081878, - "variable": "0_va[26]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c36", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(8, 7, 8)]" - }, - { - "coefficient": 45.39453875906154, - "variable": "0_va[8]" - }, - { - "coefficient": -45.39453875906154, - "variable": "0_va[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c37", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(17, 14, 15)]" - }, - { - "coefficient": -19.8968547052082, - "variable": "0_va[14]" - }, - { - "coefficient": 19.8968547052082, - "variable": "0_va[15]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c38", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(30, 19, 28)]" - }, - { - "coefficient": 9.121944633618186, - "variable": "0_va[28]" - }, - { - "coefficient": -9.121944633618186, - "variable": "0_va[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c39", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(1, 2, 1)]" - }, - { - "coefficient": 9.363115118052471, - "variable": "0_va[1]" - }, - { - "coefficient": -9.363115118052471, - "variable": "0_va[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c40", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(23, 20, 21)]" - }, - { - "coefficient": -3.33399327650884, - "variable": "0_va[20]" - }, - { - "coefficient": 3.33399327650884, - "variable": "0_va[21]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c41", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(22, 16, 19)]" - }, - { - "coefficient": -2.8140484527509644, - "variable": "0_va[16]" - }, - { - "coefficient": 2.8140484527509644, - "variable": "0_va[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c42", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(19, 14, 16)]" - }, - { - "coefficient": 3.667991302391842, - "variable": "0_va[16]" - }, - { - "coefficient": -3.667991302391842, - "variable": "0_va[14]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c43", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(6, 5, 11)]" - }, - { - "coefficient": -20.88296190751831, - "variable": "0_va[5]" - }, - { - "coefficient": 20.88296190751831, - "variable": "0_va[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c44", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(11, 9, 10)]" - }, - { - "coefficient": -52.44594387363901, - "variable": "0_va[9]" - }, - { - "coefficient": 52.44594387363901, - "variable": "0_va[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c45", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(31, 19, 28)]" - }, - { - "coefficient": 5.498037005409949, - "variable": "0_va[28]" - }, - { - "coefficient": -5.498037005409949, - "variable": "0_va[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c46", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(9, 7, 10)]" - }, - { - "coefficient": -6.467289330533839, - "variable": "0_va[7]" - }, - { - "coefficient": 6.467289330533839, - "variable": "0_va[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c47", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(14, 11, 18)]" - }, - { - "coefficient": -8.698708713000553, - "variable": "0_va[11]" - }, - { - "coefficient": 8.698708713000553, - "variable": "0_va[18]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c48", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(3, 3, 4)]" - }, - { - "coefficient": -17.010777436904807, - "variable": "0_va[3]" - }, - { - "coefficient": 17.010777436904807, - "variable": "0_va[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c49", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(29, 17, 27)]" - }, - { - "coefficient": -1.6861921183958626, - "variable": "0_va[17]" - }, - { - "coefficient": 1.6861921183958626, - "variable": "0_va[27]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c50", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(7, 6, 7)]" - }, - { - "coefficient": -31.512256609281188, - "variable": "0_va[6]" - }, - { - "coefficient": 31.512256609281188, - "variable": "0_va[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c51", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(25, 22, 23)]" - }, - { - "coefficient": 8.939086077602251, - "variable": "0_va[23]" - }, - { - "coefficient": -8.939086077602251, - "variable": "0_va[22]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c52", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(4, 4, 5)]" - }, - { - "coefficient": 16.36003009370084, - "variable": "0_va[5]" - }, - { - "coefficient": -16.36003009370084, - "variable": "0_va[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c53", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(13, 9, 16)]" - }, - { - "coefficient": 1.8998888915041532, - "variable": "0_va[16]" - }, - { - "coefficient": -1.8998888915041532, - "variable": "0_va[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c54", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(15, 12, 13)]" - }, - { - "coefficient": -7.029547007720768, - "variable": "0_va[12]" - }, - { - "coefficient": 7.029547007720768, - "variable": "0_va[13]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c55", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]" - }, - { - "coefficient": 7.165952433825185, - "variable": "0_va[3]" - }, - { - "coefficient": -7.165952433825185, - "variable": "0_va[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c56", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(27, 24, 25)]" - }, - { - "coefficient": -2.868957761798156, - "variable": "0_va[24]" - }, - { - "coefficient": 2.868957761798156, - "variable": "0_va[25]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c57", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(21, 18, 16)]" - }, - { - "coefficient": 11.73125512037617, - "variable": "0_va[16]" - }, - { - "coefficient": -11.73125512037617, - "variable": "0_va[18]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c58", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(26, 23, 24)]" - }, - { - "coefficient": 5.604798539074481, - "variable": "0_va[24]" - }, - { - "coefficient": -5.604798539074481, - "variable": "0_va[23]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c59", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(10, 8, 9)]" - }, - { - "coefficient": -6.776372942488066, - "variable": "0_va[8]" - }, - { - "coefficient": 6.776372942488066, - "variable": "0_va[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c60", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(18, 14, 20)]" - }, - { - "coefficient": 2.875699016068521, - "variable": "0_va[20]" - }, - { - "coefficient": -2.875699016068521, - "variable": "0_va[14]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[1]" - }, - { - "coefficient": -0.0036, - "variable": "outflow[2]" - }, - { - "coefficient": 1.0, - "variable": "spill[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[2]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[2]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[2]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[2]" - }, - { - "coefficient": 1.0, - "variable": "spill[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[3]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[3]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[3]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[3]" - }, - { - "coefficient": 1.0, - "variable": "spill[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[4]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[4]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[4]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[4]" - }, - { - "coefficient": 1.0, - "variable": "spill[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[5]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[5]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[5]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[5]" - }, - { - "coefficient": 1.0, - "variable": "spill[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[6]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[6]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[6]_out" - }, - { - "coefficient": -0.0036, - "variable": "outflow[5]" - }, - { - "coefficient": 0.0036, - "variable": "outflow[6]" - }, - { - "coefficient": -1.0, - "variable": "spill[5]" - }, - { - "coefficient": 1.0, - "variable": "spill[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[7]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[7]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[7]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[7]" - }, - { - "coefficient": 1.0, - "variable": "spill[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[8]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[8]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[8]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[8]" - }, - { - "coefficient": 1.0, - "variable": "spill[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[9]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[9]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[9]_out" - }, - { - "coefficient": -0.0036, - "variable": "outflow[8]" - }, - { - "coefficient": 0.0036, - "variable": "outflow[9]" - }, - { - "coefficient": -1.0, - "variable": "spill[8]" - }, - { - "coefficient": 1.0, - "variable": "spill[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[10]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[10]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[10]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[10]" - }, - { - "coefficient": 1.0, - "variable": "spill[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[11]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[11]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[11]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[11]" - }, - { - "coefficient": 1.0, - "variable": "spill[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[24]" - }, - { - "coefficient": -6.9953, - "variable": "outflow[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[25]" - }, - { - "coefficient": -5.117, - "variable": "outflow[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[26]" - }, - { - "coefficient": -9.677, - "variable": "outflow[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[27]" - }, - { - "coefficient": -5.06, - "variable": "outflow[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[28]" - }, - { - "coefficient": -8.11, - "variable": "outflow[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[29]" - }, - { - "coefficient": -6.35, - "variable": "outflow[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[30]" - }, - { - "coefficient": -3.2, - "variable": "outflow[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[31]" - }, - { - "coefficient": -4.81, - "variable": "outflow[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[32]" - }, - { - "coefficient": -4.47, - "variable": "outflow[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[33]" - }, - { - "coefficient": -1.2, - "variable": "outflow[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[34]" - }, - { - "coefficient": -2.5, - "variable": "outflow[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "min_volume_violation_bound[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[1]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[2]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[3]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[4]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[5]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[6]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[7]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[8]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[9]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[10]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[11]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[2]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[3]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[4]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[5]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[6]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[7]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[8]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[9]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[10]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[11]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c1_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[5]" - }, - { - "coefficient": -1.0, - "variable": "0_va[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c2_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[14]" - }, - { - "coefficient": 1.0, - "variable": "0_va[13]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c3_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[16]" - }, - { - "coefficient": -1.0, - "variable": "0_va[17]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c4_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[12]" - }, - { - "coefficient": 1.0, - "variable": "0_va[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c5_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[22]" - }, - { - "coefficient": 1.0, - "variable": "0_va[21]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c6_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[25]" - }, - { - "coefficient": -1.0, - "variable": "0_va[26]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c7_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[8]" - }, - { - "coefficient": 1.0, - "variable": "0_va[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c8_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[14]" - }, - { - "coefficient": -1.0, - "variable": "0_va[15]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c9_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[28]" - }, - { - "coefficient": 1.0, - "variable": "0_va[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c10_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[1]" - }, - { - "coefficient": 1.0, - "variable": "0_va[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c11_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[20]" - }, - { - "coefficient": -1.0, - "variable": "0_va[21]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c12_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[16]" - }, - { - "coefficient": -1.0, - "variable": "0_va[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c13_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[16]" - }, - { - "coefficient": 1.0, - "variable": "0_va[14]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c14_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[5]" - }, - { - "coefficient": -1.0, - "variable": "0_va[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c15_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[9]" - }, - { - "coefficient": -1.0, - "variable": "0_va[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c16_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[7]" - }, - { - "coefficient": -1.0, - "variable": "0_va[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c17_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[11]" - }, - { - "coefficient": -1.0, - "variable": "0_va[18]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c18_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[3]" - }, - { - "coefficient": -1.0, - "variable": "0_va[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c19_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[17]" - }, - { - "coefficient": -1.0, - "variable": "0_va[27]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c20_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[6]" - }, - { - "coefficient": -1.0, - "variable": "0_va[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c21_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[23]" - }, - { - "coefficient": 1.0, - "variable": "0_va[22]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c22_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[5]" - }, - { - "coefficient": 1.0, - "variable": "0_va[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c23_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[16]" - }, - { - "coefficient": 1.0, - "variable": "0_va[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c24_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[12]" - }, - { - "coefficient": -1.0, - "variable": "0_va[13]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c25_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]" - }, - { - "coefficient": 1.0, - "variable": "0_va[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c26_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[24]" - }, - { - "coefficient": -1.0, - "variable": "0_va[25]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c27_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[16]" - }, - { - "coefficient": 1.0, - "variable": "0_va[18]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c28_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[24]" - }, - { - "coefficient": 1.0, - "variable": "0_va[23]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c29_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[8]" - }, - { - "coefficient": -1.0, - "variable": "0_va[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c30_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[20]" - }, - { - "coefficient": 1.0, - "variable": "0_va[14]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[2]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[3]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[4]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[5]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[6]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[7]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[8]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[9]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[10]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[11]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[1]" - }, - "set": { - "type": "EqualTo", - "value": 2.511995176219288 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[2]" - }, - "set": { - "type": "EqualTo", - "value": 20.287328815178604 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[3]" - }, - "set": { - "type": "EqualTo", - "value": 0.47051310438920707 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[4]" - }, - "set": { - "type": "EqualTo", - "value": 5.920884899840916 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[5]" - }, - "set": { - "type": "EqualTo", - "value": 8.740098685690562 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[6]" - }, - "set": { - "type": "EqualTo", - "value": 12.202757601522093 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[7]" - }, - "set": { - "type": "EqualTo", - "value": 1.182082511928039 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[8]" - }, - "set": { - "type": "EqualTo", - "value": 7.174922571850988 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[9]" - }, - "set": { - "type": "EqualTo", - "value": 5.793033749093465 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[10]" - }, - "set": { - "type": "EqualTo", - "value": 1.6400117193850288 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[11]" - }, - "set": { - "type": "EqualTo", - "value": 3.196675667842211 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[16]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[20]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[12]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[24]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[28]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[17]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[30]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[23]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[32]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[22]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[19]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[31]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[14]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[29]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[33]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[25]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[34]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[13]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[15]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[27]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[21]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[26]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[18]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 5, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 13, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 16, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 9, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 21, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 25, 26)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 7, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 14, 15)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 2, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 20, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 16, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 14, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 5, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 9, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 7, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 11, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 3, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 17, 27)]" - }, - "set": { - "type": "GreaterThan", - "lower": -2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 6, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 22, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 4, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 9, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 12, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 24, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 18, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 23, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 8, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 14, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[2]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[3]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[4]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[5]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[6]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[7]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[8]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[9]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[10]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[11]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[12]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[13]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[14]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[15]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[16]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[17]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[18]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[19]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[20]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[21]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[22]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[23]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[24]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[25]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[26]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[27]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[28]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[5]" - }, - "set": { - "type": "LessThan", - "upper": 0.153 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[16]" - }, - "set": { - "type": "LessThan", - "upper": 0.149 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[20]" - }, - "set": { - "type": "LessThan", - "upper": 0.07339999999999999 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[12]" - }, - "set": { - "type": "LessThan", - "upper": 0.3381 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[24]" - }, - "set": { - "type": "LessThan", - "upper": 0.72 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[28]" - }, - "set": { - "type": "LessThan", - "upper": 0.7090000000000001 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[8]" - }, - "set": { - "type": "LessThan", - "upper": 0.1888 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[17]" - }, - "set": { - "type": "LessThan", - "upper": 0.149 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[30]" - }, - "set": { - "type": "LessThan", - "upper": 0.04 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]" - }, - "set": { - "type": "LessThan", - "upper": 0.1826 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[23]" - }, - "set": { - "type": "LessThan", - "upper": 0.10800000000000001 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[32]" - }, - "set": { - "type": "LessThan", - "upper": 0.4917 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[22]" - }, - "set": { - "type": "LessThan", - "upper": 0.1494 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[6]" - }, - "set": { - "type": "LessThan", - "upper": 0.1696 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[19]" - }, - "set": { - "type": "LessThan", - "upper": 0.07339999999999999 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[11]" - }, - "set": { - "type": "LessThan", - "upper": 0.3381 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[31]" - }, - "set": { - "type": "LessThan", - "upper": 0.3367 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[9]" - }, - "set": { - "type": "LessThan", - "upper": 0.5175 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[14]" - }, - "set": { - "type": "LessThan", - "upper": 0.4497 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]" - }, - "set": { - "type": "LessThan", - "upper": 0.1523 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[29]" - }, - "set": { - "type": "LessThan", - "upper": 1.08 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[33]" - }, - "set": { - "type": "LessThan", - "upper": 0.0101 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[25]" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[7]" - }, - "set": { - "type": "LessThan", - "upper": 0.1757 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[34]" - }, - "set": { - "type": "LessThan", - "upper": 0.081 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[4]" - }, - "set": { - "type": "LessThan", - "upper": 0.1623 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[13]" - }, - "set": { - "type": "LessThan", - "upper": 0.4497 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[15]" - }, - "set": { - "type": "LessThan", - "upper": 0.1483 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]" - }, - "set": { - "type": "LessThan", - "upper": 0.1593 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[27]" - }, - "set": { - "type": "LessThan", - "upper": 0.184 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[21]" - }, - "set": { - "type": "LessThan", - "upper": 0.1134 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[26]" - }, - "set": { - "type": "LessThan", - "upper": 0.076 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[10]" - }, - "set": { - "type": "LessThan", - "upper": 0.5175 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[18]" - }, - "set": { - "type": "LessThan", - "upper": 0.149 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 5, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 13, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 16, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 9, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 21, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 25, 26)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 7, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 14, 15)]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 2, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 20, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 16, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 14, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 5, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 9, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 7, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 11, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 3, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 17, 27)]" - }, - "set": { - "type": "LessThan", - "upper": 2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 6, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 22, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 4, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 9, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 12, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 24, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 18, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 23, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 8, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 14, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.1 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[2]_out" - }, - "set": { - "type": "LessThan", - "upper": 137.99 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[3]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.042 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[4]_out" - }, - "set": { - "type": "LessThan", - "upper": 16.76 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[5]_out" - }, - "set": { - "type": "LessThan", - "upper": 10.35 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[6]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.32 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[7]_out" - }, - "set": { - "type": "LessThan", - "upper": 9.72 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[8]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.07 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[9]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.04 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[10]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[11]_out" - }, - "set": { - "type": "LessThan", - "upper": 2.93 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]" - }, - "set": { - "type": "LessThan", - "upper": 10.2926 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[2]" - }, - "set": { - "type": "LessThan", - "upper": 10.5531 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[3]" - }, - "set": { - "type": "LessThan", - "upper": 0.7854 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[4]" - }, - "set": { - "type": "LessThan", - "upper": 3.63 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[5]" - }, - "set": { - "type": "LessThan", - "upper": 8.74 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[6]" - }, - "set": { - "type": "LessThan", - "upper": 17.01 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[7]" - }, - "set": { - "type": "LessThan", - "upper": 1.25 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[8]" - }, - "set": { - "type": "LessThan", - "upper": 7.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[9]" - }, - "set": { - "type": "LessThan", - "upper": 11.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[10]" - }, - "set": { - "type": "LessThan", - "upper": 0.84 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[11]" - }, - "set": { - "type": "LessThan", - "upper": 3.24 - } - } - ] -} diff --git a/examples/HydroPowerModels/bolivia/PowerModels.json b/examples/HydroPowerModels/bolivia/PowerModels.json deleted file mode 100644 index 8341e27..0000000 --- a/examples/HydroPowerModels/bolivia/PowerModels.json +++ /dev/null @@ -1,2266 +0,0 @@ -{ - "cost_deficit": 60, - "bus": { - "1": { - "zone": 1, - "bus_i": 1, - "bus_type": 3, - "name": "GCH-069 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 1, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "2": { - "zone": 1, - "bus_i": 2, - "bus_type": 1, - "name": "GCH-230 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 2, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "3": { - "zone": 1, - "bus_i": 3, - "bus_type": 2, - "name": "CAR-230 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 3, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "4": { - "zone": 1, - "bus_i": 4, - "bus_type": 1, - "name": "CHI-230 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 4, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "5": { - "zone": 1, - "bus_i": 5, - "bus_type": 1, - "name": "SJO-230 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 5, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "6": { - "zone": 1, - "bus_i": 6, - "bus_type": 1, - "name": "SJO-115 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 6, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "7": { - "zone": 1, - "bus_i": 7, - "bus_type": 2, - "name": "SIS-115 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 7, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "8": { - "zone": 1, - "bus_i": 8, - "bus_type": 2, - "name": "COR-115 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 8, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "9": { - "zone": 1, - "bus_i": 9, - "bus_type": 2, - "name": "VHE-115 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 9, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "10": { - "zone": 1, - "bus_i": 10, - "bus_type": 2, - "name": "ARO-115 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 10, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "11": { - "zone": 1, - "bus_i": 11, - "bus_type": 1, - "name": "VHE-230 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 11, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "12": { - "zone": 1, - "bus_i": 12, - "bus_type": 1, - "name": "COB-115 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 12, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "13": { - "zone": 1, - "bus_i": 13, - "bus_type": 1, - "name": "SAC-115 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 13, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "14": { - "zone": 1, - "bus_i": 14, - "bus_type": 1, - "name": "CAT-115 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 14, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "15": { - "zone": 1, - "bus_i": 15, - "bus_type": 1, - "name": "CAT-069 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 15, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "16": { - "zone": 1, - "bus_i": 16, - "bus_type": 1, - "name": "VIN-115 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 16, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "17": { - "zone": 1, - "bus_i": 17, - "bus_type": 1, - "name": "VIN-069 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 17, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "18": { - "zone": 1, - "bus_i": 18, - "bus_type": 1, - "name": "VIN-230 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 18, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "19": { - "zone": 1, - "bus_i": 19, - "bus_type": 2, - "name": "KEN-115 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 19, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "20": { - "zone": 1, - "bus_i": 20, - "bus_type": 1, - "name": "OCU-115 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 20, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "21": { - "zone": 1, - "bus_i": 21, - "bus_type": 1, - "name": "POT-115 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 21, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "22": { - "zone": 1, - "bus_i": 22, - "bus_type": 2, - "name": "POT-069 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 22, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "23": { - "zone": 1, - "bus_i": 23, - "bus_type": 2, - "name": "KAR-069 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 23, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "24": { - "zone": 1, - "bus_i": 24, - "bus_type": 1, - "name": "DDI-069 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 24, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "25": { - "zone": 1, - "bus_i": 25, - "bus_type": 1, - "name": "MAR-069 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 25, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "26": { - "zone": 1, - "bus_i": 26, - "bus_type": 2, - "name": "ARJ-069 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 26, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "27": { - "zone": 1, - "bus_i": 27, - "bus_type": 2, - "name": "MIG-069 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 27, - "va": 0, - "vm": 1, - "base_kv": 0 - }, - "28": { - "zone": 1, - "bus_i": 28, - "bus_type": 2, - "name": "ZON-115 ", - "vmax": 1.1, - "area": 1, - "vmin": 0.9, - "index": 28, - "va": 0, - "vm": 1, - "base_kv": 0 - } - }, - "source_type": "matpower", - "name": "bo-caso4", - "dcline": {}, - "source_version": "2.0.0", - "gen": { - "1": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "GCH1 ", - "qg": 0, - "gen_bus": 1, - "pmax": 0.1826, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 1, - "cost": [ - 1918, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "2": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "GCH2 ", - "qg": 0, - "gen_bus": 1, - "pmax": 0.1593, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 2, - "cost": [ - 2120, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "3": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "GCH3 ", - "qg": 0, - "gen_bus": 1, - "pmax": 0.1523, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 3, - "cost": [ - 2184, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "4": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "GCH4 ", - "qg": 0, - "gen_bus": 1, - "pmax": 0.1623, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 4, - "cost": [ - 2179, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "5": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "GCH5 ", - "qg": 0, - "gen_bus": 1, - "pmax": 0.153, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 5, - "cost": [ - 2268, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "6": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "GCH6 ", - "qg": 0, - "gen_bus": 1, - "pmax": 0.1696, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 6, - "cost": [ - 2131, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "7": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "GCH7 ", - "qg": 0, - "gen_bus": 1, - "pmax": 0.1757, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 7, - "cost": [ - 1822, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "8": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "GCH8 ", - "qg": 0, - "gen_bus": 1, - "pmax": 0.1888, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 8, - "cost": [ - 1754, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "9": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "GCH9 ", - "qg": 0, - "gen_bus": 1, - "pmax": 0.5175, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 9, - "cost": [ - 1576, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "10": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "GCH10 ", - "qg": 0, - "gen_bus": 1, - "pmax": 0.5175, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 10, - "cost": [ - 1576, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "11": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "BUL1 ", - "qg": 0, - "gen_bus": 3, - "pmax": 0.3381, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 11, - "cost": [ - 1576, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "12": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "BUL2 ", - "qg": 0, - "gen_bus": 3, - "pmax": 0.3381, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 12, - "cost": [ - 1576, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "13": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "CAR1 ", - "qg": 0, - "gen_bus": 3, - "pmax": 0.4497, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 13, - "cost": [ - 1404, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "14": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "CAR2 ", - "qg": 0, - "gen_bus": 3, - "pmax": 0.4497, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 14, - "cost": [ - 1404, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "15": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "VHE1 ", - "qg": 0, - "gen_bus": 9, - "pmax": 0.1483, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 15, - "cost": [ - 2077, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "16": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "VHE2 ", - "qg": 0, - "gen_bus": 9, - "pmax": 0.149, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 16, - "cost": [ - 2059, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "17": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "VHE3 ", - "qg": 0, - "gen_bus": 9, - "pmax": 0.149, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 17, - "cost": [ - 2059, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "18": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "VHE4 ", - "qg": 0, - "gen_bus": 9, - "pmax": 0.149, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 18, - "cost": [ - 2059, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "19": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "KEN1 ", - "qg": 0, - "gen_bus": 19, - "pmax": 0.07339999999999999, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 19, - "cost": [ - 1780, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "20": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "KEN2 ", - "qg": 0, - "gen_bus": 19, - "pmax": 0.07339999999999999, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 20, - "cost": [ - 1780, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "21": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "KAR ", - "qg": 0, - "gen_bus": 23, - "pmax": 0.1134, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 21, - "cost": [ - 1598, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "22": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "ARJ8 ", - "qg": 0, - "gen_bus": 26, - "pmax": 0.1494, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 22, - "cost": [ - 1517, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "23": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "name": "ARJDF ", - "qg": 0, - "gen_bus": 26, - "pmax": 0.10800000000000001, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 23, - "cost": [ - 4244, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "24": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "qg": 0, - "gen_bus": 7, - "pmax": 0.72, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 24, - "cost": [ - 10, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "25": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "qg": 0, - "gen_bus": 8, - "pmax": 0.54, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 25, - "cost": [ - 10, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "26": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "qg": 0, - "gen_bus": 10, - "pmax": 0.076, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 26, - "cost": [ - 10, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "27": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "qg": 0, - "gen_bus": 27, - "pmax": 0.184, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 27, - "cost": [ - 10, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "28": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "qg": 0, - "gen_bus": 28, - "pmax": 0.7090000000000001, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 28, - "cost": [ - 10, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "29": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "qg": 0, - "gen_bus": 28, - "pmax": 1.08, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 29, - "cost": [ - 10, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "30": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "qg": 0, - "gen_bus": 28, - "pmax": 0.04, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 30, - "cost": [ - 10, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "31": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "qg": 0, - "gen_bus": 19, - "pmax": 0.3367, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 31, - "cost": [ - 10, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "32": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "qg": 0, - "gen_bus": 19, - "pmax": 0.4917, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 32, - "cost": [ - 10, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "33": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "qg": 0, - "gen_bus": 19, - "pmax": 0.0101, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 33, - "cost": [ - 10, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - }, - "34": { - "pmin": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "qg": 0, - "gen_bus": 22, - "pmax": 0.081, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 34, - "cost": [ - 10, - 0 - ], - "qmax": 999, - "gen_status": 1, - "qmin": -999, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "apf": 0, - "ncost": 2 - } - }, - "branch": { - "1": { - "br_r": 0.0033, - "rate_a": 0.7, - "shift": 0, - "name": "GCH069GCH230", - "br_x": 0.1067, - "g_to": 0, - "g_fr": 0, - "b_fr": 0, - "f_bus": 2, - "br_status": 1, - "t_bus": 1, - "b_to": 0, - "index": 1, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "2": { - "br_r": 0.0204, - "rate_a": 1.3, - "shift": 0, - "name": "GCH230CAR230", - "br_x": 0.1365, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.134, - "f_bus": 2, - "br_status": 1, - "t_bus": 3, - "b_to": 0.134, - "index": 2, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "3": { - "br_r": 0.0086, - "rate_a": 1.3, - "shift": 0, - "name": "CAR230CHI230", - "br_x": 0.0575, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.0565, - "f_bus": 3, - "br_status": 1, - "t_bus": 4, - "b_to": 0.0565, - "index": 3, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "4": { - "br_r": 0.0089, - "rate_a": 1.3, - "shift": 0, - "name": "CHI230SJO230", - "br_x": 0.059800000000000006, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.058499999999999996, - "f_bus": 4, - "br_status": 1, - "t_bus": 5, - "b_to": 0.058499999999999996, - "index": 4, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "5": { - "br_r": 0.0027, - "rate_a": 0.7, - "shift": 0, - "name": "SJO230SJO115", - "br_x": 0.08, - "g_to": 0, - "g_fr": 0, - "b_fr": 0, - "f_bus": 5, - "br_status": 1, - "t_bus": 6, - "b_to": 0, - "index": 5, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "6": { - "br_r": 0.0068000000000000005, - "rate_a": 1.3, - "shift": 0, - "name": "SJO230VHE230", - "br_x": 0.046900000000000004, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.04305, - "f_bus": 5, - "br_status": 1, - "t_bus": 11, - "b_to": 0.04305, - "index": 6, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "7": { - "br_r": 0.0096, - "rate_a": 0.74, - "shift": 0, - "name": "SJO115SIS115", - "br_x": 0.0285, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.0016, - "f_bus": 6, - "br_status": 1, - "t_bus": 7, - "b_to": 0.0016, - "index": 7, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "8": { - "br_r": 0.0069, - "rate_a": 0.74, - "shift": 0, - "name": "SIS115COR115", - "br_x": 0.0196, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.0012, - "f_bus": 7, - "br_status": 1, - "t_bus": 8, - "b_to": 0.0012, - "index": 8, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "9": { - "br_r": 0.0495, - "rate_a": 0.74, - "shift": 0, - "name": "SIS115ARO115", - "br_x": 0.1367, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.00855, - "f_bus": 7, - "br_status": 1, - "t_bus": 10, - "b_to": 0.00855, - "index": 9, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "10": { - "br_r": 0.0472, - "rate_a": 0.74, - "shift": 0, - "name": "COR115VHE115", - "br_x": 0.1305, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.008199999999999999, - "f_bus": 8, - "br_status": 1, - "t_bus": 9, - "b_to": 0.008199999999999999, - "index": 10, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "11": { - "br_r": 0.0058, - "rate_a": 0.74, - "shift": 0, - "name": "VHE115ARO115", - "br_x": 0.0171, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.00095, - "f_bus": 9, - "br_status": 1, - "t_bus": 10, - "b_to": 0.00095, - "index": 11, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "12": { - "br_r": 0.049400000000000006, - "rate_a": 0.74, - "shift": 0, - "name": "VHE115COB115", - "br_x": 0.1364, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.00855, - "f_bus": 9, - "br_status": 1, - "t_bus": 12, - "b_to": 0.00855, - "index": 12, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "13": { - "br_r": 0.15990000000000001, - "rate_a": 0.74, - "shift": 0, - "name": "VHE115VIN115", - "br_x": 0.4722, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.0263, - "f_bus": 9, - "br_status": 1, - "t_bus": 16, - "b_to": 0.0263, - "index": 13, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "14": { - "br_r": 0.0163, - "rate_a": 1.3, - "shift": 0, - "name": "VHE230VIN230", - "br_x": 0.11259999999999999, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.10300000000000001, - "f_bus": 11, - "br_status": 1, - "t_bus": 18, - "b_to": 0.10300000000000001, - "index": 14, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "15": { - "br_r": 0.0455, - "rate_a": 0.74, - "shift": 0, - "name": "COB115SAC115", - "br_x": 0.1258, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.0079, - "f_bus": 12, - "br_status": 1, - "t_bus": 13, - "b_to": 0.0079, - "index": 15, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "16": { - "br_r": 0.0471, - "rate_a": 0.74, - "shift": 0, - "name": "SAC115CAT115", - "br_x": 0.1301, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.00815, - "f_bus": 13, - "br_status": 1, - "t_bus": 14, - "b_to": 0.00815, - "index": 16, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "17": { - "br_r": 0.0036, - "rate_a": 0.5, - "shift": 0, - "name": "CAT115CAT069", - "br_x": 0.05, - "g_to": 0, - "g_fr": 0, - "b_fr": 0, - "f_bus": 14, - "br_status": 1, - "t_bus": 15, - "b_to": 0, - "index": 17, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "18": { - "br_r": 0.1056, - "rate_a": 0.47, - "shift": 0, - "name": "CAT115OCU115", - "br_x": 0.312, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.0174, - "f_bus": 14, - "br_status": 1, - "t_bus": 20, - "b_to": 0.0174, - "index": 18, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "19": { - "br_r": 0.0828, - "rate_a": 0.74, - "shift": 0, - "name": "CAT115VIN115", - "br_x": 0.2446, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.01365, - "f_bus": 14, - "br_status": 1, - "t_bus": 16, - "b_to": 0.01365, - "index": 19, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "20": { - "br_r": 0.0072, - "rate_a": 0.25, - "shift": 0, - "name": "VIN069VIN115", - "br_x": 0.098, - "g_to": 0, - "g_fr": 0, - "b_fr": 0, - "f_bus": 16, - "br_status": 1, - "t_bus": 17, - "b_to": 0, - "index": 20, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "21": { - "br_r": 0.0019, - "rate_a": 1, - "shift": 0, - "name": "VIN115VIN230", - "br_x": 0.0852, - "g_to": 0, - "g_fr": 0, - "b_fr": 0, - "f_bus": 18, - "br_status": 1, - "t_bus": 16, - "b_to": 0, - "index": 21, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "22": { - "br_r": 0.09630000000000001, - "rate_a": 1.06, - "shift": 0, - "name": "VIN115KEN115", - "br_x": 0.327, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.0363, - "f_bus": 16, - "br_status": 1, - "t_bus": 19, - "b_to": 0.0363, - "index": 22, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "23": { - "br_r": 0.0911, - "rate_a": 0.47, - "shift": 0, - "name": "OCU115POT115", - "br_x": 0.2691, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.015, - "f_bus": 20, - "br_status": 1, - "t_bus": 21, - "b_to": 0.015, - "index": 23, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "24": { - "br_r": 0.0076, - "rate_a": 0.25, - "shift": 0, - "name": "POT115POT069", - "br_x": 0.23600000000000002, - "g_to": 0, - "g_fr": 0, - "b_fr": 0, - "f_bus": 21, - "br_status": 1, - "t_bus": 22, - "b_to": 0, - "index": 24, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "25": { - "br_r": 0.045899999999999996, - "rate_a": 0.33, - "shift": 0, - "name": "POT069KAR069", - "br_x": 0.08789999999999999, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.00065, - "f_bus": 22, - "br_status": 1, - "t_bus": 23, - "b_to": 0.00065, - "index": 25, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "26": { - "br_r": 0.0732, - "rate_a": 0.13, - "shift": 0, - "name": "KAR069DDI069", - "br_x": 0.1402, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.00105, - "f_bus": 23, - "br_status": 1, - "t_bus": 24, - "b_to": 0.00105, - "index": 26, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "27": { - "br_r": 0.14300000000000002, - "rate_a": 0.13, - "shift": 0, - "name": "DDI069MAR069", - "br_x": 0.27390000000000003, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.0020499999999999997, - "f_bus": 24, - "br_status": 1, - "t_bus": 25, - "b_to": 0.0020499999999999997, - "index": 27, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "28": { - "br_r": 0.1962, - "rate_a": 0.13, - "shift": 0, - "name": "MAR069ARJ069", - "br_x": 0.37579999999999997, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.0028499999999999997, - "f_bus": 25, - "br_status": 1, - "t_bus": 26, - "b_to": 0.0028499999999999997, - "index": 28, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "29": { - "br_r": 0.17179, - "rate_a": 2, - "shift": 0, - "name": "VIN69MIG69 ", - "br_x": 0.53822, - "g_to": 0, - "g_fr": 0, - "b_fr": 0, - "f_bus": 17, - "br_status": 1, - "t_bus": 27, - "b_to": 0, - "index": 29, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "30": { - "br_r": 0.010452, - "rate_a": 1, - "shift": 0, - "name": "KEN115ZON115", - "br_x": 0.10862, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.0248, - "f_bus": 19, - "br_status": 1, - "t_bus": 28, - "b_to": 0.0248, - "index": 30, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "31": { - "br_r": 0.030990000000000004, - "rate_a": 1, - "shift": 0, - "name": "KEN-ZON115-2", - "br_x": 0.17643999999999999, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.0106, - "f_bus": 19, - "br_status": 1, - "t_bus": 28, - "b_to": 0.0106, - "index": 31, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - } - }, - "storage": {}, - "switch": {}, - "baseMVA": 100, - "per_unit": true, - "shunt": {}, - "load": { - "1": { - "load_bus": 1, - "status": 1, - "qd": 0.32151087111225407, - "pd": 2.679257259268784, - "index": 1 - }, - "2": { - "load_bus": 2, - "status": 1, - "qd": 0, - "pd": 0, - "index": 2 - }, - "3": { - "load_bus": 3, - "status": 1, - "qd": 0, - "pd": 0, - "index": 3 - }, - "4": { - "load_bus": 4, - "status": 1, - "qd": 0.004081448676010458, - "pd": 0.034012072300087154, - "index": 4 - }, - "5": { - "load_bus": 5, - "status": 1, - "qd": 0, - "pd": 0, - "index": 5 - }, - "6": { - "load_bus": 6, - "status": 1, - "qd": 0, - "pd": 0, - "index": 6 - }, - "7": { - "load_bus": 7, - "status": 1, - "qd": 0, - "pd": 0, - "index": 7 - }, - "8": { - "load_bus": 8, - "status": 1, - "qd": 0, - "pd": 0, - "index": 8 - }, - "9": { - "load_bus": 9, - "status": 1, - "qd": 0.043187827948223394, - "pd": 0.35989856623519495, - "index": 9 - }, - "10": { - "load_bus": 10, - "status": 1, - "qd": 0.11126655768719727, - "pd": 0.9272213140599773, - "index": 10 - }, - "11": { - "load_bus": 11, - "status": 1, - "qd": 0, - "pd": 0, - "index": 11 - }, - "12": { - "load_bus": 12, - "status": 1, - "qd": 0.011477588220822081, - "pd": 0.09564656850685069, - "index": 12 - }, - "13": { - "load_bus": 13, - "status": 1, - "qd": 0.00009651327732773278, - "pd": 0.0008042773110644398, - "index": 13 - }, - "14": { - "load_bus": 14, - "status": 1, - "qd": 0, - "pd": 0, - "index": 14 - }, - "15": { - "load_bus": 15, - "status": 1, - "qd": 0.020031728095095222, - "pd": 0.16693106745912686, - "index": 15 - }, - "16": { - "load_bus": 16, - "status": 1, - "qd": 0.042878192206649235, - "pd": 0.35731826838874364, - "index": 16 - }, - "17": { - "load_bus": 17, - "status": 1, - "qd": 0.053550666186904405, - "pd": 0.4462555515575367, - "index": 17 - }, - "18": { - "load_bus": 18, - "status": 1, - "qd": 0, - "pd": 0, - "index": 18 - }, - "19": { - "load_bus": 19, - "status": 1, - "qd": 0.29470237972340085, - "pd": 2.455853164361674, - "index": 19 - }, - "20": { - "load_bus": 20, - "status": 1, - "qd": 0.0003113084374151701, - "pd": 0.002594236978459751, - "index": 20 - }, - "21": { - "load_bus": 21, - "status": 1, - "qd": 0, - "pd": 0, - "index": 21 - }, - "22": { - "load_bus": 22, - "status": 1, - "qd": 0.024149634097409733, - "pd": 0.2012469508117478, - "index": 22 - }, - "23": { - "load_bus": 23, - "status": 1, - "qd": 0.00009651327732773278, - "pd": 0.0008042773110644398, - "index": 23 - }, - "24": { - "load_bus": 24, - "status": 1, - "qd": 0.0036080868952609543, - "pd": 0.030067390793841287, - "index": 24 - }, - "25": { - "load_bus": 25, - "status": 1, - "qd": 0.00009651327732773278, - "pd": 0.0008042773110644398, - "index": 25 - }, - "26": { - "load_bus": 26, - "status": 1, - "qd": 0.03401845659565956, - "pd": 0.283487138297163, - "index": 26 - } - } -} \ No newline at end of file diff --git a/examples/HydroPowerModels/bolivia/SOCWRConicPowerModel.mof.json b/examples/HydroPowerModels/bolivia/SOCWRConicPowerModel.mof.json deleted file mode 100644 index 14d2ff7..0000000 --- a/examples/HydroPowerModels/bolivia/SOCWRConicPowerModel.mof.json +++ /dev/null @@ -1,21020 +0,0 @@ -{ - "name": "MathOptFormat Model", - "version": { - "major": 1, - "minor": 7 - }, - "variables": [ - { - "name": "reservoir[1]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[2]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[3]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[4]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[5]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[6]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[7]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[8]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[9]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[10]_in", - "primal_start": 0.0 - }, - { - "name": "reservoir[11]_in", - "primal_start": 0.0 - }, - { - "name": "inflow[1]", - "primal_start": 0.0 - }, - { - "name": "inflow[2]", - "primal_start": 0.0 - }, - { - "name": "inflow[3]", - "primal_start": 0.0 - }, - { - "name": "inflow[4]", - "primal_start": 0.0 - }, - { - "name": "inflow[5]", - "primal_start": 0.0 - }, - { - "name": "inflow[6]", - "primal_start": 0.0 - }, - { - "name": "inflow[7]", - "primal_start": 0.0 - }, - { - "name": "inflow[8]", - "primal_start": 0.0 - }, - { - "name": "inflow[9]", - "primal_start": 0.0 - }, - { - "name": "inflow[10]", - "primal_start": 0.0 - }, - { - "name": "inflow[11]", - "primal_start": 0.0 - }, - { - "name": "0_w[5]", - "primal_start": 1.001 - }, - { - "name": "0_w[16]", - "primal_start": 1.001 - }, - { - "name": "0_w[20]", - "primal_start": 1.001 - }, - { - "name": "0_w[12]", - "primal_start": 1.001 - }, - { - "name": "0_w[24]", - "primal_start": 1.001 - }, - { - "name": "0_w[28]", - "primal_start": 1.001 - }, - { - "name": "0_w[8]", - "primal_start": 1.001 - }, - { - "name": "0_w[17]", - "primal_start": 1.001 - }, - { - "name": "0_w[1]", - "primal_start": 1.001 - }, - { - "name": "0_w[23]", - "primal_start": 1.001 - }, - { - "name": "0_w[22]", - "primal_start": 1.001 - }, - { - "name": "0_w[19]", - "primal_start": 1.001 - }, - { - "name": "0_w[6]", - "primal_start": 1.001 - }, - { - "name": "0_w[11]", - "primal_start": 1.001 - }, - { - "name": "0_w[9]", - "primal_start": 1.001 - }, - { - "name": "0_w[14]", - "primal_start": 1.001 - }, - { - "name": "0_w[3]", - "primal_start": 1.001 - }, - { - "name": "0_w[7]", - "primal_start": 1.001 - }, - { - "name": "0_w[25]", - "primal_start": 1.001 - }, - { - "name": "0_w[4]", - "primal_start": 1.001 - }, - { - "name": "0_w[13]", - "primal_start": 1.001 - }, - { - "name": "0_w[15]", - "primal_start": 1.001 - }, - { - "name": "0_w[2]", - "primal_start": 1.001 - }, - { - "name": "0_w[27]", - "primal_start": 1.001 - }, - { - "name": "0_w[21]", - "primal_start": 1.001 - }, - { - "name": "0_w[26]", - "primal_start": 1.001 - }, - { - "name": "0_w[10]", - "primal_start": 1.001 - }, - { - "name": "0_w[18]", - "primal_start": 1.001 - }, - { - "name": "0_wr[(18, 16)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(19, 28)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(11, 18)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(4, 5)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(23, 24)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(12, 13)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(9, 10)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(9, 12)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(25, 26)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(7, 8)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(21, 22)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(5, 11)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(14, 15)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(7, 10)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(8, 9)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(5, 6)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(2, 1)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(3, 4)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(9, 16)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(14, 20)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(16, 19)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(14, 16)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(2, 3)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(16, 17)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(24, 25)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(13, 14)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(22, 23)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(6, 7)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(20, 21)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(17, 27)]", - "primal_start": 1.0 - }, - { - "name": "0_wi[(18, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(11, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(4, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(23, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(12, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(9, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(9, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(25, 26)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(7, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(21, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(5, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(14, 15)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(7, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(8, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(5, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(2, 1)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(3, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(9, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(14, 20)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(16, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(14, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(2, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(16, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(24, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(13, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(22, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(6, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(20, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(17, 27)]", - "primal_start": 0.0 - }, - { - "name": "0_pg[5]", - "primal_start": 0.0 - }, - { - "name": "0_pg[16]", - "primal_start": 0.0 - }, - { - "name": "0_pg[20]", - "primal_start": 0.0 - }, - { - "name": "0_pg[12]", - "primal_start": 0.0 - }, - { - "name": "0_pg[24]", - "primal_start": 0.0 - }, - { - "name": "0_pg[28]", - "primal_start": 0.0 - }, - { - "name": "0_pg[8]", - "primal_start": 0.0 - }, - { - "name": "0_pg[17]", - "primal_start": 0.0 - }, - { - "name": "0_pg[30]", - "primal_start": 0.0 - }, - { - "name": "0_pg[1]", - "primal_start": 0.0 - }, - { - "name": "0_pg[23]", - "primal_start": 0.0 - }, - { - "name": "0_pg[32]", - "primal_start": 0.0 - }, - { - "name": "0_pg[22]", - "primal_start": 0.0 - }, - { - "name": "0_pg[6]", - "primal_start": 0.0 - }, - { - "name": "0_pg[19]", - "primal_start": 0.0 - }, - { - "name": "0_pg[11]", - "primal_start": 0.0 - }, - { - "name": "0_pg[31]", - "primal_start": 0.0 - }, - { - "name": "0_pg[9]", - "primal_start": 0.0 - }, - { - "name": "0_pg[14]", - "primal_start": 0.0 - }, - { - "name": "0_pg[3]", - "primal_start": 0.0 - }, - { - "name": "0_pg[29]", - "primal_start": 0.0 - }, - { - "name": "0_pg[33]", - "primal_start": 0.0 - }, - { - "name": "0_pg[25]", - "primal_start": 0.0 - }, - { - "name": "0_pg[7]", - "primal_start": 0.0 - }, - { - "name": "0_pg[34]", - "primal_start": 0.0 - }, - { - "name": "0_pg[4]", - "primal_start": 0.0 - }, - { - "name": "0_pg[13]", - "primal_start": 0.0 - }, - { - "name": "0_pg[15]", - "primal_start": 0.0 - }, - { - "name": "0_pg[2]", - "primal_start": 0.0 - }, - { - "name": "0_pg[27]", - "primal_start": 0.0 - }, - { - "name": "0_pg[21]", - "primal_start": 0.0 - }, - { - "name": "0_pg[26]", - "primal_start": 0.0 - }, - { - "name": "0_pg[10]", - "primal_start": 0.0 - }, - { - "name": "0_pg[18]", - "primal_start": 0.0 - }, - { - "name": "0_qg[5]", - "primal_start": 0.0 - }, - { - "name": "0_qg[16]", - "primal_start": 0.0 - }, - { - "name": "0_qg[20]", - "primal_start": 0.0 - }, - { - "name": "0_qg[12]", - "primal_start": 0.0 - }, - { - "name": "0_qg[24]", - "primal_start": 0.0 - }, - { - "name": "0_qg[28]", - "primal_start": 0.0 - }, - { - "name": "0_qg[8]", - "primal_start": 0.0 - }, - { - "name": "0_qg[17]", - "primal_start": 0.0 - }, - { - "name": "0_qg[30]", - "primal_start": 0.0 - }, - { - "name": "0_qg[1]", - "primal_start": 0.0 - }, - { - "name": "0_qg[23]", - "primal_start": 0.0 - }, - { - "name": "0_qg[32]", - "primal_start": 0.0 - }, - { - "name": "0_qg[22]", - "primal_start": 0.0 - }, - { - "name": "0_qg[6]", - "primal_start": 0.0 - }, - { - "name": "0_qg[19]", - "primal_start": 0.0 - }, - { - "name": "0_qg[11]", - "primal_start": 0.0 - }, - { - "name": "0_qg[31]", - "primal_start": 0.0 - }, - { - "name": "0_qg[9]", - "primal_start": 0.0 - }, - { - "name": "0_qg[14]", - "primal_start": 0.0 - }, - { - "name": "0_qg[3]", - "primal_start": 0.0 - }, - { - "name": "0_qg[29]", - "primal_start": 0.0 - }, - { - "name": "0_qg[33]", - "primal_start": 0.0 - }, - { - "name": "0_qg[25]", - "primal_start": 0.0 - }, - { - "name": "0_qg[7]", - "primal_start": 0.0 - }, - { - "name": "0_qg[34]", - "primal_start": 0.0 - }, - { - "name": "0_qg[4]", - "primal_start": 0.0 - }, - { - "name": "0_qg[13]", - "primal_start": 0.0 - }, - { - "name": "0_qg[15]", - "primal_start": 0.0 - }, - { - "name": "0_qg[2]", - "primal_start": 0.0 - }, - { - "name": "0_qg[27]", - "primal_start": 0.0 - }, - { - "name": "0_qg[21]", - "primal_start": 0.0 - }, - { - "name": "0_qg[26]", - "primal_start": 0.0 - }, - { - "name": "0_qg[10]", - "primal_start": 0.0 - }, - { - "name": "0_qg[18]", - "primal_start": 0.0 - }, - { - "name": "0_p[(5, 5, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(16, 13, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(20, 16, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(12, 9, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(24, 21, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(28, 25, 26)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(8, 7, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(17, 14, 15)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(30, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(1, 2, 1)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(23, 20, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(22, 16, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(19, 14, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(6, 5, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(11, 9, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(31, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(9, 7, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(14, 11, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(3, 3, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(29, 17, 27)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(7, 6, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(25, 22, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(4, 4, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(13, 9, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(15, 12, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(2, 2, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(27, 24, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(21, 18, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(26, 23, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(10, 8, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(18, 14, 20)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(5, 6, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(16, 14, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(20, 17, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(12, 12, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(24, 22, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(28, 26, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(8, 8, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(17, 15, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(30, 28, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(1, 1, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(23, 21, 20)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(22, 19, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(19, 16, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(6, 11, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(11, 10, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(31, 28, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(9, 10, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(14, 18, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(3, 4, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(29, 27, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(7, 7, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(25, 23, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(4, 5, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(13, 16, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(15, 13, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(2, 3, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(27, 25, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(21, 16, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(26, 24, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(10, 9, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(18, 20, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(5, 5, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(16, 13, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(20, 16, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(12, 9, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(24, 21, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(28, 25, 26)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(8, 7, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(17, 14, 15)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(30, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(1, 2, 1)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(23, 20, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(22, 16, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(19, 14, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(6, 5, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(11, 9, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(31, 19, 28)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(9, 7, 10)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(14, 11, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(3, 3, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(29, 17, 27)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(7, 6, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(25, 22, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(4, 4, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(13, 9, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(15, 12, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(2, 2, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(27, 24, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(21, 18, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(26, 23, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(10, 8, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(18, 14, 20)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(5, 6, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(16, 14, 13)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(20, 17, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(12, 12, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(24, 22, 21)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(28, 26, 25)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(8, 8, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(17, 15, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(30, 28, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(1, 1, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(23, 21, 20)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(22, 19, 16)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(19, 16, 14)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(6, 11, 5)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(11, 10, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(31, 28, 19)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(9, 10, 7)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(14, 18, 11)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(3, 4, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(29, 27, 17)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(7, 7, 6)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(25, 23, 22)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(4, 5, 4)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(13, 16, 9)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(15, 13, 12)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(2, 3, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(27, 25, 24)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(21, 16, 18)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(26, 24, 23)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(10, 9, 8)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(18, 20, 14)]", - "primal_start": 0.0 - }, - { - "name": "reservoir[1]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[2]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[3]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[4]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[5]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[6]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[7]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[8]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[9]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[10]_out", - "primal_start": 0.0 - }, - { - "name": "reservoir[11]_out", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[1]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[2]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[3]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[4]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[5]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[6]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[7]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[8]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[9]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[10]", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[11]", - "primal_start": 0.0 - }, - { - "name": "outflow[1]", - "primal_start": 0.0 - }, - { - "name": "outflow[2]", - "primal_start": 0.0 - }, - { - "name": "outflow[3]", - "primal_start": 0.0 - }, - { - "name": "outflow[4]", - "primal_start": 0.0 - }, - { - "name": "outflow[5]", - "primal_start": 0.0 - }, - { - "name": "outflow[6]", - "primal_start": 0.0 - }, - { - "name": "outflow[7]", - "primal_start": 0.0 - }, - { - "name": "outflow[8]", - "primal_start": 0.0 - }, - { - "name": "outflow[9]", - "primal_start": 0.0 - }, - { - "name": "outflow[10]", - "primal_start": 0.0 - }, - { - "name": "outflow[11]", - "primal_start": 0.0 - }, - { - "name": "spill[1]", - "primal_start": 0.0 - }, - { - "name": "spill[2]", - "primal_start": 0.0 - }, - { - "name": "spill[3]", - "primal_start": 0.0 - }, - { - "name": "spill[4]", - "primal_start": 0.0 - }, - { - "name": "spill[5]", - "primal_start": 0.0 - }, - { - "name": "spill[6]", - "primal_start": 0.0 - }, - { - "name": "spill[7]", - "primal_start": 0.0 - }, - { - "name": "spill[8]", - "primal_start": 0.0 - }, - { - "name": "spill[9]", - "primal_start": 0.0 - }, - { - "name": "spill[10]", - "primal_start": 0.0 - }, - { - "name": "spill[11]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[1]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[2]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[3]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[4]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[5]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[6]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[7]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[8]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[9]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[10]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[11]", - "primal_start": 0.0 - }, - { - "name": "deficit[1]", - "primal_start": 0.0 - }, - { - "name": "deficit[2]", - "primal_start": 0.0 - }, - { - "name": "deficit[3]", - "primal_start": 0.0 - }, - { - "name": "deficit[4]", - "primal_start": 0.0 - }, - { - "name": "deficit[5]", - "primal_start": 0.0 - }, - { - "name": "deficit[6]", - "primal_start": 0.0 - }, - { - "name": "deficit[7]", - "primal_start": 0.0 - }, - { - "name": "deficit[8]", - "primal_start": 0.0 - }, - { - "name": "deficit[9]", - "primal_start": 0.0 - }, - { - "name": "deficit[10]", - "primal_start": 0.0 - }, - { - "name": "deficit[11]", - "primal_start": 0.0 - }, - { - "name": "deficit[12]", - "primal_start": 0.0 - }, - { - "name": "deficit[13]", - "primal_start": 0.0 - }, - { - "name": "deficit[14]", - "primal_start": 0.0 - }, - { - "name": "deficit[15]", - "primal_start": 0.0 - }, - { - "name": "deficit[16]", - "primal_start": 0.0 - }, - { - "name": "deficit[17]", - "primal_start": 0.0 - }, - { - "name": "deficit[18]", - "primal_start": 0.0 - }, - { - "name": "deficit[19]", - "primal_start": 0.0 - }, - { - "name": "deficit[20]", - "primal_start": 0.0 - }, - { - "name": "deficit[21]", - "primal_start": 0.0 - }, - { - "name": "deficit[22]", - "primal_start": 0.0 - }, - { - "name": "deficit[23]", - "primal_start": 0.0 - }, - { - "name": "deficit[24]", - "primal_start": 0.0 - }, - { - "name": "deficit[25]", - "primal_start": 0.0 - }, - { - "name": "deficit[26]", - "primal_start": 0.0 - }, - { - "name": "deficit[27]", - "primal_start": 0.0 - }, - { - "name": "deficit[28]", - "primal_start": 0.0 - } - ], - "objective": { - "sense": "min", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 6000.0, - "variable": "deficit[1]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[2]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[3]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[4]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[5]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[6]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[7]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[8]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[9]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[10]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[11]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[12]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[13]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[14]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[15]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[16]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[17]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[18]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[19]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[20]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[21]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[22]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[23]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[24]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[25]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[26]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[27]" - }, - { - "coefficient": 6000.0, - "variable": "deficit[28]" - }, - { - "coefficient": 2268.0, - "variable": "0_pg[5]" - }, - { - "coefficient": 2059.0, - "variable": "0_pg[16]" - }, - { - "coefficient": 1780.0, - "variable": "0_pg[20]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[12]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[24]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[28]" - }, - { - "coefficient": 1754.0, - "variable": "0_pg[8]" - }, - { - "coefficient": 2059.0, - "variable": "0_pg[17]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[30]" - }, - { - "coefficient": 1918.0, - "variable": "0_pg[1]" - }, - { - "coefficient": 4244.0, - "variable": "0_pg[23]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[32]" - }, - { - "coefficient": 1517.0, - "variable": "0_pg[22]" - }, - { - "coefficient": 2131.0, - "variable": "0_pg[6]" - }, - { - "coefficient": 1780.0, - "variable": "0_pg[19]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[11]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[31]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[9]" - }, - { - "coefficient": 1404.0, - "variable": "0_pg[14]" - }, - { - "coefficient": 2184.0, - "variable": "0_pg[3]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[29]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[33]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[25]" - }, - { - "coefficient": 1822.0, - "variable": "0_pg[7]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[34]" - }, - { - "coefficient": 2179.0, - "variable": "0_pg[4]" - }, - { - "coefficient": 1404.0, - "variable": "0_pg[13]" - }, - { - "coefficient": 2077.0, - "variable": "0_pg[15]" - }, - { - "coefficient": 2120.0, - "variable": "0_pg[2]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[27]" - }, - { - "coefficient": 1598.0, - "variable": "0_pg[21]" - }, - { - "coefficient": 10.0, - "variable": "0_pg[26]" - }, - { - "coefficient": 1576.0, - "variable": "0_pg[10]" - }, - { - "coefficient": 2059.0, - "variable": "0_pg[18]" - } - ], - "constant": 0.0 - } - }, - "constraints": [ - { - "name": "c1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(5, 5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(6, 5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(4, 5, 4)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(5, 5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(6, 5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(4, 5, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c3", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(20, 16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(22, 16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(19, 16, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(13, 16, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(21, 16, 18)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[16]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.21439096103324617 - } - }, - { - "name": "c4", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(20, 16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(22, 16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(19, 16, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(13, 16, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(21, 16, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.02572691532398954 - } - }, - { - "name": "c5", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(23, 20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(18, 20, 14)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[20]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0015565421870758504 - } - }, - { - "name": "c6", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(23, 20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(18, 20, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.00018678506244910206 - } - }, - { - "name": "c7", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(15, 12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(12, 12, 9)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[12]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.05738794110411041 - } - }, - { - "name": "c8", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(15, 12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(12, 12, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.006886552932493249 - } - }, - { - "name": "c9", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(27, 24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(26, 24, 23)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[24]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.01804043447630477 - } - }, - { - "name": "c10", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(27, 24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(26, 24, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0021648521371565727 - } - }, - { - "name": "c11", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[28]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[30]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[29]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(30, 28, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(31, 28, 19)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[28]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c12", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[28]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[30]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[29]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(30, 28, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(31, 28, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c13", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[25]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(10, 8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(8, 8, 7)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c14", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[25]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(10, 8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(8, 8, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c15", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(29, 17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(20, 17, 16)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[17]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.267753330934522 - } - }, - { - "name": "c16", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(29, 17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(20, 17, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.03213039971214264 - } - }, - { - "name": "c17", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[5]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[8]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[1]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[6]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[9]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[3]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[7]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[4]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[2]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[10]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 2)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.6075543555612704 - } - }, - { - "name": "c18", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[5]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[8]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[1]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[6]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[9]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[3]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[7]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[4]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[2]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[10]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.19290652266735245 - } - }, - { - "name": "c19", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[21]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(26, 23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(25, 23, 22)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[23]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0004825663866386638 - } - }, - { - "name": "c20", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[21]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(26, 23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(25, 23, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -5.790796639663966e-5 - } - }, - { - "name": "c21", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[34]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(25, 22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(24, 22, 21)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[22]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.12074817048704867 - } - }, - { - "name": "c22", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[34]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(25, 22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(24, 22, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.01448978045844584 - } - }, - { - "name": "c23", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[20]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[32]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[19]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[31]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[33]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(30, 19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(31, 19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(22, 19, 16)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[19]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.4735118986170044 - } - }, - { - "name": "c24", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[20]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[32]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[19]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[31]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[33]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(30, 19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(31, 19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(22, 19, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.1768214278340405 - } - }, - { - "name": "c25", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(7, 6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(5, 6, 5)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c26", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(7, 6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(5, 6, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c27", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(14, 11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(6, 11, 5)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c28", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(14, 11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(6, 11, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c29", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[16]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[17]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[15]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[18]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(12, 9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(11, 9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(13, 9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(10, 9, 8)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.21593913974111698 - } - }, - { - "name": "c30", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[16]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[17]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[15]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[18]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(12, 9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(11, 9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(13, 9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(10, 9, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.025912696768934037 - } - }, - { - "name": "c31", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(17, 14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(19, 14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(18, 14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(16, 14, 13)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[14]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c32", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(17, 14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(19, 14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(18, 14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(16, 14, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c33", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[12]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[11]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[14]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[13]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c34", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[12]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[11]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[14]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[13]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c35", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[24]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(8, 7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(9, 7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(7, 7, 6)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c36", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[24]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(8, 7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(9, 7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(7, 7, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c37", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(28, 25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(27, 25, 24)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[25]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0004825663866386638 - } - }, - { - "name": "c38", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(28, 25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(27, 25, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -5.790796639663966e-5 - } - }, - { - "name": "c39", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(4, 4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 4, 3)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.02040724338005229 - } - }, - { - "name": "c40", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(4, 4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 4, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.002448869205606275 - } - }, - { - "name": "c41", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(16, 13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(15, 13, 12)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[13]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.0004825663866386638 - } - }, - { - "name": "c42", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(16, 13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(15, 13, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -5.790796639663966e-5 - } - }, - { - "name": "c43", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(17, 15, 14)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[15]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.10015864047547611 - } - }, - { - "name": "c44", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(17, 15, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.012019036857057132 - } - }, - { - "name": "c45", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(1, 2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c46", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(1, 2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c47", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[27]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(29, 27, 17)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[27]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c48", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[27]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(29, 27, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c49", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(24, 21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(23, 21, 20)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[21]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c50", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(24, 21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(23, 21, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c51", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[23]" - }, - { - "coefficient": -1.0, - "variable": "0_pg[22]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(28, 26, 25)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[26]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.1700922829782978 - } - }, - { - "name": "c52", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[23]" - }, - { - "coefficient": -1.0, - "variable": "0_qg[22]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(28, 26, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.020411073957395734 - } - }, - { - "name": "c53", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[26]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(11, 10, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(9, 10, 7)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.5563327884359863 - } - }, - { - "name": "c54", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[26]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(11, 10, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(9, 10, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -0.06675993461231836 - } - }, - { - "name": "c55", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(21, 18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(14, 18, 11)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[18]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c56", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_q[(21, 18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(14, 18, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c57", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.4213950047523992, - "variable": "0_w[5]" - }, - { - "coefficient": 0.4213950047523992, - "variable": "0_wr[(5, 6)]" - }, - { - "coefficient": -12.485777918589607, - "variable": "0_wi[(5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(5, 5, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c58", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -12.485777918589607, - "variable": "0_w[5]" - }, - { - "coefficient": 12.485777918589607, - "variable": "0_wr[(5, 6)]" - }, - { - "coefficient": 0.4213950047523992, - "variable": "0_wi[(5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(5, 5, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c59", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.4213950047523992, - "variable": "0_w[6]" - }, - { - "coefficient": 0.4213950047523992, - "variable": "0_wr[(5, 6)]" - }, - { - "coefficient": 12.485777918589607, - "variable": "0_wi[(5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(5, 6, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c60", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -12.485777918589607, - "variable": "0_w[6]" - }, - { - "coefficient": 12.485777918589607, - "variable": "0_wr[(5, 6)]" - }, - { - "coefficient": -0.4213950047523992, - "variable": "0_wi[(5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(5, 6, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c61", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.46024690223052, - "variable": "0_w[13]" - }, - { - "coefficient": 2.46024690223052, - "variable": "0_wr[(13, 14)]" - }, - { - "coefficient": -6.795713842466891, - "variable": "0_wi[(13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(16, 13, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c62", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -6.787563842466891, - "variable": "0_w[13]" - }, - { - "coefficient": 6.795713842466891, - "variable": "0_wr[(13, 14)]" - }, - { - "coefficient": 2.46024690223052, - "variable": "0_wi[(13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(16, 13, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c63", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.46024690223052, - "variable": "0_w[14]" - }, - { - "coefficient": 2.46024690223052, - "variable": "0_wr[(13, 14)]" - }, - { - "coefficient": 6.795713842466891, - "variable": "0_wi[(13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(16, 14, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c64", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -6.787563842466891, - "variable": "0_w[14]" - }, - { - "coefficient": 6.795713842466891, - "variable": "0_wr[(13, 14)]" - }, - { - "coefficient": -2.46024690223052, - "variable": "0_wi[(13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(16, 14, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c65", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.7456627284627748, - "variable": "0_w[16]" - }, - { - "coefficient": 0.7456627284627748, - "variable": "0_wr[(16, 17)]" - }, - { - "coefficient": -10.149298248521102, - "variable": "0_wi[(16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(20, 16, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c66", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -10.149298248521102, - "variable": "0_w[16]" - }, - { - "coefficient": 10.149298248521102, - "variable": "0_wr[(16, 17)]" - }, - { - "coefficient": 0.7456627284627748, - "variable": "0_wi[(16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(20, 16, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c67", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.7456627284627748, - "variable": "0_w[17]" - }, - { - "coefficient": 0.7456627284627748, - "variable": "0_wr[(16, 17)]" - }, - { - "coefficient": 10.149298248521102, - "variable": "0_wi[(16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(20, 17, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c68", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -10.149298248521102, - "variable": "0_w[17]" - }, - { - "coefficient": 10.149298248521102, - "variable": "0_wr[(16, 17)]" - }, - { - "coefficient": -0.7456627284627748, - "variable": "0_wi[(16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(20, 17, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c69", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.3473152225768015, - "variable": "0_w[9]" - }, - { - "coefficient": 2.3473152225768015, - "variable": "0_wr[(9, 12)]" - }, - { - "coefficient": -6.481250938450924, - "variable": "0_wi[(9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(12, 9, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c70", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -6.472700938450925, - "variable": "0_w[9]" - }, - { - "coefficient": 6.481250938450924, - "variable": "0_wr[(9, 12)]" - }, - { - "coefficient": 2.3473152225768015, - "variable": "0_wi[(9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(12, 9, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c71", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.3473152225768015, - "variable": "0_w[12]" - }, - { - "coefficient": 2.3473152225768015, - "variable": "0_wr[(9, 12)]" - }, - { - "coefficient": 6.481250938450924, - "variable": "0_wi[(9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(12, 12, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c72", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -6.472700938450925, - "variable": "0_w[12]" - }, - { - "coefficient": 6.481250938450924, - "variable": "0_wr[(9, 12)]" - }, - { - "coefficient": -2.3473152225768015, - "variable": "0_wi[(9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(12, 12, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c73", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.13631367642289954, - "variable": "0_w[21]" - }, - { - "coefficient": 0.13631367642289954, - "variable": "0_wr[(21, 22)]" - }, - { - "coefficient": -4.2328983731321435, - "variable": "0_wi[(21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(24, 21, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c74", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -4.2328983731321435, - "variable": "0_w[21]" - }, - { - "coefficient": 4.2328983731321435, - "variable": "0_wr[(21, 22)]" - }, - { - "coefficient": 0.13631367642289954, - "variable": "0_wi[(21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(24, 21, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c75", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.13631367642289954, - "variable": "0_w[22]" - }, - { - "coefficient": 0.13631367642289954, - "variable": "0_wr[(21, 22)]" - }, - { - "coefficient": 4.2328983731321435, - "variable": "0_wi[(21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(24, 22, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c76", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -4.2328983731321435, - "variable": "0_w[22]" - }, - { - "coefficient": 4.2328983731321435, - "variable": "0_wr[(21, 22)]" - }, - { - "coefficient": -0.13631367642289954, - "variable": "0_wi[(21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(24, 22, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c77", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0916977112407253, - "variable": "0_w[25]" - }, - { - "coefficient": 1.0916977112407253, - "variable": "0_wr[(25, 26)]" - }, - { - "coefficient": -2.091029561081878, - "variable": "0_wi[(25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(28, 25, 26)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c78", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.088179561081878, - "variable": "0_w[25]" - }, - { - "coefficient": 2.091029561081878, - "variable": "0_wr[(25, 26)]" - }, - { - "coefficient": 1.0916977112407253, - "variable": "0_wi[(25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(28, 25, 26)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c79", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0916977112407253, - "variable": "0_w[26]" - }, - { - "coefficient": 1.0916977112407253, - "variable": "0_wr[(25, 26)]" - }, - { - "coefficient": 2.091029561081878, - "variable": "0_wi[(25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(28, 26, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c80", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.088179561081878, - "variable": "0_w[26]" - }, - { - "coefficient": 2.091029561081878, - "variable": "0_wr[(25, 26)]" - }, - { - "coefficient": -1.0916977112407253, - "variable": "0_wi[(25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(28, 26, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c81", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -15.980730481506358, - "variable": "0_w[7]" - }, - { - "coefficient": 15.980730481506358, - "variable": "0_wr[(7, 8)]" - }, - { - "coefficient": -45.39453875906154, - "variable": "0_wi[(7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(8, 7, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c82", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -45.39333875906154, - "variable": "0_w[7]" - }, - { - "coefficient": 45.39453875906154, - "variable": "0_wr[(7, 8)]" - }, - { - "coefficient": 15.980730481506358, - "variable": "0_wi[(7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(8, 7, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c83", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -15.980730481506358, - "variable": "0_w[8]" - }, - { - "coefficient": 15.980730481506358, - "variable": "0_wr[(7, 8)]" - }, - { - "coefficient": 45.39453875906154, - "variable": "0_wi[(7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(8, 8, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c84", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -45.39333875906154, - "variable": "0_w[8]" - }, - { - "coefficient": 45.39453875906154, - "variable": "0_wr[(7, 8)]" - }, - { - "coefficient": -15.980730481506358, - "variable": "0_wi[(7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(8, 8, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c85", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.4325735387749903, - "variable": "0_w[14]" - }, - { - "coefficient": 1.4325735387749903, - "variable": "0_wr[(14, 15)]" - }, - { - "coefficient": -19.8968547052082, - "variable": "0_wi[(14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(17, 14, 15)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c86", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -19.8968547052082, - "variable": "0_w[14]" - }, - { - "coefficient": 19.8968547052082, - "variable": "0_wr[(14, 15)]" - }, - { - "coefficient": 1.4325735387749903, - "variable": "0_wi[(14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(17, 14, 15)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c87", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.4325735387749903, - "variable": "0_w[15]" - }, - { - "coefficient": 1.4325735387749903, - "variable": "0_wr[(14, 15)]" - }, - { - "coefficient": 19.8968547052082, - "variable": "0_wi[(14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(17, 15, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c88", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -19.8968547052082, - "variable": "0_w[15]" - }, - { - "coefficient": 19.8968547052082, - "variable": "0_wr[(14, 15)]" - }, - { - "coefficient": -1.4325735387749903, - "variable": "0_wi[(14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(17, 15, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c89", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8777625235737184, - "variable": "0_w[19]" - }, - { - "coefficient": 0.8777625235737184, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": -9.121944633618186, - "variable": "0_wi[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(30, 19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c90", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -9.097144633618186, - "variable": "0_w[19]" - }, - { - "coefficient": 9.121944633618186, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": 0.8777625235737184, - "variable": "0_wi[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(30, 19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c91", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8777625235737184, - "variable": "0_w[28]" - }, - { - "coefficient": 0.8777625235737184, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": 9.121944633618186, - "variable": "0_wi[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(30, 28, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c92", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -9.097144633618186, - "variable": "0_w[28]" - }, - { - "coefficient": 9.121944633618186, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": -0.8777625235737184, - "variable": "0_wi[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(30, 28, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c93", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.28958087993976717, - "variable": "0_w[2]" - }, - { - "coefficient": 0.28958087993976717, - "variable": "0_wr[(2, 1)]" - }, - { - "coefficient": -9.363115118052471, - "variable": "0_wi[(2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 2, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c94", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -9.363115118052471, - "variable": "0_w[2]" - }, - { - "coefficient": 9.363115118052471, - "variable": "0_wr[(2, 1)]" - }, - { - "coefficient": 0.28958087993976717, - "variable": "0_wi[(2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 2, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c95", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.28958087993976717, - "variable": "0_w[1]" - }, - { - "coefficient": 0.28958087993976717, - "variable": "0_wr[(2, 1)]" - }, - { - "coefficient": 9.363115118052471, - "variable": "0_wi[(2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c96", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -9.363115118052471, - "variable": "0_w[1]" - }, - { - "coefficient": 9.363115118052471, - "variable": "0_wr[(2, 1)]" - }, - { - "coefficient": -0.28958087993976717, - "variable": "0_wi[(2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c97", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.128676282013955, - "variable": "0_w[20]" - }, - { - "coefficient": 1.128676282013955, - "variable": "0_wr[(20, 21)]" - }, - { - "coefficient": -3.33399327650884, - "variable": "0_wi[(20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(23, 20, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c98", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -3.3189932765088397, - "variable": "0_w[20]" - }, - { - "coefficient": 3.33399327650884, - "variable": "0_wr[(20, 21)]" - }, - { - "coefficient": 1.128676282013955, - "variable": "0_wi[(20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(23, 20, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c99", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.128676282013955, - "variable": "0_w[21]" - }, - { - "coefficient": 1.128676282013955, - "variable": "0_wr[(20, 21)]" - }, - { - "coefficient": 3.33399327650884, - "variable": "0_wi[(20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(23, 21, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c100", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -3.3189932765088397, - "variable": "0_w[21]" - }, - { - "coefficient": 3.33399327650884, - "variable": "0_wr[(20, 21)]" - }, - { - "coefficient": -1.128676282013955, - "variable": "0_wi[(20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(23, 21, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c101", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8287243608560181, - "variable": "0_w[16]" - }, - { - "coefficient": 0.8287243608560181, - "variable": "0_wr[(16, 19)]" - }, - { - "coefficient": -2.8140484527509644, - "variable": "0_wi[(16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(22, 16, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c102", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.7777484527509646, - "variable": "0_w[16]" - }, - { - "coefficient": 2.8140484527509644, - "variable": "0_wr[(16, 19)]" - }, - { - "coefficient": 0.8287243608560181, - "variable": "0_wi[(16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(22, 16, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c103", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8287243608560181, - "variable": "0_w[19]" - }, - { - "coefficient": 0.8287243608560181, - "variable": "0_wr[(16, 19)]" - }, - { - "coefficient": 2.8140484527509644, - "variable": "0_wi[(16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(22, 19, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c104", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.7777484527509646, - "variable": "0_w[19]" - }, - { - "coefficient": 2.8140484527509644, - "variable": "0_wr[(16, 19)]" - }, - { - "coefficient": -0.8287243608560181, - "variable": "0_wi[(16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(22, 19, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c105", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.2416585439004273, - "variable": "0_w[14]" - }, - { - "coefficient": 1.2416585439004273, - "variable": "0_wr[(14, 16)]" - }, - { - "coefficient": -3.667991302391842, - "variable": "0_wi[(14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(19, 14, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c106", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -3.654341302391842, - "variable": "0_w[14]" - }, - { - "coefficient": 3.667991302391842, - "variable": "0_wr[(14, 16)]" - }, - { - "coefficient": 1.2416585439004273, - "variable": "0_wi[(14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(19, 14, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c107", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.2416585439004273, - "variable": "0_w[16]" - }, - { - "coefficient": 1.2416585439004273, - "variable": "0_wr[(14, 16)]" - }, - { - "coefficient": 3.667991302391842, - "variable": "0_wi[(14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(19, 16, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c108", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -3.654341302391842, - "variable": "0_w[16]" - }, - { - "coefficient": 3.667991302391842, - "variable": "0_wr[(14, 16)]" - }, - { - "coefficient": -1.2416585439004273, - "variable": "0_wi[(14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(19, 16, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c109", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -3.027806843733998, - "variable": "0_w[5]" - }, - { - "coefficient": 3.027806843733998, - "variable": "0_wr[(5, 11)]" - }, - { - "coefficient": -20.88296190751831, - "variable": "0_wi[(5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(6, 5, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c110", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -20.83991190751831, - "variable": "0_w[5]" - }, - { - "coefficient": 20.88296190751831, - "variable": "0_wr[(5, 11)]" - }, - { - "coefficient": 3.027806843733998, - "variable": "0_wi[(5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(6, 5, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c111", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -3.027806843733998, - "variable": "0_w[11]" - }, - { - "coefficient": 3.027806843733998, - "variable": "0_wr[(5, 11)]" - }, - { - "coefficient": 20.88296190751831, - "variable": "0_wi[(5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(6, 11, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c112", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -20.83991190751831, - "variable": "0_w[11]" - }, - { - "coefficient": 20.88296190751831, - "variable": "0_wr[(5, 11)]" - }, - { - "coefficient": -3.027806843733998, - "variable": "0_wi[(5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(6, 11, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c113", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -17.788682717374634, - "variable": "0_w[9]" - }, - { - "coefficient": 17.788682717374634, - "variable": "0_wr[(9, 10)]" - }, - { - "coefficient": -52.44594387363901, - "variable": "0_wi[(9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(11, 9, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c114", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -52.44499387363901, - "variable": "0_w[9]" - }, - { - "coefficient": 52.44594387363901, - "variable": "0_wr[(9, 10)]" - }, - { - "coefficient": 17.788682717374634, - "variable": "0_wi[(9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(11, 9, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c115", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -17.788682717374634, - "variable": "0_w[10]" - }, - { - "coefficient": 17.788682717374634, - "variable": "0_wr[(9, 10)]" - }, - { - "coefficient": 52.44594387363901, - "variable": "0_wi[(9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(11, 10, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c116", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -52.44499387363901, - "variable": "0_w[10]" - }, - { - "coefficient": 52.44594387363901, - "variable": "0_wr[(9, 10)]" - }, - { - "coefficient": -17.788682717374634, - "variable": "0_wi[(9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(11, 10, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c117", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.9656776626482336, - "variable": "0_w[19]" - }, - { - "coefficient": 0.9656776626482336, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": -5.498037005409949, - "variable": "0_wi[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(31, 19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c118", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -5.487437005409949, - "variable": "0_w[19]" - }, - { - "coefficient": 5.498037005409949, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": 0.9656776626482336, - "variable": "0_wi[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(31, 19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c119", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.9656776626482336, - "variable": "0_w[28]" - }, - { - "coefficient": 0.9656776626482336, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": 5.498037005409949, - "variable": "0_wi[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(31, 28, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c120", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -5.487437005409949, - "variable": "0_w[28]" - }, - { - "coefficient": 5.498037005409949, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": -0.9656776626482336, - "variable": "0_wi[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(31, 28, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c121", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.3418494649701906, - "variable": "0_w[7]" - }, - { - "coefficient": 2.3418494649701906, - "variable": "0_wr[(7, 10)]" - }, - { - "coefficient": -6.467289330533839, - "variable": "0_wi[(7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(9, 7, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c122", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -6.458739330533839, - "variable": "0_w[7]" - }, - { - "coefficient": 6.467289330533839, - "variable": "0_wr[(7, 10)]" - }, - { - "coefficient": 2.3418494649701906, - "variable": "0_wi[(7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(9, 7, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c123", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.3418494649701906, - "variable": "0_w[10]" - }, - { - "coefficient": 2.3418494649701906, - "variable": "0_wr[(7, 10)]" - }, - { - "coefficient": 6.467289330533839, - "variable": "0_wi[(7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(9, 10, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c124", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -6.458739330533839, - "variable": "0_w[10]" - }, - { - "coefficient": 6.467289330533839, - "variable": "0_wr[(7, 10)]" - }, - { - "coefficient": -2.3418494649701906, - "variable": "0_wi[(7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(9, 10, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c125", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.2592269273704175, - "variable": "0_w[11]" - }, - { - "coefficient": 1.2592269273704175, - "variable": "0_wr[(11, 18)]" - }, - { - "coefficient": -8.698708713000553, - "variable": "0_wi[(11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(14, 11, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c126", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -8.595708713000553, - "variable": "0_w[11]" - }, - { - "coefficient": 8.698708713000553, - "variable": "0_wr[(11, 18)]" - }, - { - "coefficient": 1.2592269273704175, - "variable": "0_wi[(11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(14, 11, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c127", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.2592269273704175, - "variable": "0_w[18]" - }, - { - "coefficient": 1.2592269273704175, - "variable": "0_wr[(11, 18)]" - }, - { - "coefficient": 8.698708713000553, - "variable": "0_wi[(11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(14, 18, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c128", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -8.595708713000553, - "variable": "0_w[18]" - }, - { - "coefficient": 8.698708713000553, - "variable": "0_wr[(11, 18)]" - }, - { - "coefficient": -1.2592269273704175, - "variable": "0_wi[(11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(14, 18, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c129", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.5442206253457624, - "variable": "0_w[3]" - }, - { - "coefficient": 2.5442206253457624, - "variable": "0_wr[(3, 4)]" - }, - { - "coefficient": -17.010777436904807, - "variable": "0_wi[(3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 3, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c130", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -16.954277436904807, - "variable": "0_w[3]" - }, - { - "coefficient": 17.010777436904807, - "variable": "0_wr[(3, 4)]" - }, - { - "coefficient": 2.5442206253457624, - "variable": "0_wi[(3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 3, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c131", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.5442206253457624, - "variable": "0_w[4]" - }, - { - "coefficient": 2.5442206253457624, - "variable": "0_wr[(3, 4)]" - }, - { - "coefficient": 17.010777436904807, - "variable": "0_wi[(3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 4, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c132", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -16.954277436904807, - "variable": "0_w[4]" - }, - { - "coefficient": 17.010777436904807, - "variable": "0_wr[(3, 4)]" - }, - { - "coefficient": -2.5442206253457624, - "variable": "0_wi[(3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 4, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c133", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.5382017465334347, - "variable": "0_w[17]" - }, - { - "coefficient": 0.5382017465334347, - "variable": "0_wr[(17, 27)]" - }, - { - "coefficient": -1.6861921183958626, - "variable": "0_wi[(17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(29, 17, 27)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c134", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.6861921183958626, - "variable": "0_w[17]" - }, - { - "coefficient": 1.6861921183958626, - "variable": "0_wr[(17, 27)]" - }, - { - "coefficient": 0.5382017465334347, - "variable": "0_wi[(17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(29, 17, 27)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c135", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.5382017465334347, - "variable": "0_w[27]" - }, - { - "coefficient": 0.5382017465334347, - "variable": "0_wr[(17, 27)]" - }, - { - "coefficient": 1.6861921183958626, - "variable": "0_wi[(17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(29, 27, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c136", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.6861921183958626, - "variable": "0_w[27]" - }, - { - "coefficient": 1.6861921183958626, - "variable": "0_wr[(17, 27)]" - }, - { - "coefficient": -0.5382017465334347, - "variable": "0_wi[(17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(29, 27, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c137", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -10.614654857863137, - "variable": "0_w[6]" - }, - { - "coefficient": 10.614654857863137, - "variable": "0_wr[(6, 7)]" - }, - { - "coefficient": -31.512256609281188, - "variable": "0_wi[(6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(7, 6, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c138", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -31.510656609281188, - "variable": "0_w[6]" - }, - { - "coefficient": 31.512256609281188, - "variable": "0_wr[(6, 7)]" - }, - { - "coefficient": 10.614654857863137, - "variable": "0_wi[(6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(7, 6, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c139", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -10.614654857863137, - "variable": "0_w[7]" - }, - { - "coefficient": 10.614654857863137, - "variable": "0_wr[(6, 7)]" - }, - { - "coefficient": 31.512256609281188, - "variable": "0_wi[(6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(7, 7, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c140", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -31.510656609281188, - "variable": "0_w[7]" - }, - { - "coefficient": 31.512256609281188, - "variable": "0_wr[(6, 7)]" - }, - { - "coefficient": -10.614654857863137, - "variable": "0_wi[(6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(7, 7, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c141", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -4.66785040912336, - "variable": "0_w[22]" - }, - { - "coefficient": 4.66785040912336, - "variable": "0_wr[(22, 23)]" - }, - { - "coefficient": -8.939086077602251, - "variable": "0_wi[(22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(25, 22, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c142", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -8.938436077602251, - "variable": "0_w[22]" - }, - { - "coefficient": 8.939086077602251, - "variable": "0_wr[(22, 23)]" - }, - { - "coefficient": 4.66785040912336, - "variable": "0_wi[(22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(25, 22, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c143", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -4.66785040912336, - "variable": "0_w[23]" - }, - { - "coefficient": 4.66785040912336, - "variable": "0_wr[(22, 23)]" - }, - { - "coefficient": 8.939086077602251, - "variable": "0_wi[(22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(25, 23, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c144", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -8.938436077602251, - "variable": "0_w[23]" - }, - { - "coefficient": 8.939086077602251, - "variable": "0_wr[(22, 23)]" - }, - { - "coefficient": -4.66785040912336, - "variable": "0_wi[(22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(25, 23, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c145", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.434853977156145, - "variable": "0_w[4]" - }, - { - "coefficient": 2.434853977156145, - "variable": "0_wr[(4, 5)]" - }, - { - "coefficient": -16.36003009370084, - "variable": "0_wi[(4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(4, 4, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c146", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -16.30153009370084, - "variable": "0_w[4]" - }, - { - "coefficient": 16.36003009370084, - "variable": "0_wr[(4, 5)]" - }, - { - "coefficient": 2.434853977156145, - "variable": "0_wi[(4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(4, 4, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c147", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.434853977156145, - "variable": "0_w[5]" - }, - { - "coefficient": 2.434853977156145, - "variable": "0_wr[(4, 5)]" - }, - { - "coefficient": 16.36003009370084, - "variable": "0_wi[(4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(4, 5, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c148", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -16.30153009370084, - "variable": "0_w[5]" - }, - { - "coefficient": 16.36003009370084, - "variable": "0_wr[(4, 5)]" - }, - { - "coefficient": -2.434853977156145, - "variable": "0_wi[(4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(4, 5, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c149", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.64335500582701, - "variable": "0_w[9]" - }, - { - "coefficient": 0.64335500582701, - "variable": "0_wr[(9, 16)]" - }, - { - "coefficient": -1.8998888915041532, - "variable": "0_wi[(9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(13, 9, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c150", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.8735888915041532, - "variable": "0_w[9]" - }, - { - "coefficient": 1.8998888915041532, - "variable": "0_wr[(9, 16)]" - }, - { - "coefficient": 0.64335500582701, - "variable": "0_wi[(9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(13, 9, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c151", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.64335500582701, - "variable": "0_w[16]" - }, - { - "coefficient": 0.64335500582701, - "variable": "0_wr[(9, 16)]" - }, - { - "coefficient": 1.8998888915041532, - "variable": "0_wi[(9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(13, 16, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c152", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.8735888915041532, - "variable": "0_w[16]" - }, - { - "coefficient": 1.8998888915041532, - "variable": "0_wr[(9, 16)]" - }, - { - "coefficient": -0.64335500582701, - "variable": "0_wi[(9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(13, 16, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c153", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.5424832182137913, - "variable": "0_w[12]" - }, - { - "coefficient": 2.5424832182137913, - "variable": "0_wr[(12, 13)]" - }, - { - "coefficient": -7.029547007720768, - "variable": "0_wi[(12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(15, 12, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c154", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -7.021647007720768, - "variable": "0_w[12]" - }, - { - "coefficient": 7.029547007720768, - "variable": "0_wr[(12, 13)]" - }, - { - "coefficient": 2.5424832182137913, - "variable": "0_wi[(12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(15, 12, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c155", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.5424832182137913, - "variable": "0_w[13]" - }, - { - "coefficient": 2.5424832182137913, - "variable": "0_wr[(12, 13)]" - }, - { - "coefficient": 7.029547007720768, - "variable": "0_wi[(12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(15, 13, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c156", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -7.021647007720768, - "variable": "0_w[13]" - }, - { - "coefficient": 7.029547007720768, - "variable": "0_wr[(12, 13)]" - }, - { - "coefficient": -2.5424832182137913, - "variable": "0_wi[(12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(15, 13, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c157", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.070955528571676, - "variable": "0_w[2]" - }, - { - "coefficient": 1.070955528571676, - "variable": "0_wr[(2, 3)]" - }, - { - "coefficient": -7.165952433825185, - "variable": "0_wi[(2, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c158", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -7.031952433825185, - "variable": "0_w[2]" - }, - { - "coefficient": 7.165952433825185, - "variable": "0_wr[(2, 3)]" - }, - { - "coefficient": 1.070955528571676, - "variable": "0_wi[(2, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c159", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.070955528571676, - "variable": "0_w[3]" - }, - { - "coefficient": 1.070955528571676, - "variable": "0_wr[(2, 3)]" - }, - { - "coefficient": 7.165952433825185, - "variable": "0_wi[(2, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c160", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -7.031952433825185, - "variable": "0_w[3]" - }, - { - "coefficient": 7.165952433825185, - "variable": "0_wr[(2, 3)]" - }, - { - "coefficient": -1.070955528571676, - "variable": "0_wi[(2, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c161", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.4978494338705233, - "variable": "0_w[24]" - }, - { - "coefficient": 1.4978494338705233, - "variable": "0_wr[(24, 25)]" - }, - { - "coefficient": -2.868957761798156, - "variable": "0_wi[(24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(27, 24, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c162", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.866907761798156, - "variable": "0_w[24]" - }, - { - "coefficient": 2.868957761798156, - "variable": "0_wr[(24, 25)]" - }, - { - "coefficient": 1.4978494338705233, - "variable": "0_wi[(24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(27, 24, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c163", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.4978494338705233, - "variable": "0_w[25]" - }, - { - "coefficient": 1.4978494338705233, - "variable": "0_wr[(24, 25)]" - }, - { - "coefficient": 2.868957761798156, - "variable": "0_wi[(24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(27, 25, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c164", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.866907761798156, - "variable": "0_w[25]" - }, - { - "coefficient": 2.868957761798156, - "variable": "0_wr[(24, 25)]" - }, - { - "coefficient": -1.4978494338705233, - "variable": "0_wi[(24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(27, 25, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c165", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.26161249681590054, - "variable": "0_w[18]" - }, - { - "coefficient": 0.26161249681590054, - "variable": "0_wr[(18, 16)]" - }, - { - "coefficient": -11.73125512037617, - "variable": "0_wi[(18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(21, 18, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c166", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -11.73125512037617, - "variable": "0_w[18]" - }, - { - "coefficient": 11.73125512037617, - "variable": "0_wr[(18, 16)]" - }, - { - "coefficient": 0.26161249681590054, - "variable": "0_wi[(18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(21, 18, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c167", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.26161249681590054, - "variable": "0_w[16]" - }, - { - "coefficient": 0.26161249681590054, - "variable": "0_wr[(18, 16)]" - }, - { - "coefficient": 11.73125512037617, - "variable": "0_wi[(18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(21, 16, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c168", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -11.73125512037617, - "variable": "0_w[16]" - }, - { - "coefficient": 11.73125512037617, - "variable": "0_wr[(18, 16)]" - }, - { - "coefficient": -0.26161249681590054, - "variable": "0_wi[(18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(21, 16, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c169", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.9263284811715553, - "variable": "0_w[23]" - }, - { - "coefficient": 2.9263284811715553, - "variable": "0_wr[(23, 24)]" - }, - { - "coefficient": -5.604798539074481, - "variable": "0_wi[(23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(26, 23, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c170", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -5.603748539074481, - "variable": "0_w[23]" - }, - { - "coefficient": 5.604798539074481, - "variable": "0_wr[(23, 24)]" - }, - { - "coefficient": 2.9263284811715553, - "variable": "0_wi[(23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(26, 23, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c171", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.9263284811715553, - "variable": "0_w[24]" - }, - { - "coefficient": 2.9263284811715553, - "variable": "0_wr[(23, 24)]" - }, - { - "coefficient": 5.604798539074481, - "variable": "0_wi[(23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(26, 24, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c172", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -5.603748539074481, - "variable": "0_w[24]" - }, - { - "coefficient": 5.604798539074481, - "variable": "0_wr[(23, 24)]" - }, - { - "coefficient": -2.9263284811715553, - "variable": "0_wi[(23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(26, 24, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c173", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.450918029773461, - "variable": "0_w[8]" - }, - { - "coefficient": 2.450918029773461, - "variable": "0_wr[(8, 9)]" - }, - { - "coefficient": -6.776372942488066, - "variable": "0_wi[(8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(10, 8, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c174", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -6.768172942488065, - "variable": "0_w[8]" - }, - { - "coefficient": 6.776372942488066, - "variable": "0_wr[(8, 9)]" - }, - { - "coefficient": 2.450918029773461, - "variable": "0_wi[(8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(10, 8, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c175", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.450918029773461, - "variable": "0_w[9]" - }, - { - "coefficient": 2.450918029773461, - "variable": "0_wr[(8, 9)]" - }, - { - "coefficient": 6.776372942488066, - "variable": "0_wi[(8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(10, 9, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c176", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -6.768172942488065, - "variable": "0_w[9]" - }, - { - "coefficient": 6.776372942488066, - "variable": "0_wr[(8, 9)]" - }, - { - "coefficient": -2.450918029773461, - "variable": "0_wi[(8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(10, 9, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c177", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.9733135131308841, - "variable": "0_w[14]" - }, - { - "coefficient": 0.9733135131308841, - "variable": "0_wr[(14, 20)]" - }, - { - "coefficient": -2.875699016068521, - "variable": "0_wi[(14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(18, 14, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c178", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.8582990160685213, - "variable": "0_w[14]" - }, - { - "coefficient": 2.875699016068521, - "variable": "0_wr[(14, 20)]" - }, - { - "coefficient": 0.9733135131308841, - "variable": "0_wi[(14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(18, 14, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c179", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.9733135131308841, - "variable": "0_w[20]" - }, - { - "coefficient": 0.9733135131308841, - "variable": "0_wr[(14, 20)]" - }, - { - "coefficient": 2.875699016068521, - "variable": "0_wi[(14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(18, 20, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c180", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -2.8582990160685213, - "variable": "0_w[20]" - }, - { - "coefficient": 2.875699016068521, - "variable": "0_wr[(14, 20)]" - }, - { - "coefficient": -0.9733135131308841, - "variable": "0_wi[(14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(18, 20, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[1]" - }, - { - "coefficient": -0.0036, - "variable": "outflow[2]" - }, - { - "coefficient": 1.0, - "variable": "spill[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[2]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[2]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[2]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[2]" - }, - { - "coefficient": 1.0, - "variable": "spill[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[3]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[3]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[3]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[3]" - }, - { - "coefficient": 1.0, - "variable": "spill[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[4]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[4]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[4]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[4]" - }, - { - "coefficient": 1.0, - "variable": "spill[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[5]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[5]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[5]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[5]" - }, - { - "coefficient": 1.0, - "variable": "spill[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[6]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[6]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[6]_out" - }, - { - "coefficient": -0.0036, - "variable": "outflow[5]" - }, - { - "coefficient": 0.0036, - "variable": "outflow[6]" - }, - { - "coefficient": -1.0, - "variable": "spill[5]" - }, - { - "coefficient": 1.0, - "variable": "spill[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[7]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[7]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[7]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[7]" - }, - { - "coefficient": 1.0, - "variable": "spill[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[8]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[8]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[8]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[8]" - }, - { - "coefficient": 1.0, - "variable": "spill[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[9]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[9]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[9]_out" - }, - { - "coefficient": -0.0036, - "variable": "outflow[8]" - }, - { - "coefficient": 0.0036, - "variable": "outflow[9]" - }, - { - "coefficient": -1.0, - "variable": "spill[8]" - }, - { - "coefficient": 1.0, - "variable": "spill[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[10]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[10]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[10]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[10]" - }, - { - "coefficient": 1.0, - "variable": "spill[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "hydro_balance[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[11]_in" - }, - { - "coefficient": -0.0036, - "variable": "inflow[11]" - }, - { - "coefficient": 1.0, - "variable": "reservoir[11]_out" - }, - { - "coefficient": 0.0036, - "variable": "outflow[11]" - }, - { - "coefficient": 1.0, - "variable": "spill[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[24]" - }, - { - "coefficient": -6.9953, - "variable": "outflow[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[25]" - }, - { - "coefficient": -5.117, - "variable": "outflow[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[26]" - }, - { - "coefficient": -9.677, - "variable": "outflow[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[27]" - }, - { - "coefficient": -5.06, - "variable": "outflow[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[28]" - }, - { - "coefficient": -8.11, - "variable": "outflow[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[29]" - }, - { - "coefficient": -6.35, - "variable": "outflow[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[30]" - }, - { - "coefficient": -3.2, - "variable": "outflow[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[31]" - }, - { - "coefficient": -4.81, - "variable": "outflow[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[32]" - }, - { - "coefficient": -4.47, - "variable": "outflow[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[33]" - }, - { - "coefficient": -1.2, - "variable": "outflow[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[34]" - }, - { - "coefficient": -2.5, - "variable": "outflow[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c1_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(5, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c2_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[5]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[6]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(5, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c3_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[5]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[6]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(5, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c4_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(13, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c5_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[14]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[13]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(13, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c6_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[14]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[13]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(13, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c7_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(16, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c8_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[16]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[17]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(16, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c9_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[16]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[17]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(16, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c10_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(9, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c11_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[12]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[9]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(9, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c12_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[12]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[9]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(9, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c13_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(21, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c14_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[22]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[21]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(21, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c15_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[22]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[21]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(21, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c16_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(25, 26)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c17_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[25]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[26]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(25, 26)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c18_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[25]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[26]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(25, 26)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c19_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(7, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c20_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[8]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[7]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(7, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c21_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[8]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[7]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(7, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c22_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(14, 15)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c23_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[14]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[15]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(14, 15)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c24_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[14]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[15]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(14, 15)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c25_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c26_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[28]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[19]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c27_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[28]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[19]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c28_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(2, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c29_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[1]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[2]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(2, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c30_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[1]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[2]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(2, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c31_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(20, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c32_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[20]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[21]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(20, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c33_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[20]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[21]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(20, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c34_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(16, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c35_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[16]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[19]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(16, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c36_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[16]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[19]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(16, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c37_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(14, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c38_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[16]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[14]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(14, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c39_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[16]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[14]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(14, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c40_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(5, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c41_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[5]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[11]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(5, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c42_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[5]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[11]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(5, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c43_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(9, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c44_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[9]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[10]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(9, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c45_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[9]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[10]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(9, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c46_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(7, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c47_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[7]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[10]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(7, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c48_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[7]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[10]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(7, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c49_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(11, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c50_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[11]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[18]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(11, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c51_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[11]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[18]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(11, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c52_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(3, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c53_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[3]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[4]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(3, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c54_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[3]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[4]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(3, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c55_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(17, 27)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c56_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[17]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[27]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(17, 27)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c57_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[17]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[27]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(17, 27)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c58_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(6, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c59_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[6]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[7]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(6, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c60_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[6]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[7]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(6, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c61_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(22, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c62_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[23]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[22]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(22, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c63_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[23]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[22]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(22, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c64_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(4, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c65_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[5]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[4]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(4, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c66_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[5]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[4]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(4, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c67_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(9, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c68_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[16]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[9]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(9, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c69_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[16]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[9]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(9, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c70_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(12, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c71_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[12]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[13]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(12, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c72_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[12]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[13]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(12, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c73_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(2, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c74_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[3]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[2]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c75_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[3]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[2]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c76_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(24, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c77_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[24]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[25]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(24, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c78_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[24]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[25]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(24, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c79_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(18, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c80_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[16]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[18]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(18, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c81_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[16]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[18]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(18, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c82_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(23, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c83_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[24]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[23]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(23, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c84_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[24]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[23]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(23, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c85_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(8, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c86_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[8]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[9]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(8, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c87_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[8]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[9]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(8, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c88_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(14, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c89_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[20]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[14]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(14, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c90_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[20]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[14]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(14, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "min_volume_violation_bound[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[1]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[2]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[3]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[4]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[5]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[6]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[7]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[8]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[9]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[10]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_volume_violation_bound[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "reservoir[11]_out" - }, - { - "coefficient": 1.0, - "variable": "min_volume_violation[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[2]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[2]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[3]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[3]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[4]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[4]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[4]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[5]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[5]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[5]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[6]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[6]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[6]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[7]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[7]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[7]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[8]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[8]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[8]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[9]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[9]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[9]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[10]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[10]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[10]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "min_outflow_violation_bound[11]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[11]" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[11]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c1_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(5, 6)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(5, 6)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c2_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(13, 14)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(13, 14)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c3_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(16, 17)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(16, 17)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c4_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(9, 12)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(9, 12)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c5_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(21, 22)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(21, 22)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c6_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(25, 26)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(25, 26)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c7_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(7, 8)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(7, 8)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c8_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(14, 15)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(14, 15)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c9_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(19, 28)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(19, 28)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c10_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(2, 1)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(2, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c11_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(20, 21)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(20, 21)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c12_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(16, 19)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(16, 19)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c13_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(14, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(14, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c14_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(5, 11)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(5, 11)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c15_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(9, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(9, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c16_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(7, 10)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(7, 10)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c17_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(11, 18)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(11, 18)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c18_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(3, 4)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(3, 4)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c19_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(17, 27)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(17, 27)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c20_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(6, 7)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(6, 7)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c21_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(22, 23)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(22, 23)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c22_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(4, 5)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(4, 5)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c23_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(9, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(9, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c24_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(12, 13)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(12, 13)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c25_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(2, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c26_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(24, 25)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(24, 25)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c27_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(18, 16)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(18, 16)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c28_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(23, 24)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(23, 24)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c29_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(8, 9)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(8, 9)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c30_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(14, 20)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(14, 20)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c1_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(5, 5, 6)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(5, 5, 6)]" - } - } - ], - "constants": [ - 0.7, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c2_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(5, 6, 5)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(5, 6, 5)]" - } - } - ], - "constants": [ - 0.7, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c3_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(16, 13, 14)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(16, 13, 14)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c4_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(16, 14, 13)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(16, 14, 13)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c5_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(20, 16, 17)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(20, 16, 17)]" - } - } - ], - "constants": [ - 0.25, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c6_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(20, 17, 16)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(20, 17, 16)]" - } - } - ], - "constants": [ - 0.25, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c7_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(12, 9, 12)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(12, 9, 12)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c8_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(12, 12, 9)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(12, 12, 9)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c9_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(24, 21, 22)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(24, 21, 22)]" - } - } - ], - "constants": [ - 0.25, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c10_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(24, 22, 21)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(24, 22, 21)]" - } - } - ], - "constants": [ - 0.25, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c11_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(28, 25, 26)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(28, 25, 26)]" - } - } - ], - "constants": [ - 0.13, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c12_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(28, 26, 25)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(28, 26, 25)]" - } - } - ], - "constants": [ - 0.13, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c13_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(8, 7, 8)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(8, 7, 8)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c14_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(8, 8, 7)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(8, 8, 7)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c15_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(17, 14, 15)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(17, 14, 15)]" - } - } - ], - "constants": [ - 0.5, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c16_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(17, 15, 14)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(17, 15, 14)]" - } - } - ], - "constants": [ - 0.5, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c17_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(30, 19, 28)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(30, 19, 28)]" - } - } - ], - "constants": [ - 1.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c18_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(30, 28, 19)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(30, 28, 19)]" - } - } - ], - "constants": [ - 1.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c19_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(1, 2, 1)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(1, 2, 1)]" - } - } - ], - "constants": [ - 0.7, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c20_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 2)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 2)]" - } - } - ], - "constants": [ - 0.7, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c21_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(23, 20, 21)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(23, 20, 21)]" - } - } - ], - "constants": [ - 0.47, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c22_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(23, 21, 20)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(23, 21, 20)]" - } - } - ], - "constants": [ - 0.47, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c23_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(22, 16, 19)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(22, 16, 19)]" - } - } - ], - "constants": [ - 1.06, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c24_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(22, 19, 16)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(22, 19, 16)]" - } - } - ], - "constants": [ - 1.06, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c25_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(19, 14, 16)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(19, 14, 16)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c26_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(19, 16, 14)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(19, 16, 14)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c27_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(6, 5, 11)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(6, 5, 11)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c28_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(6, 11, 5)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(6, 11, 5)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c29_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(11, 9, 10)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(11, 9, 10)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c30_3", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(11, 10, 9)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(11, 10, 9)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c31_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(31, 19, 28)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(31, 19, 28)]" - } - } - ], - "constants": [ - 1.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c32_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(31, 28, 19)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(31, 28, 19)]" - } - } - ], - "constants": [ - 1.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c33_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(9, 7, 10)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(9, 7, 10)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c34_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(9, 10, 7)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(9, 10, 7)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c35_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(14, 11, 18)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(14, 11, 18)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c36_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(14, 18, 11)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(14, 18, 11)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c37_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(3, 3, 4)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(3, 3, 4)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c38_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(3, 4, 3)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(3, 4, 3)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c39_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(29, 17, 27)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(29, 17, 27)]" - } - } - ], - "constants": [ - 2.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c40_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(29, 27, 17)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(29, 27, 17)]" - } - } - ], - "constants": [ - 2.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c41_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(7, 6, 7)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(7, 6, 7)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c42_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(7, 7, 6)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(7, 7, 6)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c43_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(25, 22, 23)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(25, 22, 23)]" - } - } - ], - "constants": [ - 0.33, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c44_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(25, 23, 22)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(25, 23, 22)]" - } - } - ], - "constants": [ - 0.33, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c45_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(4, 4, 5)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(4, 4, 5)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c46_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(4, 5, 4)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(4, 5, 4)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c47_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(13, 9, 16)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(13, 9, 16)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c48_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(13, 16, 9)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(13, 16, 9)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c49_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(15, 12, 13)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(15, 12, 13)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c50_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(15, 13, 12)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(15, 13, 12)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c51_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c52_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]" - } - } - ], - "constants": [ - 1.3, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c53_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(27, 24, 25)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(27, 24, 25)]" - } - } - ], - "constants": [ - 0.13, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c54_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(27, 25, 24)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(27, 25, 24)]" - } - } - ], - "constants": [ - 0.13, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c55_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(21, 18, 16)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(21, 18, 16)]" - } - } - ], - "constants": [ - 1.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c56_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(21, 16, 18)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(21, 16, 18)]" - } - } - ], - "constants": [ - 1.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c57_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(26, 23, 24)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(26, 23, 24)]" - } - } - ], - "constants": [ - 0.13, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c58_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(26, 24, 23)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(26, 24, 23)]" - } - } - ], - "constants": [ - 0.13, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c59_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(10, 8, 9)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(10, 8, 9)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c60_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(10, 9, 8)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(10, 9, 8)]" - } - } - ], - "constants": [ - 0.74, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c61_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(18, 14, 20)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(18, 14, 20)]" - } - } - ], - "constants": [ - 0.47, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c62_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(18, 20, 14)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(18, 20, 14)]" - } - } - ], - "constants": [ - 0.47, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c1_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[18]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[16]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(18, 16)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(18, 16)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c2_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[19]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[28]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(19, 28)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(19, 28)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c3_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[11]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[18]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(11, 18)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(11, 18)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c4_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[4]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[5]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(4, 5)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(4, 5)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c5_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[23]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[24]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(23, 24)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(23, 24)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c6_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[12]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[13]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(12, 13)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(12, 13)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c7_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[9]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[10]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(9, 10)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(9, 10)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c8_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[9]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[12]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(9, 12)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(9, 12)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c9_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[25]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[26]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(25, 26)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(25, 26)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c10_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[7]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[8]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(7, 8)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(7, 8)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c11_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[21]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[22]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(21, 22)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(21, 22)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c12_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[5]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[11]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(5, 11)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(5, 11)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c13_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[14]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[15]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(14, 15)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(14, 15)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c14_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[7]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[10]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(7, 10)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(7, 10)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c15_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[8]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[9]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(8, 9)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(8, 9)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c16_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[5]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[6]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(5, 6)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(5, 6)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c17_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[2]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[1]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(2, 1)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(2, 1)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c18_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[3]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[4]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(3, 4)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(3, 4)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c19_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[9]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[16]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(9, 16)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(9, 16)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c20_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[14]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[20]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(14, 20)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(14, 20)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c21_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[16]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[19]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(16, 19)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(16, 19)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c22_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[14]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[16]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(14, 16)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(14, 16)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c23_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[2]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[3]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(2, 3)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(2, 3)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c24_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[16]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[17]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(16, 17)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(16, 17)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c25_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[24]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[25]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(24, 25)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(24, 25)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c26_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[13]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[14]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(13, 14)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(13, 14)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c27_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[22]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[23]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(22, 23)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(22, 23)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c28_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[6]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[7]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(6, 7)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(6, 7)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c29_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[20]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[21]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(20, 21)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(20, 21)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "name": "c30_4", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 1, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[17]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[27]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(17, 27)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(17, 27)]" - } - } - ], - "constants": [ - 0.0, - 0.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "RotatedSecondOrderCone", - "dimension": 4 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[2]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[3]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[4]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[5]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[6]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[7]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[8]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[9]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[10]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[11]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[1]" - }, - "set": { - "type": "EqualTo", - "value": 0.9398527488038416 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[2]" - }, - "set": { - "type": "EqualTo", - "value": 5.882002148039282 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[3]" - }, - "set": { - "type": "EqualTo", - "value": 0.2000144671649994 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[4]" - }, - "set": { - "type": "EqualTo", - "value": 3.9469358129786256 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[5]" - }, - "set": { - "type": "EqualTo", - "value": 6.211844156821933 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[6]" - }, - "set": { - "type": "EqualTo", - "value": 10.23842397764487 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[7]" - }, - "set": { - "type": "EqualTo", - "value": 0.1869794681093533 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[8]" - }, - "set": { - "type": "EqualTo", - "value": 10.477704945568126 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[9]" - }, - "set": { - "type": "EqualTo", - "value": 8.449733976255288 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[10]" - }, - "set": { - "type": "EqualTo", - "value": 1.4824946743419087 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[11]" - }, - "set": { - "type": "EqualTo", - "value": 3.37887731734589 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[16]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[20]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[12]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[24]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[28]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[17]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[23]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[22]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[19]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[14]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[25]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[13]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[15]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[27]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[21]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[26]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[18]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(18, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(11, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(4, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(23, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(12, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(9, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(9, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(25, 26)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(7, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(21, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(5, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(14, 15)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(7, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(8, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(5, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(2, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(3, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(9, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(14, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(16, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(14, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(2, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(16, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(24, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(13, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(22, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(6, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(20, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(17, 27)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(18, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(11, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(4, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(23, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(12, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(9, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(9, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(25, 26)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(7, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(21, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(5, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(14, 15)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(7, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(8, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(5, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(2, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(3, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(9, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(14, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(16, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(14, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(2, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(16, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(24, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(13, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(22, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(6, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(20, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(17, 27)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[16]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[20]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[12]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[24]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[28]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[17]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[30]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[23]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[32]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[22]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[19]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[31]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[14]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[29]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[33]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[25]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[34]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[13]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[15]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[27]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[21]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[26]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[18]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[5]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[16]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[20]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[12]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[24]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[28]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[8]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[17]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[30]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[23]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[32]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[22]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[6]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[19]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[11]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[31]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[9]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[14]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[29]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[33]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[25]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[7]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[34]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[4]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[13]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[15]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[27]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[21]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[26]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[10]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[18]" - }, - "set": { - "type": "GreaterThan", - "lower": -999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 5, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 13, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 16, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 9, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 21, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 25, 26)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 7, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 14, 15)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 2, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 20, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 16, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 14, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 5, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 9, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 7, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 11, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 3, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 17, 27)]" - }, - "set": { - "type": "GreaterThan", - "lower": -2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 6, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 22, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 4, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 9, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 12, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 24, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 18, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 23, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 8, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 14, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 6, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 14, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 17, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 12, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 22, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 26, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 8, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 15, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 28, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 21, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 19, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 16, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 11, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 10, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 28, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 10, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 18, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 4, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 27, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 7, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 23, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 5, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 16, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 13, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 25, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 16, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 24, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 9, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 20, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(5, 5, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(16, 13, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(20, 16, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(12, 9, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(24, 21, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(28, 25, 26)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(8, 7, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(17, 14, 15)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(30, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 2, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(23, 20, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(22, 16, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(19, 14, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(6, 5, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(11, 9, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(31, 19, 28)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(9, 7, 10)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(14, 11, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 3, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(29, 17, 27)]" - }, - "set": { - "type": "GreaterThan", - "lower": -2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(7, 6, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(25, 22, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(4, 4, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(13, 9, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(15, 12, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(27, 24, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(21, 18, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(26, 23, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(10, 8, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(18, 14, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(5, 6, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(16, 14, 13)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(20, 17, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(12, 12, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(24, 22, 21)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(28, 26, 25)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(8, 8, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(17, 15, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(30, 28, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(23, 21, 20)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(22, 19, 16)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(19, 16, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(6, 11, 5)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(11, 10, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(31, 28, 19)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(9, 10, 7)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(14, 18, 11)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 4, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(29, 27, 17)]" - }, - "set": { - "type": "GreaterThan", - "lower": -2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(7, 7, 6)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(25, 23, 22)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(4, 5, 4)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(13, 16, 9)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(15, 13, 12)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(27, 25, 24)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(21, 16, 18)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(26, 24, 23)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(10, 9, 8)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(18, 20, 14)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[2]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[3]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[4]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[5]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[6]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[7]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[8]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[9]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[10]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[11]_out" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[4]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[5]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[6]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[7]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[8]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[9]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[10]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[11]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[12]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[13]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[14]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[15]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[16]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[17]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[18]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[19]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[20]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[21]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[22]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[23]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[24]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[25]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[26]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[27]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[28]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[5]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[16]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[20]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[12]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[24]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[28]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[8]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[17]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[1]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[23]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[22]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[19]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[6]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[11]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[9]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[14]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[3]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[7]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[25]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[4]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[13]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[15]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[2]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[27]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[21]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[26]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[10]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[18]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(18, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(11, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(4, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(23, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(12, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(9, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(9, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(25, 26)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(7, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(21, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(5, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(14, 15)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(7, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(8, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(5, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(2, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(3, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(9, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(14, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(16, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(14, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(2, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(16, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(24, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(13, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(22, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(6, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(20, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(17, 27)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(18, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(11, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(4, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(23, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(12, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(9, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(9, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(25, 26)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(7, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(21, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(5, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(14, 15)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(7, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(8, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(5, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(2, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(3, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(9, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(14, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(16, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(14, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(2, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(16, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(24, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(13, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(22, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(6, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(20, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(17, 27)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[5]" - }, - "set": { - "type": "LessThan", - "upper": 0.153 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[16]" - }, - "set": { - "type": "LessThan", - "upper": 0.149 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[20]" - }, - "set": { - "type": "LessThan", - "upper": 0.07339999999999999 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[12]" - }, - "set": { - "type": "LessThan", - "upper": 0.3381 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[24]" - }, - "set": { - "type": "LessThan", - "upper": 0.72 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[28]" - }, - "set": { - "type": "LessThan", - "upper": 0.7090000000000001 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[8]" - }, - "set": { - "type": "LessThan", - "upper": 0.1888 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[17]" - }, - "set": { - "type": "LessThan", - "upper": 0.149 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[30]" - }, - "set": { - "type": "LessThan", - "upper": 0.04 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]" - }, - "set": { - "type": "LessThan", - "upper": 0.1826 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[23]" - }, - "set": { - "type": "LessThan", - "upper": 0.10800000000000001 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[32]" - }, - "set": { - "type": "LessThan", - "upper": 0.4917 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[22]" - }, - "set": { - "type": "LessThan", - "upper": 0.1494 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[6]" - }, - "set": { - "type": "LessThan", - "upper": 0.1696 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[19]" - }, - "set": { - "type": "LessThan", - "upper": 0.07339999999999999 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[11]" - }, - "set": { - "type": "LessThan", - "upper": 0.3381 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[31]" - }, - "set": { - "type": "LessThan", - "upper": 0.3367 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[9]" - }, - "set": { - "type": "LessThan", - "upper": 0.5175 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[14]" - }, - "set": { - "type": "LessThan", - "upper": 0.4497 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]" - }, - "set": { - "type": "LessThan", - "upper": 0.1523 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[29]" - }, - "set": { - "type": "LessThan", - "upper": 1.08 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[33]" - }, - "set": { - "type": "LessThan", - "upper": 0.0101 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[25]" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[7]" - }, - "set": { - "type": "LessThan", - "upper": 0.1757 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[34]" - }, - "set": { - "type": "LessThan", - "upper": 0.081 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[4]" - }, - "set": { - "type": "LessThan", - "upper": 0.1623 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[13]" - }, - "set": { - "type": "LessThan", - "upper": 0.4497 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[15]" - }, - "set": { - "type": "LessThan", - "upper": 0.1483 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]" - }, - "set": { - "type": "LessThan", - "upper": 0.1593 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[27]" - }, - "set": { - "type": "LessThan", - "upper": 0.184 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[21]" - }, - "set": { - "type": "LessThan", - "upper": 0.1134 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[26]" - }, - "set": { - "type": "LessThan", - "upper": 0.076 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[10]" - }, - "set": { - "type": "LessThan", - "upper": 0.5175 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[18]" - }, - "set": { - "type": "LessThan", - "upper": 0.149 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[5]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[16]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[20]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[12]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[24]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[28]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[8]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[17]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[30]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[23]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[32]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[22]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[6]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[19]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[11]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[31]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[9]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[14]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[29]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[33]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[25]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[7]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[34]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[4]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[13]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[15]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[27]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[21]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[26]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[10]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[18]" - }, - "set": { - "type": "LessThan", - "upper": 999.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 5, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 13, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 16, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 9, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 21, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 25, 26)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 7, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 14, 15)]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 2, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 20, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 16, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 14, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 5, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 9, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 7, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 11, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 3, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 17, 27)]" - }, - "set": { - "type": "LessThan", - "upper": 2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 6, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 22, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 4, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 9, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 12, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 24, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 18, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 23, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 8, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 14, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(5, 6, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(16, 14, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(20, 17, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(12, 12, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(24, 22, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(28, 26, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(8, 8, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(17, 15, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(30, 28, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(23, 21, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(22, 19, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(19, 16, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(6, 11, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(11, 10, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(31, 28, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(9, 10, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(14, 18, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 4, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(29, 27, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(7, 7, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(25, 23, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(4, 5, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(13, 16, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(15, 13, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(27, 25, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(21, 16, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(26, 24, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(10, 9, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(18, 20, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(5, 5, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(16, 13, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(20, 16, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(12, 9, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(24, 21, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(28, 25, 26)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(8, 7, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(17, 14, 15)]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(30, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 2, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(23, 20, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(22, 16, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(19, 14, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(6, 5, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(11, 9, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(31, 19, 28)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(9, 7, 10)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(14, 11, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 3, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(29, 17, 27)]" - }, - "set": { - "type": "LessThan", - "upper": 2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(7, 6, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(25, 22, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(4, 4, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(13, 9, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(15, 12, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(27, 24, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(21, 18, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(26, 23, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(10, 8, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(18, 14, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(5, 6, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(16, 14, 13)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(20, 17, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(12, 12, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(24, 22, 21)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(28, 26, 25)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(8, 8, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(17, 15, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(30, 28, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 0.7 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(23, 21, 20)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(22, 19, 16)]" - }, - "set": { - "type": "LessThan", - "upper": 1.06 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(19, 16, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(6, 11, 5)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(11, 10, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(31, 28, 19)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(9, 10, 7)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(14, 18, 11)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 4, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(29, 27, 17)]" - }, - "set": { - "type": "LessThan", - "upper": 2.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(7, 7, 6)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(25, 23, 22)]" - }, - "set": { - "type": "LessThan", - "upper": 0.33 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(4, 5, 4)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(13, 16, 9)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(15, 13, 12)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 1.3 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(27, 25, 24)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(21, 16, 18)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(26, 24, 23)]" - }, - "set": { - "type": "LessThan", - "upper": 0.13 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(10, 9, 8)]" - }, - "set": { - "type": "LessThan", - "upper": 0.74 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(18, 20, 14)]" - }, - "set": { - "type": "LessThan", - "upper": 0.47 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.1 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[2]_out" - }, - "set": { - "type": "LessThan", - "upper": 137.99 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[3]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.042 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[4]_out" - }, - "set": { - "type": "LessThan", - "upper": 16.76 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[5]_out" - }, - "set": { - "type": "LessThan", - "upper": 10.35 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[6]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.32 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[7]_out" - }, - "set": { - "type": "LessThan", - "upper": 9.72 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[8]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.07 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[9]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.04 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[10]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[11]_out" - }, - "set": { - "type": "LessThan", - "upper": 2.93 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]" - }, - "set": { - "type": "LessThan", - "upper": 10.2926 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[2]" - }, - "set": { - "type": "LessThan", - "upper": 10.5531 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[3]" - }, - "set": { - "type": "LessThan", - "upper": 0.7854 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[4]" - }, - "set": { - "type": "LessThan", - "upper": 3.63 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[5]" - }, - "set": { - "type": "LessThan", - "upper": 8.74 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[6]" - }, - "set": { - "type": "LessThan", - "upper": 17.01 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[7]" - }, - "set": { - "type": "LessThan", - "upper": 1.25 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[8]" - }, - "set": { - "type": "LessThan", - "upper": 7.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[9]" - }, - "set": { - "type": "LessThan", - "upper": 11.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[10]" - }, - "set": { - "type": "LessThan", - "upper": 0.84 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[11]" - }, - "set": { - "type": "LessThan", - "upper": 3.24 - } - } - ] -} diff --git a/examples/HydroPowerModels/bolivia/_demand.csv b/examples/HydroPowerModels/bolivia/_demand.csv deleted file mode 100644 index d53b74a..0000000 --- a/examples/HydroPowerModels/bolivia/_demand.csv +++ /dev/null @@ -1 +0,0 @@ -2.17019838000772,0,0,0.027549778563071,0,0,0,0,0.291517838650508,0.751049264388582,0,0.077473720490549,0.000651464621962,0,0.135214164641893,0.289427797394882,0.361466996761605,0,1.98924106313296,0.002101331952552,0,0.163010030157516,0.000651464621962,0.024354586543012,0.000651464621962,0.229624582020702 \ No newline at end of file diff --git a/examples/HydroPowerModels/bolivia/hydro.json b/examples/HydroPowerModels/bolivia/hydro.json deleted file mode 100644 index ea2feb8..0000000 --- a/examples/HydroPowerModels/bolivia/hydro.json +++ /dev/null @@ -1,202 +0,0 @@ -{ - "Hydrogenerators": [ - { - "spill_cost": 9.2310822e-316, - "max_turn": 10.2926, - "final_volume":0.0, - "minimal_outflow_violation_cost":0, - "minimal_volume_violation_cost":0, - "index_grid": 24, - "downstream_spill": [], - "name": "SIS ", - "min_volume": 0, - "production_factor": 6.9953, - "index": 1, - "min_turn": 0, - "initial_volume": 9.23057945e-316, - "max_volume": 0.1, - "downstream_turn": [] - }, - { - "spill_cost": 6.17802055e-316, - "max_turn": 10.5531, - "final_volume":0.0, - "minimal_outflow_violation_cost":0, - "minimal_volume_violation_cost":0, - "index_grid": 25, - "downstream_spill": [], - "name": "COR ", - "min_volume": 0, - "production_factor": 5.117, - "index": 2, - "min_turn": 0, - "initial_volume": 6.17802055e-316, - "max_volume": 137.99, - "downstream_turn": [ - 1 - ] - }, - { - "spill_cost": 9.1988794e-316, - "max_turn": 0.7854, - "final_volume":0.0, - "minimal_outflow_violation_cost":0, - "minimal_volume_violation_cost":0, - "index_grid": 26, - "downstream_spill": [], - "name": "KAN ", - "min_volume": 0, - "production_factor": 9.677, - "index": 3, - "min_turn": 0, - "initial_volume": 9.198813e-316, - "max_volume": 0.042, - "downstream_turn": [] - }, - { - "spill_cost": 9.2310917e-316, - "max_turn": 3.63, - "final_volume":0.0, - "minimal_outflow_violation_cost":0, - "minimal_volume_violation_cost":0, - "index_grid": 27, - "downstream_spill": [], - "name": "MIG ", - "min_volume": 0, - "production_factor": 5.06, - "index": 11, - "min_turn": 0, - "initial_volume": 9.2305905e-316, - "max_volume": 16.76, - "downstream_turn": [] - }, - { - "spill_cost": 6.17955176e-316, - "max_turn": 8.74, - "final_volume":0.0, - "minimal_outflow_violation_cost":0, - "minimal_volume_violation_cost":0, - "index_grid": 28, - "downstream_spill": [ - 28 - ], - "name": "ZON ", - "min_volume": 0, - "production_factor": 8.11, - "index": 21, - "min_turn": 0, - "initial_volume": 6.17955176e-316, - "max_volume": 10.35, - "downstream_turn": [ - 28 - ] - }, - { - "spill_cost": 9.23109486e-316, - "max_turn": 17.01, - "final_volume":0.0, - "minimal_outflow_violation_cost":0, - "minimal_volume_violation_cost":0, - "index_grid": 29, - "downstream_spill": [], - "name": "CHU ", - "min_volume": 0, - "production_factor": 6.35, - "index": 28, - "min_turn": 0, - "initial_volume": 9.2305937e-316, - "max_volume": 0.32, - "downstream_turn": [] - }, - { - "spill_cost": 6.1795549e-316, - "max_turn": 1.25, - "final_volume":0.0, - "minimal_outflow_violation_cost":0, - "minimal_volume_violation_cost":0, - "index_grid": 30, - "downstream_spill": [], - "name": "ACH ", - "min_volume": 0, - "production_factor": 3.2, - "index": 40, - "min_turn": 0, - "initial_volume": 6.1795549e-316, - "max_volume": 9.72, - "downstream_turn": [] - }, - { - "spill_cost": 9.231098e-316, - "max_turn": 7, - "final_volume":0.0, - "minimal_outflow_violation_cost":0, - "minimal_volume_violation_cost":0, - "index_grid": 31, - "downstream_spill": [ - 42 - ], - "name": "TAQ1 ", - "min_volume": 0, - "production_factor": 4.81, - "index": 41, - "min_turn": 0, - "initial_volume": 9.23059684e-316, - "max_volume": 0.07, - "downstream_turn": [ - 42 - ] - }, - { - "spill_cost": 6.1795581e-316, - "max_turn": 11, - "final_volume":0.0, - "minimal_outflow_violation_cost":0, - "minimal_volume_violation_cost":0, - "index_grid": 32, - "downstream_spill": [], - "name": "TAQ2 ", - "min_volume": 0, - "production_factor": 4.47, - "index": 42, - "min_turn": 0, - "initial_volume": 6.1795581e-316, - "max_volume": 0.04, - "downstream_turn": [] - }, - { - "spill_cost": 9.2311012e-316, - "max_turn": 0.84, - "final_volume":0.0, - "minimal_outflow_violation_cost":0, - "minimal_volume_violation_cost":0, - "index_grid": 33, - "downstream_spill": [], - "name": "CHJ ", - "min_volume": 0, - "production_factor": 1.2, - "index": 43, - "min_turn": 0, - "initial_volume": 9.2306e-316, - "max_volume": 0, - "downstream_turn": [] - }, - { - "spill_cost": 6.17956124e-316, - "max_turn": 3.24, - "final_volume":0.0, - "minimal_outflow_violation_cost":0, - "minimal_volume_violation_cost":0, - "index_grid": 34, - "downstream_spill": [], - "name": "YUR ", - "min_volume": 0, - "production_factor": 2.5, - "index": 51, - "min_turn": 0, - "initial_volume": 6.17956124e-316, - "max_volume": 2.93, - "downstream_turn": [] - } - ], - "stage_hours": 168 -} \ No newline at end of file diff --git a/examples/HydroPowerModels/bolivia/inflows.csv b/examples/HydroPowerModels/bolivia/inflows.csv deleted file mode 100644 index 97fd22e..0000000 --- a/examples/HydroPowerModels/bolivia/inflows.csv +++ /dev/null @@ -1,48 +0,0 @@ -2.511995176219288,1.5219775304828789,1.201635404772053,1.665234650457725,1.3538975481813056,0.9398527488038416,1.898122101740684,2.19503446312563,0.8720931867986674,1.8554464021009434,2.1197339063133027,1.054227917226262,1.5323036129474812,2.338129891598134,1.2862919022041872,20.287328815178604,10.772303049460756,9.275349917740012,14.141831452973653,19.68323492663498,5.882002148039282,22.949247433144187,16.590984966460844,12.899242194257571,12.501687701197117,16.543011671005324,15.253237155042374,16.24851040546283,19.049733526468252,10.284614251333002,0.47051310438920707,0.41650730776932954,0.4336057461647621,0.477451968284078,0.3754523636596491,0.2000144671649994,0.4218600252286296,0.295586304290897,0.5648489526744095,0.2907116065969533,0.2611208236108502,0.42297175432264633,0.5545585862379216,0.48408174580858665,0.36360629912991477,5.920884899840916,4.456284667046018,3.039611668886998,6.2458766559125,7.658748883214739,3.9469358129786256,6.365430054453148,4.5135860066301765,5.5963354410421715,5.064642896573039,6.134565797798968,4.444426961132509,4.52173270308419,5.40128586100095,5.302232484614076,8.740098685690562,7.395369718493634,6.236679166784453,6.576517754966244,8.021893816349996,6.211844156821933,6.567282832672815,8.969023056873555,6.7272333746157695,8.719667980856505,6.992505926619616,5.401448346338854,5.605904506674471,9.16293594438752,7.8625255927132205,12.202757601522093,11.368770660800644,9.150617600702416,10.357171277022768,12.790574440438007,10.23842397764487,10.737961788285372,13.933898490446618,10.120008125457083,13.899373317210864,11.586359841602471,7.602365317441269,8.19131331231342,13.401595443549056,12.814776118098221,1.182082511928039,0.38193097776388596,0.37145124679935854,0.4056552491194089,0.4180195852494776,0.1869794681093533,0.2544849122899851,0.3220899402742792,0.4702788063264206,0.3451845991892177,0.3521226207861642,0.40433946449534874,0.4114652621089111,0.6835222599450383,0.3856949951615897,7.174922571850988,5.553884331559729,7.94289068507205,12.11876492182805,11.305606204953921,10.477704945568126,18.124673645212127,7.950978457290265,9.12900308659847,8.575929704620522,10.915252409539892,10.01360814824206,9.320395779643585,8.002953930720434,11.644763729620392,5.793033749093465,4.483574866447554,6.4083096134767255,9.773742052335578,9.120936811607633,8.449733976255288,14.61286380404199,6.418419956369257,7.36573973903494,6.9204892262104565,8.805058363001338,8.080938535198477,7.5207944603289905,6.459871302494316,9.389227417318914,1.6400117193850288,1.6190620737633332,1.265289204467468,1.472304807798992,1.8640401422793809,1.4824946743419087,1.6566933736224485,1.9626217927383123,1.3115335491996367,2.031323432079124,1.7960015116361485,1.0239458291153407,1.1205763237682493,1.8616228172257083,1.8450596303120101,3.196675667842211,3.456728692005256,3.4244537873583027,3.094285645863952,3.327895699300981,3.37887731734589,3.402956792561052,3.4582810194596263,3.273756264195349,3.3839938910958764,3.5113378154776664,3.507487794885554,3.3826590336057394,3.210450288504671,3.101301937391568 -1.759797745755387,1.3538473691134958,1.8121944514820059,2.1409446954163345,1.262347499669223,1.2118205188685007,1.8148011513740658,2.2362790957138583,2.80494645376739,2.4713697644995767,0.9974292289900765,1.4967869902357773,1.6080916974581803,1.4300726967490056,1.6533490473058698,19.26405193271715,17.96202099091269,19.114657654695797,22.69731955671032,18.868198548566266,8.99713001427237,25.769732666887997,17.431249058218025,17.29857248355733,12.324541910965404,16.273893947525618,20.217721079775494,19.530121596749265,18.63537301778422,19.537101364748914,0.2586142280260421,0.16020862998290164,0.31677616386597707,0.25892032231870676,0.19502772863468898,0.24798923622304694,0.3568585869658658,0.28270425729301096,0.21248425481774064,0.3259492922150853,0.2584710732651788,0.3317635400360802,0.2937762764678645,0.35606322887217184,0.15932311653040243,5.650334923611902,4.266875106053565,2.907535952530181,5.9767537499838,7.29560347415484,3.776747546298865,6.080973753911128,4.306896154719088,5.343686890363616,4.835052337113452,5.843129871101171,4.249499336824739,4.317858441475937,5.15379029674294,5.068227899696149,8.343545356982407,7.088008967542689,5.976254785499046,6.296126326335206,7.663704667699678,5.949950842368699,6.273140275978935,8.564911971297077,6.422107771505571,8.307585421027568,6.683125905109123,5.1509199191201,5.336376682666859,8.737155270612742,7.516184827717686,11.647525006779365,10.86611807984486,8.74533859360631,9.893545633004393,12.209893837366312,9.783057179426859,10.251181568931779,13.297474113300815,9.658473206155717,13.259262066395456,11.060505213372231,7.255478044801137,7.81222664151554,12.78317416381938,12.237623204476776,1.1245093684696195,0.36600911752288456,0.3576742491570405,0.3882547425071962,0.3989745379082795,0.17521457408545815,0.2396694779501638,0.3119374132833169,0.4479400224008069,0.32153910135460695,0.3361956291486144,0.3790706706051048,0.3826776062127931,0.6576904102262898,0.3640600701561311,6.85255124457294,5.305834713061641,7.584656675909456,11.566349035451358,10.786420342036976,10.006243891025814,17.298217192001513,7.595406498252583,8.715202904073976,8.189729232678987,10.412311719677179,9.565370881078113,8.903869940651196,7.641001212571519,11.117902408643058,5.528927412575618,4.278704097179636,6.115643334150211,9.325800354587967,8.697977842079071,8.06808113284935,13.947506734952483,6.12869985395658,7.028441905044081,6.605837303898831,8.394536610313454,7.718145124300897,7.1832591824027165,6.163790155309038,8.962959703456626,1.5677574142463622,1.5608423977779695,1.2202164690800024,1.4138739031440224,1.7802481505191743,1.4279989297260538,1.5857472004895694,1.871639355460132,1.252890670621793,1.9360058433417404,1.7141445159491253,0.9791671773034886,1.0670382232751705,1.7670029966935437,1.7690482048727256,3.054521911651973,3.2990201352748874,3.2656996769542883,2.948748355688428,3.1766119157764834,3.224138312918702,3.24171151125524,3.302826812426757,3.123484757411376,3.2260139840976896,3.3506334178807937,3.3442365453299785,3.2311557588530344,3.0587208671028505,2.9646414716375205 -1.0317156624533503,1.5498872321953148,1.6166224402339222,1.7042427566501162,0.7797468065183932,1.5565941489276165,1.0422202095029423,1.2670639715652225,1.867493335813572,2.345125409401739,0.97413451969861,1.9363289752389308,1.4648637627517047,1.287522248348763,0.9572070872140972,16.307103000468185,21.00228249288491,20.37256855688921,28.918729590754143,13.481500468277705,11.916102976314264,21.833985679152494,14.633743670567306,17.753954019468665,14.916258006135658,13.084643309560025,17.750997533609578,20.5303866729131,20.103373563131658,16.33530782045545,0.42204925219961975,0.18319869905354966,0.34413046952513027,0.34290776303851406,0.3441381362108653,0.2716978817931632,0.35672217652107224,0.39018309353668573,0.26178820888467635,0.5171991765083124,0.37351323483010046,0.2047144334405663,0.45214075177770024,0.3307684792978106,0.3281163263927033,5.094263483162652,3.847936699015974,2.635577329289853,5.428917119976986,6.577604107350782,3.4114722664921393,5.492811049913325,3.869121967936292,4.833555723511137,4.386328399633866,5.280291159854479,3.845727041874381,3.9179988877541976,4.663157435801949,4.584854859903086,7.5407766128340725,6.402909657634705,5.4139487854600965,5.7005818706642835,6.91447028925395,5.38619265881754,5.670847991173487,7.740503168004098,5.811201636321031,7.5103598916804835,6.03292976271113,4.671380556690082,4.8356853067198,7.898006706277975,6.797129359297834,10.531161874554456,9.825962111103001,7.915956023148964,8.957010203227698,11.033610787902086,8.856157761147525,9.268926903928023,12.025109676152004,8.742948853035651,11.992959320045046,9.996717618364325,6.570453598881773,7.0716261815376,11.56489110744764,11.07481086199498,1.0198277253380752,0.3313029783526146,0.32579202516904165,0.3463434864678547,0.35506702731634854,0.14973720391434886,0.21653803101175334,0.2800202815424559,0.3962636891890327,0.29157575453068035,0.2990449653913545,0.34299495180253625,0.3484076271927985,0.592055919189052,0.32021863275628654,6.19147346927331,4.797566330074574,6.8615990082003,10.470054380655556,9.757482329734454,9.046761475851381,15.642127956886846,6.8611375819784985,7.883210089436588,7.408044149779074,9.414910831681278,8.647606777047313,8.054891091447843,6.912768810059946,10.059517302023393,4.999098419499084,3.871672950517403,5.535575255386518,8.444802976330163,7.871713046232922,7.298237041341597,12.617163627395914,5.540100456430997,6.360682529025918,5.978450018213879,7.594195679751174,6.98138257354572,6.501487154917217,5.579278480659346,8.113021242846363,1.4121758469887586,1.407797420223896,1.1092554028782966,1.2869256470919361,1.6019269269372407,1.2986828364729253,1.4297352236526915,1.686961020302265,1.1389739855432972,1.7488112210946756,1.5461679652880098,0.8925742506164894,0.9701531167460528,1.5994814922774687,1.6027674276105253,2.7607942262228766,2.9821278790419044,2.9590656154788313,2.6729749019144964,2.877486489239145,2.915508963970828,2.924955489220345,2.9927298791026846,2.8232214298617033,2.9105660552669352,3.0290637470021564,3.0234687389757697,2.9203963562740616,2.770584161351662,2.678578383120093 -0.9422365651687641,1.9480480112623704,1.4015848932449475,1.2501125476636568,0.4236674450771135,1.8377145480215624,0.7861953861298044,0.7558321055329758,1.7811410936074479,1.9161503588947753,0.7662161440930366,1.281878954146074,1.5889997130454299,1.0924339840105428,1.2577544267933363,18.057066922362505,24.443303652709716,25.732317528580207,33.30910146075573,12.688509972619682,13.577739076643267,21.38987779705814,14.09674649446126,19.527715152370245,14.990779402446414,13.879256255641163,18.927954651344912,21.74555705385875,21.238157357955192,18.39158944174909,0.35834255251127245,0.5061571569696225,0.48541268987399855,0.35404551515583416,0.43204256020762366,0.5912157951409373,0.4035385079622132,0.4663696972752098,0.45817776137609423,0.4327844430070439,0.3958386690930214,0.6347873283038137,0.26120016566466253,0.3800187773059739,0.4478300944474463,4.819772625375145,3.64821023726474,2.5075211427050945,5.145435033952139,6.221253869404239,3.238568028392958,5.20085898320063,3.6685241055022777,4.584650558687287,4.157425709853394,4.989188113554569,3.6347390746396546,3.702817676994796,4.416976908724373,4.355593642948379,7.1379254609323795,6.05105507290585,5.131410628127528,5.406813855540137,6.524231086266043,5.093993757269005,5.363379114187324,7.33082643400993,5.489845845348986,7.1283508996577805,5.6918918604844535,4.410179766410961,4.574681780718768,7.475665901870962,6.425774199609892,9.973641558219782,9.298433487605156,7.499630821873326,8.489886077175182,10.433631472428843,8.385268561157744,8.777939013634706,11.390955243971966,8.272993865820261,11.373082143585421,9.454051351232511,6.211778397945594,6.6940055053612415,10.95209886303755,10.486037797963906,0.9639379965236416,0.3167327141800924,0.31983704485195297,0.3370818559860942,0.341041461924314,0.14377543507909707,0.2071239372947989,0.2730788450133973,0.37588553195303154,0.28406251428205653,0.28743867090323866,0.33012774880286494,0.33694457798225047,0.5644043441505292,0.3059946008606206,5.864710762254554,4.545847363409447,6.496478866470008,9.91736379524398,9.243596231316658,8.572840750978562,14.820310942502305,6.501442180435258,7.472150724852896,7.016081944480477,8.920615174845151,8.191731388109828,7.628385197235378,6.548230165127118,9.530775244605294,4.73453380205217,3.668292186695644,5.239400041358196,7.998070761131512,7.456565110138422,6.916074343534331,11.954193528685826,5.249590918287233,6.029642857914978,5.661058469873837,7.195361306143035,6.612651777492955,6.156022261992404,5.284380679461454,7.686309152470118,1.3335448633370623,1.3237144872054636,1.0513875489712188,1.2217667380357595,1.496170067200829,1.2294814262255074,1.352016041103786,1.5935132809183685,1.0715361679196767,1.6646571557836605,1.4487630055593665,0.8345467915480707,0.914537899954514,1.5079303504978985,1.5118777653260058,2.619109810850834,2.823920201340817,2.8016527025341365,2.535233052049318,2.7293453350350627,2.7599075742514216,2.771272580772154,2.8333162707586212,2.6721291329291637,2.7576439348273714,2.8725507479928196,2.857623564828618,2.7680741844168186,2.6203529885878325,2.5333343960912114 -0.6583619904253567,1.9460208014998073,1.8531776092557002,1.4000363970272542,0.6198457560366892,1.7992410342277487,0.5492056886946377,0.6176218062529892,1.63576504430634,1.4979362334709925,0.7459248823674344,2.329046339665723,1.4735019448241957,0.7699771571204856,1.250562599263746,17.87349774784659,25.451741576204917,23.116166647150802,32.00959637686101,13.988258458880347,13.192551750924524,19.971127623000324,12.560098764592725,18.210732872342124,14.148896790239203,15.252450635923637,21.684803942290927,20.539433524152383,19.192820745118816,19.5971821684429,0.4021645547717706,0.6893593358349945,0.6019510307529679,0.5743120178373292,0.3278607716756913,0.5206408374864235,0.3483607713464399,0.2694346531317561,0.2592054140292206,0.3181360593960425,0.4682395652678058,0.3384461168551877,0.4805087684219034,0.5279023457289115,0.46647070217403774,6.450983080248613,5.598111042440709,4.483698307757893,5.927375716919782,5.99151023062675,3.8724625401237267,4.97477308849434,4.194050845913403,5.314835156965575,5.090664698934192,5.203296153900621,4.48361035783308,4.519101692414951,4.990850620460127,4.868289805115018,9.057120183594698,5.13865142140122,5.8335111159224295,5.45995804181449,6.6563915517598105,4.4585823199552035,5.496387158305913,6.975495381370184,6.115691832612882,7.342891030573453,5.652371374372247,6.388534941250365,4.27533707824851,6.521057054890897,6.848327122820955,12.465242197252381,7.608366180447535,8.103174267498982,8.732341630066927,10.186184656945166,7.026467362858616,9.027741889516903,10.90756415152147,9.82503454534126,11.679360708431417,9.13225118734384,9.34374104755926,6.003795402092129,9.419135567465096,10.77301566639805,1.1587369386311672,0.3665552358795565,0.42340431795294176,0.37781839239932613,0.4406438055860938,0.21785830876574824,0.19927972604447158,0.22767552034938843,0.29058250743059416,0.26051635653412186,0.2830126602027789,0.3715397682551193,0.5204640529377519,0.5857198224977653,0.32413618317502346,5.811364534463035,5.794618585824917,9.911371129064342,8.565856804448147,11.257190959307762,8.005427162002356,14.525059751403454,8.784032691615371,8.385475509208982,10.484687978234863,8.213451384736135,7.624593403865385,8.941909442447391,7.244518415769378,9.142384795923089,4.691955208391888,4.678978363602188,7.99855960312909,6.9023471747912755,9.079992833154941,6.455463923448459,11.706843237321479,7.091341676472541,6.766092868692418,8.461024080288585,6.621294880061355,6.152526224036849,7.214894128358809,5.844438912138379,7.3689182046879385,1.5479458593595605,1.1731562281995114,1.1977882059285996,1.3107460214029862,1.4493083767186823,1.0787881789522455,1.3665116262382682,1.5282355467195492,1.3440786655002102,1.6318246115888337,1.3815196649518924,1.2996920886348569,0.9464413048013638,1.3564881546289875,1.469717104812827,2.870585773320622,3.0319544413200314,3.107419793342677,2.840697621547444,3.029906696103214,2.991589518152742,3.077938581859145,3.086561469357897,3.066624805101317,3.0529542663315445,3.0748206873164423,3.1074432158014855,2.9849441865913255,2.8411566971103204,2.7466915607985536 -0.3392624026791461,1.4150864487499077,1.0871515149518376,0.8414775025234876,0.4232879957585389,1.4442094730151387,0.8110720520710614,0.8956120596496717,0.9478786120442395,1.2400036985922551,0.3547486018781323,1.3304874255557424,0.922477890412598,1.3367690301785908,0.7954267699938367,13.336764912917694,21.967988227967894,16.66901964321612,24.844722735060138,10.350679172270958,11.859204482317878,18.846377652890684,11.905913083225087,15.281471961786453,10.558579355324076,15.012927307460421,16.908635087564438,16.442604671627638,18.206281840459674,14.981170259341068,0.3488362814486615,0.48766564980662663,0.4477015036708305,0.4230291632399638,0.3809546184706499,0.474844695855403,0.37856444493008534,0.3844098796085055,0.47351294538148225,0.2932671593683992,0.3430820055758077,0.4801134600879826,0.3242179735696856,0.33864184596669533,0.332002232886383,6.929419691816639,5.3866164061323065,4.4375140652736675,6.534486038096633,5.376323851226174,3.8102493073669548,5.8224241850207425,5.3463550939917255,6.08475270057585,4.815474432411642,6.2458276413332845,4.195475574154961,5.518300748405039,6.835578529206989,5.246689065852553,10.546906928349213,5.4108371708777785,5.335103154248085,5.078646400099486,6.056272167546188,3.6509904671779214,6.975343954466032,7.0527593903052965,5.895974260242426,7.882896291958732,6.805159875143345,5.700703273004505,4.51810853469028,8.744381813000928,7.3988956564507555,14.192033347466499,7.978721815706148,7.071320683222666,8.485839170101178,9.146146370647482,5.7629644728801654,11.347444265782725,11.203505920969318,9.884009204567151,12.31677449413258,10.724742519309636,8.072524349783855,6.470003091869045,13.184081908083835,11.56371800061725,1.3434499309522132,0.38722424238454334,0.416339383779923,0.34246108554791016,0.42957485766531944,0.22483484389893643,0.1549642533109259,0.12018716155835169,0.1779519737764766,0.30100809730817746,0.28091108761454725,0.3485356478080284,0.5559455785700091,0.6581550254033609,0.25589310223613626,6.563759508908267,4.343938979643025,11.332970014360189,9.367890254874741,10.856869767885238,7.428888365594881,16.572897196688047,9.055078426247775,9.171014797224991,11.037587051399026,8.664047450423022,6.925149620112783,12.08465433015798,8.685470602216402,10.03628396191597,5.299470966488344,3.509333936911336,9.148905014052568,7.549343406943659,8.760811073398587,5.9919350655114,13.364291862258048,7.313884726764494,7.401609221467654,8.911217444980688,6.986792665337846,5.58968346965311,9.752240351992379,7.0083271161444465,8.091633904216136,1.6822739471891084,1.2743649582226693,1.1009574041424646,1.2993319101316925,1.1892984642403692,0.9182699036164181,1.7825746399382425,1.611186861949705,1.3739126018905772,1.626775097813012,1.632916200337353,1.0972230276790602,1.190890209673394,2.0182470324241875,1.5196788283876628,3.0914383430801617,3.3002535342834918,3.468501117852417,3.0885910622658868,3.2608182595161717,3.277745054037339,3.3526079246459575,3.365574514775106,3.2624533178126383,3.2803502115169687,3.4016460137706845,3.4167696267115395,3.242739751419217,3.0513482480479297,2.9587951336632057 -0.12481374467919726,1.3669848288709885,0.959542261368984,0.653884167227638,0.48669085290578395,1.2955920138065076,1.4445242510625624,0.8688313444412261,0.7434417613408535,2.161115820720168,0.39271323951206494,2.570854636585988,2.1259395379932893,1.3485677289401905,0.560031195556612,13.59924572859418,27.549083843925594,18.875297813132477,29.003274631925457,12.271289505876402,13.398941593773472,20.352086375864253,14.996082642499925,15.918485865351272,14.038569148254691,19.95538231718965,18.839266455516814,19.6042328795161,18.726363680065784,15.171823084304801,0.24415422477673263,0.4887935920427378,0.7066556187169386,0.6705314150907871,0.42776723888603896,0.22352258453972462,0.456346728924,0.4728045716795606,0.325339227466517,0.4456458557269144,0.5021157796519256,0.32246074640450056,0.2981599105972025,0.43322403283530053,0.5022085751683352,6.277322699164064,4.908248217112225,4.0354037910667655,5.948786048930948,4.898237293786471,3.4506223483036416,5.280525103417995,4.848176520643259,5.525717987955324,4.375966411317425,5.686614031913134,3.8057699095563287,5.016689929153642,6.192946964412039,4.768651004796253,9.593640530265327,4.91977564501201,4.847162002729203,4.620087596762996,5.510482278000178,3.314218600872132,6.344620659343178,6.404070811923176,5.357891985740724,7.166300687908191,6.185381103699393,5.172677025385456,4.110009230635271,7.94183882422743,6.713915157641662,12.897607613352898,7.261284965921627,6.436280647042736,7.721199072934837,8.322482973220431,5.247337915697595,10.315722564407706,10.176997825134809,8.986964196550844,11.192714608532306,9.750104210952934,7.334842039633351,5.89428545451773,11.971915252188865,10.49935351636509,1.22646149692457,0.35765725460551795,0.37760411807614036,0.3182057843116195,0.3964886250271247,0.20492958540829992,0.14794798557214256,0.1086306733030607,0.16356671997442584,0.2810533590071201,0.25665409365981867,0.31536125026675343,0.5092565798395973,0.6019090185327687,0.23204788112054164,5.963455651717297,3.9467132872485005,10.294878589398174,8.51123477724226,9.86220714781851,6.7483876285779525,15.05993475456917,8.225992770497536,8.336675752694013,10.021640988102565,7.874196956518273,6.297159820917431,10.984707240078878,7.8951889166604365,9.124622492773952,4.816390943782208,3.1897219479645558,8.313056037867373,6.860968158400232,7.960299567190692,5.444727624998875,12.147322353213324,6.646127697471296,6.730369423568328,8.092951261587396,6.351832684096635,5.084654534572801,8.867152103701496,6.372689432366934,7.35893314535971,1.51859685517989,1.1684604845429425,1.013080682707861,1.184629690889537,1.0926228276847723,0.843774292348101,1.6087936907283966,1.4459946008783735,1.2472063771615916,1.4676415275840748,1.4818995274805782,0.9911964749197151,1.1027319786158662,1.80379217317991,1.3578262246351225,2.814082580520191,2.99887465493262,3.1519296823637655,2.803608705914991,2.9586170247813817,2.976914174103084,3.0436766241766655,3.062696256869856,2.967305368268333,2.9799393989582215,3.096934032789063,3.108182173462092,2.950417836872104,2.776931257756544,2.6882355133624745 -0.013694638040496532,1.2788796145188521,1.0471948883906848,0.5262291699134027,0.41757769106289155,1.2237974677914427,1.5122629176023088,2.8695705119960806,1.2112440322728335,2.071388378826358,0.5621311252651152,2.4244212627291213,2.2049472693133163,1.2900502987408762,0.5631973137765388,9.574485457483986,30.93176743358945,20.32689052176676,28.333719366528552,10.260839432339614,11.306666889053789,21.12172764055633,15.86917457302008,16.757029386728064,14.518102670697289,21.760890137298222,17.191473322197496,21.79918969130451,23.892617605240865,15.932212343652214,0.41671816937486356,0.3786858268179378,0.15474027424097092,0.21336875456233856,0.3688934862687886,0.42648350126208234,0.3596478172281077,0.3260585475608644,0.4362532984195937,0.338945445880318,0.3309651826650504,0.49405408891744435,0.29901906945135664,0.7324315351300719,0.3659144193560242,5.646734051387709,4.421678093979814,3.628083426060565,5.345652037521765,4.403671440197956,3.102711109645952,4.743583008761782,4.356194138841465,4.986657729770143,3.933823091320711,5.127753688860514,3.419963768473524,4.530162591778028,5.586926555521034,4.287543114218162,8.621944689962028,4.419921237377514,4.3811438352699374,4.1573059160275285,4.956676432821967,2.996509857889837,5.7129348515879235,5.7581440099807715,4.845137701344124,6.452972507860235,5.579276416979755,4.658214384860424,3.7279822472426885,7.142495160382046,6.03803727386437,11.606293964821031,6.524332107436052,5.802826006898062,6.94349679788202,7.484734410075139,4.72574112459106,9.285560914558117,9.15437682164195,8.102885162349729,10.07923189414412,8.783444460609683,6.597110199510269,5.324041643816535,10.772058100642502,9.447490167962396,1.0999980958847255,0.32104555511346483,0.34052456800954184,0.2844786437569609,0.3561833276228701,0.18639384431135947,0.13475127910375545,0.10152973115006264,0.15723954883295338,0.25124347168835415,0.2364812066148277,0.2871387868063858,0.4570156824826528,0.5455677597648524,0.20567539139498908,5.367494039504722,3.5566458316612346,9.26527122408119,7.662531725294654,8.877282464714384,6.074656601445077,13.554244512675341,7.401824889862989,7.504899058448626,9.022842441230244,7.0889666594133125,5.668133907466125,9.891804243765499,7.103895760780649,8.216170998005863,4.333576957840484,2.875976462661095,7.476817331574515,6.174212303407249,7.161305729521564,4.899354694429364,10.92466401658653,5.976409891121185,6.056182329245215,7.282982342314892,5.71618997257689,4.575133645591299,7.981630667758789,5.730324745684421,6.623781679443105,1.339556530324414,1.0292486093807964,0.9528752310295768,1.0441955314086961,0.9722289190087419,0.7908657557020651,1.428698802216219,1.2761900803153219,1.1630260854724663,1.323728770300516,1.3496740990603227,0.8836940171646714,1.0597011162799264,1.5821173333771998,1.213842912353323,2.535549352341419,2.7002967977075487,2.8369029329692674,2.5215207298668143,2.6678565046101568,2.6808181084245426,2.742080474356648,2.758341580949868,2.6716921923360557,2.685376794309936,2.792635497397557,2.7998198722470558,2.6549373347826903,2.4954768552924946,2.420373277628901 -0.23494876687564825,1.365180262981438,1.0348728465101549,1.012628645582706,2.012574815095237,0.8946304984520457,1.0869709397897476,1.8525202997943429,0.9108423981283645,1.358956708080044,0.5382571518179406,1.586735774124749,2.8846948143534976,0.846173873877347,0.7907665021941347,13.23621266446501,29.023315624217496,17.345124979233418,26.46809245337238,17.450461165852985,11.69166536542053,20.038642717006304,14.958917164977318,17.537705049152486,13.023750971968933,25.132441716859894,17.593184846270955,23.460814331627002,20.55663808022041,18.180262297393135,0.41578889001054564,0.3229317835316218,0.26417432461070806,0.517234389821721,0.5579639843810213,0.3229987544197173,0.37303755554893464,0.25630290908314907,0.398801726188641,0.4842656652683658,0.42998295713155965,0.3760016165616136,0.26234366410358634,0.3663636624380248,0.317261606067864,5.905084277626279,4.724288738003283,3.4463763440342525,6.1174541202766255,5.283906605052707,3.5801983877475485,4.4261146928070065,4.047610072947493,4.606477288831447,4.37493048645838,5.54515240198087,4.071789932946441,6.029903003133948,5.762625457241852,4.916982276932404,9.59866323809809,5.000490477597197,3.7551590190140347,4.61890681679207,5.080344719641749,3.7277168833543426,6.0937047085523135,6.048394549833193,5.471679692523014,7.4015907187833045,6.6522076600283615,5.27939251195154,6.29811381598881,7.631574048548816,6.868550443319872,13.246056158816991,7.718386505803691,5.369090820423184,7.799055579461424,7.60470256955303,5.730303427219862,9.6590938177623,9.862694329555879,8.988556073827237,11.407071898684318,10.21740638403665,7.939498560939587,9.89351203691215,11.627192929335239,10.654593131222242,1.1310022524158874,0.292118231307807,0.2517194949742784,0.2890342215996658,0.38087450857416455,0.19806430583774942,0.17328594027316424,0.10972745127438605,0.1633760023420151,0.5669128764541599,0.2937541370045724,0.24512024807663335,0.4487480200653302,0.5576252242763758,0.4842276795128229,6.268791399332626,5.355863468195958,9.314501042416543,6.923872536797718,7.653969493148769,6.4439403633936685,11.03576196809561,7.554347873550375,5.878299054527731,8.180667151937428,5.928004850019362,6.503943661076647,11.20742164995733,7.846817517257116,7.390927895254368,5.057728734220431,4.322203322446471,7.5148370355847725,5.579589151036546,6.1745710905422255,5.19606657386986,8.898435412994072,6.0957911351937195,4.741349556747687,6.600904441889318,4.77915525137303,5.245988625774171,9.044385944498517,6.328846995314008,5.9590811033126245,1.5455144376573793,1.307855652943652,0.9950203849392629,1.257740300557648,1.061267298451015,0.9639456469666943,1.4187956877018109,1.388112108931366,1.3201661445654451,1.496532275675379,1.5157706921293466,1.1612973721135664,1.81386191002114,1.6507388761794575,1.3446565314566323,2.689520480174758,3.18448280890985,3.244361633778862,2.8041432064547136,2.7294797582086736,2.742786873474253,2.934451483913705,3.181047024499212,3.043441574561023,2.777581432103508,2.8651497972527613,2.8444602207466287,2.7671540800487797,2.703077365463214,2.6761721539917853 -0.7380727488268115,0.595181299045688,0.9771038966353235,0.7038016911271237,1.6154634481905088,1.6519102017601448,0.8974410943168191,1.5394662492172793,0.9393280479815722,1.0568213345496984,0.7821939331319744,0.8761781278666978,1.5481439110349315,1.1321499610165355,0.8734280750056539,10.720725950007324,19.977341260519946,13.653386076820807,19.83828685059933,14.781477944598494,11.65906756489301,13.970329935067754,11.90151274801867,13.546845271693762,9.087353856025732,18.4703543325307,14.51475468100066,20.25338588513508,16.30310928833104,14.116765518755585,0.35591747642340354,0.3852961059310585,0.46069464892296685,0.48755960867904924,0.7571394402227358,0.40292952256932707,0.40604647499196656,0.3794120069488471,0.4629824752524561,0.3157006437023001,0.3972801996336976,0.3169672616083806,0.38420103302282593,0.2017036808438028,0.466023234492687,6.421947116705813,4.246886865770696,3.6938087675347195,6.244712286290812,5.980606398168983,3.9098949795201254,4.595868723305795,4.269662477854356,5.113142563700137,4.681045856517024,6.303962156482792,4.669279735288578,6.3347465961985625,6.528797967617144,5.673979562531941,10.688522501202078,5.7763022520385805,3.9102983070468826,4.4321926555086275,4.563074007962484,4.457757359515483,7.15899755366543,6.861190874843618,6.034181370445305,7.8828132112116815,7.6874806494455115,6.206475063564972,7.785676268940309,9.220967872300841,8.731358882331566,14.882324891490576,8.399880036206895,5.218263364656436,7.57945418531588,6.641545677400443,6.312590099757587,10.979037506810926,11.133944420858562,9.674930120285516,12.627376019459966,12.14337976591503,9.077504227279887,11.40735135372074,14.621381975566154,12.945980362990626,1.19935034811371,0.40891146421823654,0.3059523193389104,0.26792035067383857,0.5793121753416604,0.29234292232666015,0.2510618059747921,0.11511004733646335,0.21145834147450004,0.5394708390355115,0.2779721200953735,0.31249839393716133,0.7512612008194455,0.5281172092779173,0.8733495450953417,8.961273847353844,4.231957410847299,8.772192115367757,7.853125794999627,8.25303717236594,5.782270324091525,10.400412317667115,6.153306998512294,6.29541383917831,9.932632711919865,5.616997997046239,6.631149764488449,9.712689377909925,10.751510904892436,6.876820469261833,7.2307660056986425,3.417151646028741,7.079352499967874,6.330975475979921,6.6593881891439874,4.666049288674719,8.388638463665696,4.967224495402092,5.080220459416553,8.013812648046601,4.530278146873465,5.351321315893807,7.84134851364178,8.672783795096038,5.547234247633283,1.7924712775507212,1.3197716780736728,0.949902201712703,1.1847953281241335,0.8769736417549107,1.0368483004870446,1.589601581434839,1.5736745790166964,1.3765842666719603,1.723618384707028,1.825647667027521,1.2795086117812922,2.0522087459819325,2.1590569807971463,1.596034129892596,2.9129222665029797,3.6193457427254327,3.6749362882279937,2.9400859681865845,2.857552544807334,2.986664361004478,3.2486103103402226,3.5557628721533145,3.328955279968921,3.0043127180486437,3.0894260035985277,3.0954112816251684,2.9736276767356933,2.839960329234406,2.6318198966907254 -0.2907737604432622,1.1161500762250849,0.5580951809477908,1.4263863742608092,0.9935817546769284,1.1302031326591502,1.191277181523542,1.1381237703174112,1.3793201079065924,1.0759493474240516,0.9944177007457993,1.1345087029856327,1.9099226161471847,0.992790865186952,0.38423659862963133,6.641558298378273,21.958339672837518,12.53231206705482,21.192683836929618,14.364578175611669,9.83758008304696,13.661991019506033,10.593459092256523,14.717906396626056,9.863712317833738,21.02532752928267,13.291117314949808,23.80432462352438,17.059412639795447,12.86980474247783,0.33373440282927164,0.3299594576903041,0.5058964466301712,0.31343745158500813,0.716381714902234,0.334293344578667,0.3171317230405877,0.4919038465929547,0.31620172232992544,0.40186184374844797,0.32120392625994915,0.36206883860474115,0.23259006247719036,0.3430011281620692,0.749184132037588,5.818456994956729,3.8687371724646598,3.3654222785674035,5.677903707252227,5.441575981154673,3.553996724644815,4.1745581056038725,3.8673274142131358,4.649300205495642,4.254278557319592,5.7277405506757955,4.251170031401314,5.77263218034292,5.942794121481338,5.156139801634517,9.703507037794807,5.25193696578698,3.5679645011003793,4.036487598649422,4.145495017232033,4.033776297443435,6.525594126969327,6.21870240350616,5.4888292029473345,7.157096367651845,6.996573788851929,5.643824395112243,7.089197241988003,8.386332027421854,7.922339458911022,13.518937919837736,7.639582108481997,4.752363508300832,6.893861976170898,6.036397766712755,5.72866267963606,9.987283865105187,10.107694483582382,8.796319765153262,11.474777536596815,11.042382638086515,8.252551954702154,10.378020092705684,13.292307727269867,11.759026622290158,1.0881833571551285,0.36769643902782756,0.2763606412981097,0.24698399956295614,0.5304211099933909,0.26317785628297774,0.23362974497873384,0.10622607878620721,0.19156071476303865,0.4867481308057351,0.2516353357874139,0.2849440740826068,0.6819627809793598,0.4809676457381291,0.7902208498397303,8.14371196493642,3.852224531549908,7.977330088234801,7.143101839170308,7.498622456619127,5.264405622143814,9.448346731497406,5.589496727700334,5.725440795612285,9.031515242442467,5.107145713794309,6.034852471971837,8.835685021617438,9.778745192833117,6.252676895764687,6.5694460880725485,3.1101136892848626,6.436450808689458,5.757381777078491,6.0491214328020835,4.247504898401512,7.618686802311796,4.510994244668904,4.619347646932177,7.285083824968434,4.118240516360867,4.869247196660912,7.131794139537338,7.886323268216021,5.042680498463983,1.5860885961853661,1.221327479350321,0.9043800456228684,1.0957432361348491,0.7984233585188686,0.9275602112708196,1.4619717071150808,1.3814856329260055,1.265860209125516,1.5538290030136663,1.6632714207793615,1.171793640463765,1.8844005772823065,1.9565899820897155,1.4265138783049383,2.643212971394856,3.292356455677532,3.3362629532578465,2.6728658893920376,2.59003363858095,2.715574364839604,2.944850637582483,3.231093748888499,3.02875773462641,2.725160282640698,2.8070283615908016,2.8069290042995187,2.69959728390403,2.579119140502663,2.391329875420998 -0.3203254539867112,0.9530938467731543,0.283819289607703,1.1184993934182843,0.8339212304787471,0.8586804084628568,1.0416494426933025,1.275826291040394,1.3369019759992455,0.7559406335733607,0.9098562988932362,1.0225054537717981,1.6688346161058834,0.8043586367376422,0.4871909173325788,8.177690833336388,20.98473299237868,13.624640296597388,17.61982374596355,13.143092662334464,11.224083664051271,18.25784276434957,12.26045337593254,15.680704256022414,10.292976547482567,16.83336227900107,13.02007790789539,23.83133815795691,16.626716963693983,12.156877408018998,0.32179121352564377,0.3245677847190056,0.41143598354612415,0.36185255399293403,0.7090592454936483,0.582939735833028,0.19644248173494766,0.653937041805239,0.4116763801695682,0.5366502097830924,0.7675733337207243,0.2650581535812794,0.2294191709203848,0.41753491133289566,0.37972436537984766,5.232266731699749,3.4818756662842656,3.040812666332789,5.103089329473924,4.88506126492239,3.2077409036023448,3.758035048663507,3.476028086763903,4.192757751859619,3.8241511858114583,5.136631340531181,3.830964795215598,5.1933060162591556,5.357337655133077,4.633701082172787,8.716287614384594,4.726913266410658,3.2183561725311574,3.6210904398487713,3.7159660245490373,3.6282379729985412,5.891994833008825,5.572902796823291,4.9500940218268425,6.442696188611398,6.2817360045297725,5.10254971910236,6.382575105369774,7.544191047065829,7.116011370991427,12.15379945340555,6.873259263596548,4.282737453185744,6.195544636830768,5.418898251153144,5.152268154542618,9.003269440622665,9.07706560442723,7.924686662744308,10.326418415848131,9.925237569044464,7.4437279152271465,9.343141810986559,11.964540348728825,10.57441791429428,0.9788084510806856,0.33486810638497877,0.24838444130699117,0.22207266323556596,0.4820412082940486,0.23662629779468042,0.20406284054185808,0.09403270538104314,0.17337219125775416,0.43875540304777066,0.22643373001502087,0.26023310204652156,0.6142739468106342,0.4257545044729476,0.7095088145639021,7.337738383344372,3.4640222799662057,7.179021446808792,6.429191852322768,6.746756094644068,4.738810411415788,8.500452194508583,5.03106949484115,5.1548815015585,8.12248077751116,4.590236074995248,5.4287286364968,7.949535750583142,8.81207049701309,5.626763925545251,5.921506887334532,2.7955229065629137,5.79379393068849,5.182992246264357,5.443649043225466,3.823387404897682,6.8564860962266145,4.060434875319428,4.159324395136629,6.553501957262855,3.7007358995365816,4.380337469317726,6.418342562554222,7.110136913143581,4.538309291057114,1.39105592342201,1.091884923613291,0.8319615242965457,0.9601421107654504,0.6924386654189081,0.8341684302465556,1.3525281296194949,1.196147777375482,1.1575326514411677,1.3792081371119704,1.4516569696045385,1.0986766462221689,1.6872000104082385,1.7560007597116376,1.2648985688760053,2.380137161123448,2.962251982868594,2.9989492797668516,2.403735081453652,2.334802318308118,2.4396826794495383,2.6504682572157283,2.9093350774665825,2.7224160021654824,2.4484315962727843,2.5214567395098695,2.5268705255355126,2.4342262902614435,2.3201119803899,2.150036415932912 -0.43529941617723467,1.0550631535564834,0.14695597895469803,0.9081461663430803,0.5588751858130591,0.6431738607101092,0.7851230499974877,1.0371429148559956,1.1755394950827953,0.5686240795489368,0.966538239748267,0.8950937038791467,1.341851228395182,0.6654918280933255,0.8945798988137291,10.118795225422122,18.05113757640641,13.13413391367676,16.670456339767767,9.157597402093288,12.291328517858117,14.389096393238894,10.769525367964626,15.168842933371913,10.527003500179392,16.82110002863072,9.856140282681274,20.2410453251324,15.655184656320872,15.800280757963852,0.374588924250829,0.2532358700812594,0.22866128735516655,0.4737774410761111,0.3410395925735785,0.6084826463592165,0.4269212144654278,0.2304841616028093,0.32602953870193374,0.3368602741674454,0.46575814942401433,0.3913325450527228,0.3578963269203474,0.2966438195568218,0.4321797239177489,5.489683043030834,3.6513817390132774,3.2568653018216636,5.379134293306237,5.051764526420246,3.4511435518375184,3.908464192348206,3.6914753505033477,4.453955228928733,4.061106659867778,5.398273380273177,4.034229160268471,5.4580139129070515,5.583918709860353,4.877144329138099,9.081497071476495,5.136780290015564,3.6947060313535283,3.984269221750542,4.021276515106024,3.8303157731698367,6.115829216485314,5.94346916078251,5.3778576453284,6.851359753370912,6.559722810994732,5.377974828701559,6.721300282766084,7.856572680135572,7.433439178117497,12.711383908031953,7.523482771996688,5.022982499796436,6.729656989982254,5.877782446363174,5.430864637405978,9.371784272228425,9.663990148216715,8.603774492363126,10.964708077068313,10.378120998868472,7.885004892781673,9.910680394498645,12.484490815065872,11.108426798402649,1.0135439530306873,0.3599327692139185,0.28041343177576294,0.24851016709631596,0.4936757082696514,0.2651641903289579,0.2169149712617165,0.12999116678685396,0.20633269513125885,0.47042633789562976,0.25036760390008334,0.2732985389000731,0.6179197267309228,0.4448156353715555,0.7319451324154307,7.876733849342383,4.104387085397825,7.7227970194417335,6.552639088569728,7.20735562933489,5.152581112245381,9.083732343815335,5.474791319635082,5.605012862809528,8.676278389517954,5.0893130407533675,6.028683629072452,9.034052033556609,9.457376769654793,6.032780544309676,6.356801196951135,3.3110129217720528,6.2326866108780274,5.284079575803304,5.815390683810973,4.157365869676708,7.326954680648062,4.418517933503006,4.5226210086037195,7.000631583178439,4.102941859632075,4.863820970386858,7.291342117824871,7.630793970285177,4.86610415533323,1.4808049017772098,1.185960623290579,0.9375700613626143,1.0393888509683502,0.7566593639368865,0.8705645700729472,1.4080526068585757,1.2808353509083386,1.2568771803760375,1.47517525405102,1.5274611052187115,1.1684575597301965,1.78224152924265,1.8392200908066907,1.3507555823530846,2.6880336841398043,3.128891253121286,3.179009711460113,2.6866535694294074,2.6041701816354323,2.655777693192796,2.9246185348691274,3.0678359192775964,2.9271242891060396,2.684143064820877,2.808861002898732,2.83246628770982,2.69763684718285,2.6295513196466427,2.4585821660091294 -4.524894680478303,0.8147026754899197,0.4047753970427068,0.48710323584450466,0.36323451561381165,0.4349846113656241,0.36247809937788583,0.5967352997379913,1.128221149741062,0.43565745868861194,0.5062883640796286,1.3799131891783694,0.5848367453794162,0.3431386017653936,0.47408682119770457,10.829428413635751,13.398136629559472,15.388541274555891,10.754979636658025,8.76775720347396,10.15018114110233,10.223190211166612,10.248174344158565,17.721645806156996,9.138497473514754,9.123864284610882,14.237310692015793,11.806024282058074,16.426251925024722,11.587465595491139,0.2710438346291008,0.48197420681125,0.5776944608676218,0.2658009798706208,0.37367592292172275,0.5564993581425202,0.3473569483706635,0.54125793124863,0.6581967162968998,0.2541261810695633,0.6899481784734858,0.3905661369089196,0.2506363792366909,0.41676616086162355,0.39359925094472187,3.9883899762583415,3.39378934045296,2.6331964506100176,3.8990400395904317,3.550017204762352,2.7033552001663725,3.0064945856539573,2.5893936745283277,3.8255621127048625,3.129464322348942,3.8619249773109807,3.801102415299558,3.892888651917259,4.540833314656071,3.980121717793781,5.752963032372864,4.826588515797684,3.6007005049276533,4.316570058287513,3.445243947569047,4.262386002847119,5.595782035786655,4.260199620157996,4.366528883348197,6.040833356392065,4.616943651486321,5.515683178978639,6.14725659229156,6.290810093691778,5.485786092819317,8.859207346606162,7.0423441182937445,4.745683407653563,7.176271346375551,4.973891584911636,5.8902153815346665,8.595471077038356,6.560409682533077,6.8003789285084615,10.051159953291542,7.083696773804881,8.397470751580654,9.475875797678185,9.817467953202527,8.602779409039636,0.4629539220720489,0.47445580680695476,0.4405926035805031,0.18273940007971026,0.3225350536331362,0.4222384334184875,0.28233215199691875,0.31522135936828755,0.30254710019881587,0.2696805126469132,0.3890851720512661,0.3132891378782009,0.4686180331606435,0.42304134377469327,0.40100084174485484,7.526008001457776,3.8595766589559006,5.867245266820515,6.724629525169536,7.500472930265639,3.2432702729858667,7.104249891395929,2.4222119245647495,3.451950317460921,6.7610357800273855,2.0342608918770466,3.9914085663255605,7.31973721890158,8.79796833907135,7.194865849868647,6.071934362225286,3.114068311178066,4.7338444173128735,5.4196216163156805,6.049950095042547,2.6160117754448957,5.726932767530749,1.9544890076392898,2.7843306993048076,5.451830698243194,1.6372002966137167,3.2194510188769083,5.904109384335938,7.096414093808763,5.80195656621192,1.3080354468378717,1.0439781541782087,0.7326695464777271,1.0810692192275455,0.6643375993054329,0.835172660696212,1.3214802008554425,0.902973923581167,1.0275705565425508,1.5311215572252188,1.0861545802453267,1.279862173129069,1.6116269198819952,1.5796666842514502,1.227575034679152,4.351307378210308,2.687993645664946,3.1379875411244824,2.6548866875756225,4.22778365321932,3.156337118028942,3.4843184604421547,3.0471683835974224,2.617398017216309,2.8965039675140827,2.281474323567809,3.090626143643837,2.612623073477688,2.641915797792731,2.87067291780284 -2.510160805205321,0.9467727259620229,1.0427984258362397,0.37169287378654153,0.45211901650357367,0.5315872106924886,0.2034584266816819,1.360292732610482,0.7984448201399417,0.3928501105933503,0.4211820170400999,0.8592655696368141,0.36425223309917354,0.35483502691477187,0.6804121432789991,8.081340509521462,10.40631433101531,12.489768877263607,7.113975521799418,5.851690218019764,7.073144692582238,5.776038796251012,9.522661380925236,11.14748189343613,5.760563263128407,5.977212719649927,7.585832805098655,7.641327631071964,9.376146556012547,6.8696223250245065,0.24193279339217105,0.5336218628620458,0.3742350020064642,0.23697252904997257,0.5272954644093444,0.41018918465317894,0.48890586812618475,0.3339288762534295,0.5198526885744565,0.3322963890575386,0.6317687935060806,0.36693808945250644,0.36766882666670786,0.5283245925030235,0.3066878006618935,3.658278907901694,3.122072840296893,2.443273371971142,3.561480152130021,3.252726924465477,2.473981750780818,2.7412318549489534,2.4046673680478285,3.518378431316676,2.8717717624586365,3.534825066980374,3.4722968709149837,3.577774256203825,4.146991709611012,3.630420134693491,5.282035683778343,4.42268713991226,3.3182532916374297,3.955250302384314,3.140934904918664,3.9256826889057725,5.109029316718196,3.9232709471608866,4.001952656245869,5.534297001631648,4.22914663507086,5.042914067025121,5.6394847644912005,5.759029517393816,5.018135889644515,8.127793714163522,6.450952496989756,4.356651802926969,6.575466304445545,4.546246935840184,5.405085517803235,7.865353441419037,6.023775135625382,6.23192406694377,9.214696527243017,6.490679896556564,7.690088442481222,8.690213595905139,8.994397750910705,7.882477692789293,0.4269381287654993,0.4423688334115763,0.4059303184353419,0.1661065019981604,0.29254962160173875,0.39360603832332897,0.2620659527438522,0.28782572965549985,0.2792684729084752,0.24656648296452646,0.3563016053431792,0.2863010710948595,0.4358288612786486,0.39491296593774156,0.3625408373070129,6.900489825879477,3.5362862416618843,5.379907789117107,6.161127715668636,6.877518809269584,2.971198502102635,6.5107917299464,2.228371218891552,3.167436574780179,6.201795276306846,1.860064950697374,3.6629946521162617,6.711440846802059,8.062007580647965,6.597861778530106,5.569089601063009,2.8539568449423873,4.341928133220098,4.967190316632425,5.549262481443974,2.3970935587565485,5.250310007308466,1.7980065285643567,2.555274649141524,5.0023600099238985,1.4972268121734875,2.955123603323844,5.41520414188406,6.505176141446692,5.32220488513373,1.2013692262632147,0.9517078075210936,0.6795652023260403,0.9869812407724959,0.5996415143733713,0.7686981709437406,1.1964662709642797,0.8382227177179397,0.9379445040426042,1.400919651494735,0.9910503198900761,1.1647324892672088,1.476303907125004,1.4382349602593236,1.1222518782731774,3.992271436269712,2.4663338908283956,2.8747140796557793,2.437600406355294,3.876879712579997,2.8987827457481585,3.1978786769940424,2.7957714183014244,2.398159006369503,2.65913481046517,2.0843644887886352,2.838309957776524,2.398683722394779,2.4254041265295645,2.6363849444913416 -1.2994972118182389,0.6148813572551128,0.5237442397771284,0.2944478000296049,0.2856835001012394,0.5393762271126213,0.6480857602353056,0.7546472000965773,0.3935777848266366,0.17746598190464447,0.6364492065880375,0.6589166870521431,0.6630302264936826,0.411770843444274,0.6791622246147225,6.634920314613121,8.294408626815393,9.781778069825442,5.806643199363946,3.579312676425522,6.07149852681029,5.213416899878608,7.437853699498228,8.804182609755443,4.049020999387933,5.268792923561217,6.076890256916806,6.771363320741581,8.599925803917158,6.114264016028974,0.26661365043315277,0.532634408598824,0.38450973963957996,0.32159063570260726,0.364550180609471,0.2872197715056767,0.3833822679802671,0.3274332080232425,0.3895434809303908,0.5187152600728427,0.3500762398808575,0.32691489085462966,0.1840132905118022,0.5396024187197426,0.3453601370393401,2.984156710110063,2.5393288878484146,1.9973160110976793,2.890675638166857,2.6516119087555396,2.0248290174978254,2.240101736698422,1.9658262974419833,2.8754925554027,2.3464435537592108,2.885267723364389,2.8387064092285383,2.9349759198874077,3.401524810567641,2.9747469368316612,4.338288412103512,3.6166679773986083,2.714493397071304,3.2532484247165305,2.5620559682015536,3.208395843418999,4.1905355881606035,3.2370267446178875,3.278101842083288,4.523873704600282,3.4582343465643386,4.1228955932978835,4.629827097949109,4.706808813301052,4.120967001477853,6.656353506755287,5.277055716812357,3.5605198319169356,5.383112635741719,3.716103172629779,4.4214782492043785,6.441545498146986,4.936679002929713,5.098318977837841,7.540288058942885,5.31064740226088,6.29200921532626,7.121052551664752,7.360196490847051,6.455857152661889,0.35531524892928995,0.35947856422646784,0.3304380999443017,0.14612031446431786,0.22738823676378317,0.3125158738109174,0.2097404407367482,0.2368262829654435,0.22889520481221637,0.20254281452113898,0.2901243551043297,0.2319446868969138,0.34906183981415617,0.32292888831768624,0.302506619541512,5.6419323766133465,2.8894771336617047,4.400931686460647,5.035037365374745,5.627709451869763,2.4316914996154058,5.327810629943466,1.8215264222262246,2.5903149629085576,5.076118938984844,1.518505410632922,2.994161437990236,5.495131595133184,6.595308462227559,5.395361502874684,4.5509399878416215,2.331568445140208,3.551869035333967,4.056353553163009,4.540693201632547,1.9640704111480558,4.296517107382749,1.4712196701821694,2.0908463058128373,4.095300538056275,1.2231510854461156,2.4155956864267267,4.435436783410405,5.320105179239402,4.3504710843238765,0.9860611825007937,0.7820541541163514,0.5607585450837208,0.813930910419169,0.4990243008304295,0.638351815245386,0.9871589298248162,0.7000959208674655,0.7698001718150962,1.1424643814959246,0.8154660192466979,0.9519189104167272,1.2180038869906291,1.173531778247979,0.9234623109444577,3.2716219414431604,2.0178579640584484,2.348385009227803,1.9990339837681383,3.1688025655668817,2.375464470210926,2.613087918654246,2.2820709294183756,1.960404565220577,2.1740990733032164,1.7071452775232765,2.3210100866313756,1.9625315732250865,1.979844338848517,2.1463018144181527 -1.0658563698137102,0.579405243558227,0.842650588479356,0.4961599633589167,0.5840236859236418,0.35810491622792606,0.38408767316231673,0.5449213204936382,0.5926019535217628,0.40378784882764385,0.8070377819432104,0.7561950760414143,0.5425596852895506,0.7270817250968001,0.5226164599722275,5.801929999541039,6.926672616544762,8.299907903714876,5.0285191295530165,3.0980200559547053,4.965374030765387,4.385565942393951,6.277417201607157,7.511372416631004,3.496180612036936,4.5587178732158735,5.1983818610766095,5.71678089237927,7.395148540484639,5.158851379322568,0.4724531452738594,0.4241753668549535,0.5959081824532901,0.4305547258397225,0.2979622570761225,0.29207180798520305,0.3128867054514034,0.5932902539452358,0.3172804128099308,0.575927815126417,0.3985309460174574,0.1385671472256706,0.4555411454432066,0.2877167901021994,0.5278913259330278,2.665534494816838,2.257131040351258,1.7775853061622815,2.577386314800882,2.3548817438282197,1.8056215127253117,1.9844981562789388,1.7508689920815848,2.5620837267211622,2.0886748730436553,2.565115106273244,2.533808439536611,2.617427380545117,3.0341860258088635,2.6425907283929435,3.8577774661385984,3.2237802482015976,2.41639556973816,2.901741124343501,2.27278816481681,2.866370881663071,3.716124184219184,2.8833472903276274,2.9164235418414024,4.00078289741567,3.080408153485067,3.684817595292487,4.123769609391798,4.197918417171406,3.648996870943333,5.915501933760425,4.692128504955667,3.1642877643008704,4.78826848979471,3.300034672108599,3.935207445704264,5.720058995584057,4.390086933272907,4.533238987332573,6.690904069029413,4.721300656620109,5.604240152167601,6.331616277666757,6.548094371426213,5.728851026663689,0.32137611129496835,0.32328225773517993,0.2949615290184239,0.12624378518087026,0.1996084970515357,0.274747719416941,0.1834927222411582,0.2095739434352348,0.19823748125361063,0.17845874354215197,0.2588368046905329,0.20285396544821926,0.31529953799314486,0.2929705034646966,0.2744372469351182,5.013633363513916,2.562357881119437,3.9059675029835654,4.475698793864051,5.003223512506001,2.1633229121693742,4.734913880970361,1.6123150397183994,2.3035981511634596,4.509237711648569,1.3448382407586639,2.6667970667624026,4.884756696034079,5.860805726512076,4.794262462114923,4.041764494606961,2.063863738821966,3.1485408058197906,3.6039586624440245,4.035239955053239,1.7463843835807678,3.8162166448784665,1.2983330881935822,1.8582175914229655,3.635120878276459,1.080033465783576,2.1517493596667436,3.94097872973886,4.7250605954570775,3.86336051183664,0.8760504159189367,0.6961801402962016,0.5000811065448685,0.7273346470933687,0.44536310492373543,0.5743410378649647,0.8725101957871371,0.6266486395504561,0.688839212881191,1.0047528141713216,0.7275450529847918,0.8604586807776047,1.0807740138460762,1.0467944660053854,0.8108463504943364,2.906122601598596,1.7900965208075659,2.086665146904344,1.7733991238212317,2.8223398231921872,2.11528481032916,2.331578787512178,2.0277315281868553,1.7494542280355774,1.9308300236527671,1.5200567328795582,2.0665516235145316,1.7379809390430867,1.7596729802843056,1.906679376183481 -0.6878067343471155,0.2933989747482687,0.5829087814958207,0.34212137776608365,0.4393165793072042,0.16829624265638635,0.35389924219808766,0.3954127872844212,0.35517510773212824,0.28367715412256467,0.48965224252321127,0.7032974680633775,0.35066850837564395,0.4995234474695438,0.3299855083582969,4.288773369309693,4.675093194849741,5.7662478143522655,3.4681294425549467,2.20851051476241,3.6773094446868706,3.2383789546390673,4.560130860888895,4.968520294890677,2.247165026784274,3.2428318857004776,3.7289986592232514,4.243079662727359,5.234379811648003,3.71407771761574,0.28983161207766217,0.5702012441603851,0.3844967190284274,0.30740755342471354,0.30419800387765955,0.5155327167833763,0.45584551500277865,0.3853181352728748,0.23286684344778313,0.25517219607571917,0.37900454229299246,0.4354625530880155,0.5218793960185435,0.5865125114577513,0.39574030244182845,2.2227081000219657,1.8284589632363286,1.6492246873146192,1.9538176051401484,1.7865390003199642,2.116855640720711,2.201655811070064,2.095808592128185,1.6246515505439902,1.5081831999077977,2.079316882752627,2.236979177125526,2.3566675570616464,2.5197557021307526,1.8843275164330862,4.377966609757091,3.041597954396585,2.5127048493015622,2.4073635961807147,2.745842435720175,2.558787626272207,3.5543655328186206,3.204577882748056,2.9294296342116657,3.836885040446255,3.055564822301366,3.7727859121478486,3.654495013884424,4.203122574921131,3.4663227183857814,7.02268670608543,4.334147772840249,3.4213025351284254,4.014075781554793,4.249433054589665,3.6490659864997634,5.489099341119494,4.859395310207412,4.4773427136987864,6.455224339371197,4.762779026703896,5.916856855552018,5.727411265134139,6.610851229222938,5.4524495828741815,0.2655409013456765,0.27020959361569385,0.21737189913312407,0.11902122916128001,0.1827442665521225,0.188816468469234,0.1621448020286223,0.19057688061176972,0.21923518710786657,0.16998801025387583,0.18934140804241753,0.1991055307644608,0.2435955249521088,0.29042940885445906,0.21744620379222368,3.8966561036440375,2.314595295466785,3.6335156249682505,6.020880628417892,3.1156984011773243,4.0063412179721265,4.45392172584988,4.288085885259791,2.70892877774243,3.390196328609224,3.3620877121740267,3.2548731080937165,4.04023299941507,4.176981597200596,3.1445174766583164,3.141611212916133,1.8666445800791829,2.929310352043956,4.850661070307721,2.5119994730597597,3.2309075957819298,3.5904296641804936,3.4587767650353385,2.1851814130521765,2.732978366742579,2.710642018196813,2.625229916478852,3.258077358755595,3.366881240058298,2.5346671078391796,1.0158983304780647,0.6572644347566584,0.5677264963947889,0.6051967702793569,0.5955964283822229,0.5656528514955395,0.875656599348543,0.7029295627121094,0.6560351500062243,0.9607916062882271,0.7516284238532833,0.9723848366056816,0.9680737314786333,1.0174869272349252,0.7887735601239085,2.567636737160651,2.2908983213946663,2.5318028773541825,1.737547005000347,2.079073298163768,1.70871540700224,1.650485102747456,2.208697825710188,1.9837806307536587,2.3426039275479504,2.368833098374065,2.348174073434429,1.4523875294519746,1.0558498086228427,2.4215806678264977 -0.35111552345906605,0.2456605738123277,0.3389125747553686,0.25290606547852823,0.3940378241159054,0.318188359307356,0.23999132116968108,0.3266608224459364,0.3385338920951638,0.40947184693180405,0.3364756628469491,0.5535103892301527,0.25466982228758694,0.3367936485423318,0.3806207538924104,3.1659118690011363,3.5996726224430375,4.26911944964299,2.942995531162419,2.102150800180927,3.216268573249468,2.853339180633052,3.618873186722556,4.377565377168684,2.259404968191549,2.8752755887775456,3.7738284041307417,3.356459654542635,4.075000702588835,2.808710131102973,0.3447562380567629,0.37108065160280734,0.3825259717553304,0.3146726053024215,0.2963665721779701,0.43084679027821526,0.5009933149375335,0.1876823573124508,0.26648246268253445,0.1941886301997343,0.19947211401844397,0.41526427116138087,0.44344971897526453,0.3336523993776295,0.3173286121147694,1.8737117115795565,1.8063122568109415,1.6023143913313147,1.8759870874113596,2.125154534797719,2.084981953113285,2.0905638444633134,2.0134560142833187,1.6465489140961793,1.9738891010437596,2.2867524271905633,2.516382898938579,2.305343671627743,2.5749885307885916,1.7542931863010056,4.342689636119312,3.318772949801512,2.616470679920482,2.374989591727993,2.9018606087777363,2.5293508205304636,3.441313434337087,3.2928290094165082,3.183181315712587,4.092875979252214,3.3254415630581864,3.9947911393980093,3.5815266243624992,4.361479172161149,3.4552746636868448,7.278836647964515,4.644004001625931,3.524956973843232,4.09077751185562,4.543106789692779,3.659068434306263,5.570661430256165,5.09895685031029,4.818379853127395,7.0069443186438924,5.180012663368998,6.377576491337487,5.853102892694197,7.044404302527941,5.636312412840809,0.2574938393023912,0.2866805471019228,0.21982671009013613,0.11294208909255818,0.17212922622806748,0.18888000885174422,0.14179097596246684,0.18750399827019257,0.23404611654768956,0.16667019049339718,0.18833768595671896,0.20567636219695495,0.237510797825805,0.2835042121995159,0.21285177565089097,3.956550613039524,1.9767820917944654,3.545979691323772,6.267297745661475,4.044336573674287,4.1407626433445195,4.642601008256972,4.816755667241401,2.7083516721419887,4.484051633977996,3.684461669271017,2.8129534146676782,4.147393703156668,4.913998371711147,3.5395775365331135,3.190461110593213,1.5915719530314842,2.858366798986207,5.0527901882083945,3.2652940608978214,3.3405764831720948,3.7443107805414266,3.8885124397814694,2.183925412953015,3.621116742627429,2.9720176260424873,2.266991017922404,3.3455750431069324,3.96543659155473,2.854474462231075,1.0416261455780604,0.6968938606320352,0.5849459814748568,0.6095938401697059,0.6399830092441929,0.5643150325931299,0.8941735468953588,0.7348813709190581,0.701196667607931,1.046307899569632,0.8171795787707733,1.05145904338911,0.9949100769394674,1.0866671438935342,0.8129842465024208,2.2392000695329712,1.8681090823721103,2.029286429130011,2.206956861684634,2.0041435256092552,1.9779498771289992,1.951551616424549,2.6921848624428657,2.226798255062585,1.7011965332733205,2.2378405588775725,1.286708489709762,1.3597041006918367,1.6778074822833182,2.1459828953730704 -0.46674867127284614,0.2641466038061173,0.48156420164055946,0.3962341478299984,0.3752204137610344,0.41911876132052983,0.26179509943019885,0.4894575909737744,0.351075310586565,0.2698871228540115,0.456185598296476,0.3671038968614287,0.1286560788402073,0.279801409055819,0.2808370003526781,2.7950004293582107,3.153903599371608,3.768884938498595,2.601192605323072,1.8877059681837174,2.8673911188250476,2.514845650290588,3.1899924505049557,3.83661310581362,1.9395673021801663,2.5977544119047455,3.325839494666978,2.8660577930121853,3.5310991160111294,2.4634912481561404,0.31827673138568546,0.3861854024897221,0.24434317707993986,0.19984363957399465,0.5235336980964999,0.32040083673665254,0.3631256074136476,0.2892488155517052,0.2835645351387496,0.38195989664553837,0.32195699011206086,0.30290130045247593,0.3728753932726514,0.23256600605194958,0.8100580946490847,1.6749016440534792,1.7481140444488412,1.7006933645571702,1.765121177140844,1.9930206531603323,1.9752825960701677,1.9497251722852442,1.9274911856909198,1.552329077762768,1.7119747521665325,2.197176013497973,2.328916388743291,1.9034673875356125,2.3408640439975166,1.6642431016411232,3.9173088424503297,3.11338605884777,2.413824213893955,2.1956899871037154,2.569687693612633,2.3951872347188745,3.2190678246222824,3.0197388714852322,2.916641095635645,3.7615502913582675,3.162728667351188,3.710623949557748,3.1968292937231935,4.054125613072554,3.0903841118506876,6.606606712122406,4.228315914694746,3.210566227261511,3.7255656852100305,4.123060073549571,3.3377341324901684,5.069859946286977,4.638304358998276,4.382083499230193,6.368041341362103,4.719559344175688,5.801523550785504,5.311734515360471,6.408364833412608,5.113134291258063,0.2680228811932949,0.33342849167862487,0.19696103275170035,0.06450834448543546,0.133180393442425,0.18003667611092472,0.14084151307640647,0.13968046138303797,0.19668495797377625,0.17784407387936935,0.21551707277179036,0.20717755090027706,0.2166522132172851,0.2761984520868531,0.19451979963147986,3.59462336509323,1.795063639355081,3.2275693809434265,5.701810596504476,3.6768086668399964,3.761376520755798,4.219163441325651,4.378207035259367,2.4621096296056346,4.074179498381129,3.3449757204560706,2.554742286457512,3.7688544553197136,4.467671186507782,3.2163947204848933,2.89877887051008,1.4461876837387868,2.6040997049983865,4.598451018585246,2.969496605385913,3.0343673317639928,3.4030226885177246,3.5348789626718453,1.9867079770366831,3.2901083432970335,2.69766813155144,2.059372038602673,3.040560540374191,3.6059893734593125,2.5944369144952395,0.9419644776718675,0.6368586617903631,0.5352464653466052,0.5586833790411458,0.5777156337900368,0.5192956040164325,0.8154025267241849,0.6711849007186685,0.6374838939380219,0.9494368505224794,0.7487719998474741,0.9589511290609838,0.8983397608510763,0.9917041496688094,0.7332759015958897,2.0437095373436267,1.6995060613325956,1.8401212301414736,2.020540904028992,1.8226752224816332,1.7932168782347622,1.7768187712460795,2.4456663905378555,2.0290604839090363,1.5427079317527113,2.025725968809257,1.1839920774593407,1.235574871529535,1.5348939454312904,1.9473444120699335 -0.2476299447333384,0.17035627004757092,0.36878340170759916,0.23707769346700852,0.301344889782012,0.3041434735539301,0.17811388771308276,0.2830512800826033,0.22877166324548823,0.16423223043470914,0.35241245546109196,0.2639879965984495,0.2092599103281996,0.11175084751074033,0.1401984915338569,2.6194865509694836,2.9113156005074883,3.439863983685546,2.4209338124281397,1.701303652232816,2.598729681293736,2.5595149099540304,2.881577847996108,3.1545350226435214,1.658038450984315,2.4124292243497543,2.920842419828065,2.472246630262786,2.9315231615068953,2.1650148296683147,0.30292520132145173,0.3706488864478802,0.5614434926933032,0.23380796391973202,0.3279681460474756,0.40612992225512035,0.3917474195902828,0.25123443491072667,0.33863637619056336,0.43129426316308794,0.33708400497202967,0.4237632801896717,0.3332629505059766,0.49057457492733314,0.3329472001876833,1.5041041103870825,1.5232401074775155,1.4373119569310797,1.6317140730393724,1.7115697081595718,1.7518851730903746,1.7994630301650527,1.7325819914894873,1.3461639694492127,1.4075374884674454,1.8845660181842432,2.0606667213448793,1.5680378705434743,1.8725631456625134,1.4112025675505704,3.5253687268316667,2.758943565207928,2.077961208125079,2.019071609685326,2.1917759900992437,2.2324132607907297,3.124268039558232,2.682544292100003,2.6389297970567744,3.3798172454129816,2.980301268181271,3.2973324113533584,2.8637590264682555,3.3415371589296994,2.738404312174045,5.950014006802779,3.7997300703912384,2.874168291265068,3.3517205726056365,3.698348893005876,3.0014441350043004,4.5742672409519765,4.17145415304933,3.9435924087932808,5.731502794962192,4.252894230255429,5.2186244034279845,4.777038700741686,5.751045096518393,4.597743979567675,0.17353469386766432,0.24040380400407724,0.20986171916295537,0.05325303745932902,0.13940465497327445,0.21070536054164418,0.13382355625206108,0.09277556359233233,0.13127287990970093,0.2466015672531534,0.24140561043877623,0.21436380918187703,0.23120774074469685,0.16359391864682843,0.14099684421290792,3.239032540819965,1.614944453654843,2.8997802740503156,5.1362323974227895,3.3084313628745234,3.385200898926667,3.7964588254535125,3.941068196632241,2.2186087927630482,3.6641661817872273,3.0064651629449504,2.300012353405301,3.389380138095761,4.013032997035494,2.8930994387665985,2.612807009663256,1.3007830748517402,2.3401289487630073,4.144321837952032,2.672777523386553,2.731746129808483,3.0631893896656837,3.1831504022254546,1.790341238084018,2.960007278168163,2.425236830747726,1.854191282881675,2.735244275121697,3.2402224434369216,2.334174273527405,0.8508461513651744,0.5710484661291503,0.4756603524939115,0.5082085129554963,0.5149526754843103,0.4709256170321253,0.7449195317081434,0.6062915362934825,0.5791984258909058,0.8537874283807936,0.6803338725624756,0.8624217797644534,0.8070418024522459,0.8802750994405524,0.6593163330551977,1.8152538996173666,1.5080316605682613,1.6840681533081925,1.9120242134908148,1.6389484480144274,1.5900706313067097,1.5487480354549126,2.283953968906813,1.8329716662346827,1.3336664168606716,1.8645450458712538,0.9488706945765937,1.0765294387981925,1.3751227719249313,1.7569202896679101 -0.15107220652065753,0.15730431557856903,0.24011723641531935,0.1721854746086922,0.23082971368811828,0.29704091785645553,0.243085257943271,0.2139650708192016,0.260050628621931,0.10617670574895394,0.2784256985381078,0.26647294114892517,0.29297506713326643,0.20801848449303673,0.08567089663695729,1.8315332214432192,2.576134237557624,2.695735467672603,2.017270767318578,1.433002473422294,2.092521875239501,1.9205461981303429,2.0702710532617394,2.581571998602585,1.130291983969042,1.9060806056560176,2.3476837874915475,1.8820105574006638,2.518570289659414,1.6733885669746835,0.268703612263119,0.5760221795177976,0.23331000439813943,0.2930295676950859,0.25578266069602007,0.40030454179004216,0.29573269261133084,0.3550726749613735,0.36983786131538826,0.3423466217498975,0.6647377649297412,0.27040952743928937,0.23668367650538014,0.19982839105092223,0.3267879093414838,1.5051893086684618,1.5707726684232577,1.4194442796493398,1.607475428042881,1.7277271274935564,1.774140923555489,1.772530283281932,1.5569710838320587,1.3307922621484893,1.443156214659404,1.8902456873010902,2.056167652863388,1.4845893305948166,1.9867931477325356,1.3501790607262523,3.9134209328206757,2.9799585867556644,2.2766328940331326,2.4197122281777963,2.7206308433048316,2.3698570345769645,3.3593199868627206,2.6685682589977207,2.9823173249178394,3.4829829187885095,2.9575114665781284,3.822774049504906,3.147958808738089,3.8476588666896436,2.982099166089473,6.7212944672498365,4.10790302969942,3.1263990441422953,3.87888386847846,4.439697530636633,3.1359305943132565,5.040543206129777,4.29318075057748,4.388467877826233,6.150483121969334,4.3345529437805315,6.041501607170723,5.330471310502003,6.650653322535141,5.039648856079456,0.19498572834209502,0.19338906007630088,0.19294302464484817,0.34795914750412843,0.19228234184529167,0.48520810963288,0.18021368860871043,0.1580826314858067,0.28954107357765413,0.1455194392719915,0.15062733032364742,0.16462490629767781,0.17663113191431745,0.18280241719389553,0.2193493491941097,3.27472357753344,1.3969384777548748,2.9192874796558645,5.536935849837101,3.4955793367713337,3.608804408228328,3.968585342495807,3.9106264708297998,1.9020493459890147,4.047517030101013,3.417872462327205,2.533117214525929,3.5959649035127894,4.554699531719575,2.6494459486120996,2.6405208550241333,1.1259953452452363,2.3556240300022804,4.464534967726518,2.822985671175563,2.911006541307366,3.2005331166221564,3.157744808763109,1.535885616243951,3.2676905771286697,2.755810798622994,2.0417136891069263,2.900718791655197,3.67520100921508,2.137574858426546,0.960963665604794,0.6066879333666388,0.5060467183659196,0.5785912254790655,0.6306003667320675,0.48586691689370176,0.82061738874289,0.6116607742490412,0.6371940416954122,0.92188073218994,0.6992394691729182,1.005599940986492,0.9115820342294357,1.0222607244755744,0.7064708923749768,1.7005284883627625,1.7255088364212121,1.9848777958708976,2.1239123399275326,1.8305014621535234,1.7113393424513068,1.691801158877082,2.9414940881305895,1.9362563423761592,1.9481898817136287,1.997922101024255,1.0309063796734526,2.3368555001640083,1.4852256123788858,1.5889436331150917 -0.3158091990081707,0.29884577966912645,0.39969908452962466,0.11027175689542973,0.15548040998864154,0.2385394193244082,0.4204927473623966,0.15964999459737428,0.2120381384014172,0.15168364504095283,0.16772610407128205,0.2963118157225737,0.21459212316953424,0.224074754874218,0.2817468792170429,1.8059141898900544,2.4850266112594523,2.620820696750969,1.6171358654431325,1.1807116884097906,2.033790600719503,1.7449273203288946,1.8220440625539285,2.3057221461007966,1.135239507004639,1.6066007106803797,2.152275185120889,1.7645326043839278,2.300562223733592,1.5773517338505576,0.36018239897505777,0.46317218971693774,0.3041671116854996,0.3428087983205818,0.4677515192178059,0.8230502636104813,0.2882953034570216,0.32235330669374457,0.4759676087865926,0.17980843794644155,0.42328333005911584,0.23752383791124346,0.36410956988499116,0.25151839464094006,0.4460274860549067,1.287551996731586,1.3067172911851677,1.28237515117935,1.0693850949022774,1.2284331097779442,1.6602407676172821,1.4226128960989415,1.3190256919544234,0.9456773518766807,1.395153007222477,1.5500565326653841,1.741312294277297,1.7343187380856753,1.6910341452016868,1.0785494631361061,3.831115844302866,3.0213718315228113,2.483061941276274,2.2280768228678234,2.5106591747262454,2.6164596092867707,3.251743804816244,2.8051224745203354,2.5285424559781178,4.016193987645705,3.0426179004197853,4.026654821314414,3.218557822506508,4.577305775103884,2.709121483366191,6.862681912728447,3.95459319964063,3.24237918259149,3.6193241638336326,4.044311131128649,3.2169212606877053,4.999033724435114,4.33691815230022,3.803672278495882,6.890008029270411,4.48537234008352,6.4835845894813655,5.581490400931215,7.577506074869195,4.783262178830421,0.10088601364696607,0.4500273887479248,0.2088149003443457,0.1671582267020061,0.47268596697132476,0.43546621032374555,0.1387797751039243,0.17605718023639205,0.13448633060253165,0.411676439610033,0.13098299933887603,0.1311424359260445,0.1194562145846539,0.39273088848588616,0.12816043225158064,3.6170934527765244,0.5130852765998268,2.343881662427603,5.1992501030579525,2.8831061149054,3.073347207217565,4.018997778192741,3.3614686126360063,1.3700311428484815,3.6947488613644923,3.2673972416881805,2.3345764018629462,3.924133488164432,4.1334145426243865,2.4871305806456023,2.9153343567973904,0.41475190759004743,1.8934229865928516,4.194253812491558,2.3313893664207086,2.481072125715616,3.241511166475113,2.717526691412915,1.1080870395008198,2.9853456901800324,2.634572728760196,1.8818345198912598,3.1645806604495936,3.3378786083374723,2.0070553149127317,0.9939467267279288,0.5761829993276038,0.5278174318538964,0.5271028491327785,0.5486678942902968,0.4918862867680093,0.8285646050797151,0.6088102307760853,0.5452676558665139,1.0142265012548575,0.7347266041589229,1.0819905316572693,0.971634405025386,1.141871159951875,0.6731881747969318,1.9516020823839462,2.011815806049185,1.8869482941248856,1.7907506068377423,1.9568795946409105,1.3674238702072241,1.7986033778830763,3.2390705959992774,2.280338056127537,1.883880493614378,1.7594716852392858,1.2077089046067366,2.5066172070068404,1.4226826505306722,1.8795968646609835 -0.0890666214239029,0.11036492151311746,0.288399999236744,0.15938980269038552,0.1339373264387869,0.07086109524891056,0.25610704554529684,0.10739954339798473,0.13084895127533908,0.19955713610658635,0.16781275097453835,0.12014342193933315,0.12222277405699716,0.13736556585337778,0.17359607842243288,1.3670469920999422,2.045153027893874,2.359995672039614,1.4844171301359645,0.929102043705315,1.499244220330235,1.457916086526589,1.3284228615228542,1.7466766232288187,1.0225000778246573,1.444655119461055,1.7825744208183452,1.2755964489718858,1.929047940986341,1.3993031121388975,0.254293487017077,0.3715981016014311,0.4627699173184465,0.3409308345189954,0.39751844423150884,0.33736382158763834,0.3797177638787991,0.3240950281520077,0.26284554412159605,0.5494320311893985,0.4372459872688617,0.2838915422364388,0.2466421401331928,0.356245315148832,0.4302849713042184,1.184044280904251,1.481993085944403,1.5897841214083965,1.2697656885576878,1.1621699188026664,1.467235246801654,1.5593664077619798,1.1486233655309743,0.7888136667414218,1.4216389397437486,1.4827408709166328,1.5946659315318594,1.5638674170700884,1.5337678861627766,1.250227251880397,3.5628606631894666,2.8382937886876918,2.647708147580529,2.3387180295884322,2.2425992811794444,2.265222965010661,2.9789520911871357,2.4671395006249033,2.0975005502814383,3.6436545555512843,2.808928220131266,3.8448551265793736,2.9769330559822116,4.607981696012759,2.6810843519597984,6.534192710070362,3.7684172157858873,3.1034533731979774,3.4602140015530978,3.847364231098922,3.055921802728016,4.7617427827057845,4.124792840120771,3.6105963672691486,6.5537441455419145,4.271877452159872,6.180476977452056,5.316490300444871,7.226814545011544,4.559499844363352,0.0846566928106423,0.12562988379192075,0.3485446525837172,0.28089756735478294,0.1574847593269143,0.20413443963316422,0.10012796550830706,0.14430107065870862,0.09970558726089923,0.1993391631341659,0.1022292433737285,0.09084146499093283,0.14372409596412944,0.3024776301274945,0.3867562238544088,3.446438325566116,0.49638189683075673,2.2336703135979565,4.947869406394369,2.7426155339177227,2.9307057447611267,3.8341486689288504,3.200959903836591,1.3075589914126338,3.5201892653590496,3.1074836773653245,2.225227483598869,3.736370079019898,3.9284177032300107,2.369100980860507,2.7755902572285422,0.3944699792352737,1.7997935377105003,3.9911644879498884,2.2132962629628796,2.3631255922633847,3.0919570609465787,2.584698186240709,1.0514023697169221,2.8422151519409997,2.5016242701536773,1.7891475903633842,3.0110438467947906,3.169213847177656,1.9072800225918838,0.9473614540193671,0.5478842628198644,0.5065004269083624,0.503336237357932,0.5148751595539427,0.45738907290056796,0.7897595582841876,0.5713453288531086,0.5069251391032227,0.9615737500703295,0.6990033242792659,1.0369906467861487,0.9254007192082663,1.0960762543468907,0.6396864331255996,1.8655616772847436,1.9215740058017639,1.7982125474957416,1.709238461642022,1.8678531316123643,1.3130241748107132,1.7143332190733727,3.0852630533401078,2.176947266723199,1.7961750796127474,1.680197043300875,1.1600884688604034,2.387447502879632,1.3627840840681948,1.794038508753663 -0.18002135914525305,0.13869972780425446,0.3715206820402596,0.17358050129348027,0.2036667046988298,0.18501212314279405,0.2814356915020359,0.20408237936645132,0.1542179867887199,0.160991628123672,0.22779875203805386,0.11695887787604574,0.16865209661722558,0.19967145372591083,0.2955351406814791,1.2976550773557125,1.8987757748105882,2.4552583711665177,1.4376860957156514,1.0915711270129216,1.5706894650284429,1.4455138958293647,1.4287683694526476,1.9065047465463165,1.1473559329656702,1.606407417943716,1.5479679846886243,1.26159271761133,1.806840745114379,1.6890176390683305,0.21782613591151478,0.4522248839835755,0.5335541118359965,0.3054358471591937,0.5142775261093318,0.4016354235471442,0.26307219280709304,0.24085052363695364,0.4410998557086968,0.23648272489351857,0.3496441772377718,0.32689932885469086,0.3700340113320533,0.25876429374457377,0.29519462305472866,1.062578686364881,1.276460881390851,1.4872966625116857,1.125117978398499,1.0855547885512824,1.3674974909365356,1.5590274756365943,1.0379722450740487,0.892967827930214,1.234549577664396,1.7329118657737448,1.2032317846860274,1.2488080719557415,1.3297128633295052,1.3103617852721587,3.3575975698785103,2.6809324602316047,2.532021011467373,2.3131765637208144,2.1912587617066044,2.2456912339411708,3.2106020547100576,2.5667771895539992,2.12838461857632,3.4553298488590714,2.865088324094291,3.615747173928595,2.8536227696274343,4.166850248698014,2.547235944601279,6.206627598549398,3.573722719553478,2.942799625006956,3.2859361782351053,3.6517272531302147,2.9030559508232114,4.53983176429491,3.927446314683732,3.430461618102715,6.223981255309036,4.066587501216519,5.868461973086475,5.046587835799223,6.857563588750663,4.327797644941172,0.07850624111623293,0.28631189277964947,0.4052255773384481,0.2564554430335588,0.20374541082699835,0.20842990807756778,0.2735064764585158,0.17287615509479265,0.22175481644852135,0.13846081651884268,0.18126656538638625,0.2261707022405824,0.2451443048601163,0.10894559372885697,0.15275034164613682,3.28105813508947,0.4609586055684587,2.116508184222552,4.699695963752316,2.600346151845604,2.7789320938547686,3.6384206783714665,3.0332595661763837,1.2358471303946124,3.348097099485316,2.9551639718992377,2.1032406669679165,3.547264042358935,3.736842925351851,2.2488393879340083,2.643722387017097,0.37035575850847735,1.7078326116992288,3.790711521252816,2.100418258951131,2.2424842467227313,2.9349542740960364,2.4507378470556507,0.9970995988651319,2.704479201418719,2.3806352546266787,1.693445047379004,2.8595923895964175,3.0154706969470984,1.8127975157546006,0.9024822863290132,0.5151820970597286,0.4772483821604414,0.47720344352740385,0.488685704991337,0.43639263420822344,0.7625571101328336,0.5517182620033797,0.4836348263790785,0.9136630119424678,0.6721403557847482,0.9800405354479765,0.8745516497898187,1.0356806086251384,0.60722783500717,1.7782699952668706,1.8248381693678224,1.7089254547207209,1.6286875425899436,1.778125114012471,1.2530147414498929,1.6271192801841146,2.927989324813143,2.068058072329223,1.7136899686769447,1.594494375277531,1.1071368482416364,2.2669433168446975,1.3033542194548082,1.70778750501853 -0.5243717685700878,0.11722538577006904,0.30610642031292423,0.12711691283388854,0.23054341734805006,0.1685777777083674,0.20548128390707274,0.17726892563372276,0.1400821791491399,0.15359173924932226,0.17508079720777023,0.1573317358195907,0.15707214771145986,0.08530023515303974,0.31014149745276937,1.862142391050815,2.0888835344901198,3.051161324738529,1.4610729037447256,1.499731616595626,1.8869655669924648,1.569597207290022,1.4295721993145256,2.2615261923606855,1.1184446909171026,1.6980316680315233,1.7661137456217777,1.5545663151024542,2.166993706689461,1.9595101205795276,0.22982236866372896,0.48678482613174356,0.3232519672002918,0.28587510475793043,0.4067814311063106,0.43215860890290947,0.4868293559092044,0.2985577725018087,0.4594291187289049,0.21442383436144452,0.46835432209021577,0.38905648265327536,0.39678222437846505,0.41344683889347544,0.33009861980585503,1.572910575388977,1.5360666095404396,1.5063405207177079,1.1934400988464444,1.4117410802342327,1.6301854739157922,1.3150781669182745,1.1706331226512074,1.436199883134122,1.2102801531485907,1.5091344999563323,1.4636729177780794,1.5183492364997164,1.4135455244243906,1.470530175455697,3.6039010231553847,2.6182218409454654,2.8865567302127846,2.2341816957637812,2.1541459622871098,2.5197454263774817,3.028231743753791,2.6627343119756235,2.2417601869077806,3.6784681971039803,2.5997173525565205,3.681769278381366,2.9241157269061704,4.26457442868172,2.490093058659334,6.5087287846205415,3.697287255491254,3.1870209472898514,3.4083754054378312,3.808461322545409,3.1307720959070937,4.624790472645193,4.12014019766045,3.6396521222408507,6.494456333988542,4.140217356470644,6.085088301988414,5.24020210789324,7.085908167469292,4.50080923277176,0.1072866169894619,0.15304601241452578,0.2724951854495016,0.15620707565349087,0.15685959873760041,0.1632995532706127,0.2502068608018001,0.2032885511850276,0.11341008411757104,0.19078445681081777,0.07281275602012614,0.1078789604839273,0.19899305070712253,0.21395814668234797,0.15993307074687602,3.431316986936925,0.732039749613854,2.179550437636434,4.891508716378768,2.661257204563871,2.93409040939075,3.668741674087826,3.085648885519967,1.31390507938992,3.4420183928514705,3.14602215085233,2.1826236938727535,3.658570546579787,3.731895792952762,2.3829780837017167,2.766918163525767,0.5992256301062016,1.7603976832882795,3.9461300775686476,2.150439673707497,2.3706368143433307,2.9578136476769394,2.492915113269221,1.0635380169321613,2.780623793535002,2.538115278237469,1.7595504740731203,2.949906566940768,3.0089917208842403,1.924188170821273,0.9526270147040934,0.5338426993839828,0.516650860325759,0.4912767968422955,0.5111636143795489,0.47485442755077195,0.7757941363706425,0.5813929640380485,0.5192097204222208,0.9556164380322235,0.6868134385343624,1.0132564632014653,0.9066004709730434,1.0678045079257958,0.63461402428925,1.9061368598416364,1.8239795570908495,1.797306126802727,1.579701273987613,1.811794192003931,1.4613722345501086,1.6432005477892773,2.894307979796631,2.0824706957282393,1.835958885685761,1.6218808248375227,1.1047161728894124,2.322109774122738,1.3332336100450346,1.775856179567332 -0.011640615261173317,0.46909814407594863,0.05909428042484688,0.4475522804445128,0.22302422085263493,0.35753417197864645,0.27770952694005696,0.35493923419377793,0.41956811160368246,0.39019653628437967,0.3468426437216521,0.3838821248156878,0.3825172795676954,0.5386201516281256,0.05027671025245853,2.4731143650670866,3.183755549324294,5.032381129766838,2.024595762397232,2.7115285392196506,2.799726354740561,2.4661197333393585,2.3952007150552617,3.819639244796699,1.466656792365102,3.0177364579170236,2.903166518961569,2.3297658032137423,4.064195460370783,3.1406704523040645,0.38441206084531304,0.3624538172025018,0.3440025565763082,0.3986478370256828,0.29632656064552476,0.30262940072929795,0.4151031128735354,0.4165170894923718,0.31035477021290503,0.3748900077166359,0.41401459796513174,0.3605118978665299,0.3382962652332872,0.35298227643539376,0.3517562286273529,0.8633037448353025,0.9622536263055598,0.8573619537310225,0.9637188693730216,0.928543950899654,0.9725704589654135,0.9261026098473842,1.036692215780812,1.0897073702985582,1.0335497992745535,1.482331001355106,0.9224696791369456,1.4945966566392337,1.2753390264069409,1.062686809503386,2.512217317117021,2.2709779406599875,2.6225237094268175,1.6572205765713373,1.9819346270619889,2.5396696484415124,2.7710604113996347,2.282626279737074,2.195910206882507,3.028771742423517,2.828386358213346,2.9839561317494043,3.4348737617579808,3.6272785517110906,2.0828992676072735,4.7841939532488995,3.2340071420019836,3.147203530906809,2.634122313081461,3.3249737468268816,3.2593466765088572,4.116295683112131,3.612094889797427,3.3489288100600945,5.373977176764297,4.341126557353686,5.069995344405431,5.486302618659476,6.214687000149511,3.698073094449246,0.06247321989324506,0.14415792990502724,0.18413749136162905,0.05022514640789143,0.18248606915971852,0.14776072209183996,0.23345437188541163,0.0915717975541718,0.2012853621104318,0.18583206736566585,0.088917019797343,0.09644047863163566,0.4043372482527335,0.10037243202820713,0.10195025035606703,2.7755748289682227,1.3607501710077416,1.2869123952574812,4.204750478533672,1.57365460095732,2.534792015030005,2.39583974908938,2.4698507334955453,0.8794278926900487,2.536370654900038,2.2861194170140005,1.5418245056584097,3.147936739957042,3.014682581463196,2.086588554980807,2.2394435134568833,1.1060075280830126,1.037000375798746,3.395228597221203,1.2692219738750965,2.0490225122281154,1.9300658804104867,1.996028924725811,0.7108177363381463,2.049035935321048,1.8444690009365508,1.2422864716136521,2.5409822612743795,2.432592464835222,1.685979570198566,0.7015870998092469,0.47968643882209183,0.511146881539063,0.3964881958186257,0.4485701073659141,0.48521547936785575,0.6720711832410733,0.5409768785133073,0.4836394059611533,0.8024028115560325,0.7186403829149453,0.8331196076633997,0.8996572300175416,0.9522707677439579,0.5430680746778686,1.3042395640884266,1.3275269337180315,1.290235734885087,1.4475978291858314,1.4171043846506937,1.5352021347253424,1.3593721132285514,1.2341618680279065,1.6467925429984314,1.7357615347420394,1.1673112690389862,1.6656620495925614,0.9656239563542304,1.6605967236802306,1.6421246227328632 -0.11604516860129135,0.24938261954228605,0.2218707329202771,0.13361077366679244,0.16163262353674987,0.25603385726327516,0.2590014211170971,0.2354524175829345,0.2358477990254182,0.2071223196862427,0.29954881971747344,0.25722347522283373,0.1519452647950993,0.251869235559481,0.18324540494111496,1.3468398690945838,1.6981832701049957,2.662765002733935,0.957460274255667,1.4766809735572264,1.5780273096804847,1.4616861464201252,1.3972874200899823,2.0598903467182845,1.066666756710923,1.893604740519044,1.5365017813313984,1.3553377052395847,2.1814803175463133,1.8186298293750027,0.5432378472998599,0.17576184472303494,0.29494096005027537,0.3299578121422137,0.4818104009488101,0.3288696553378486,0.4628267952015949,0.19149659190433013,0.4149867342961527,0.3273349730077375,0.38271653322260957,0.20385562541211272,0.34156494785898067,0.1603018636015853,0.2678825882112254,0.910101766444099,1.0444381911725809,1.1583869478928923,0.7462006975365845,1.0274953856960176,1.0248174529340164,0.9507775051917167,1.1106590378970869,1.188702581250413,0.9869692883783947,1.655279536099164,0.7116673212093199,1.4297663636067461,1.2873706065120385,1.1884992005064734,2.519305179284061,2.5784205165610996,2.86210771261516,1.6462472570033637,2.1478862245957995,2.714222659592478,3.0211789188783733,2.364366138753306,2.6824481959942186,3.2928956046691917,3.0839742847180553,3.044484749990072,3.554983496107867,4.116809725732155,2.0385846996275063,5.042948611506878,3.4202197763239988,3.3280298747700394,2.7734795332689375,3.5090549421916672,3.4410231837133916,4.346510850072901,3.8088682957368833,3.545312556255082,5.67446220948028,4.585895116703253,5.346139740024574,5.786531390509634,6.573209402670274,3.8968478933669237,0.12442791894412737,0.14835742358338175,0.11351966478957248,0.08834229285061279,0.15734385038194415,0.1644386917589902,0.2813885786095485,0.12368863249441067,0.23554010805275288,0.15249326998590354,0.16173413655345678,0.11324138067306647,0.2776238620560356,0.13419123360964802,0.07538386834532186,2.9341562659266245,1.4376759970669337,1.3623180570127744,4.444277226426009,1.66272611392733,2.6759934507500494,2.5234454927938166,2.6117123255449095,0.9281421676150337,2.6760922252596635,2.416285484658052,1.6251139491679107,3.3257956011932253,3.187442559632278,2.2043666525742505,2.3667039268278174,1.166656418409708,1.0962076745570424,3.5889350692135458,1.3393393344757896,2.1617825450434403,2.0305615306956657,2.109866505586012,0.7478464049550402,2.160314512584917,1.9483670038063126,1.3070774494532733,2.683860853064409,2.5715650877787866,1.7797297610505525,0.7336306289370939,0.5030546967928681,0.5388849230420227,0.4007658237805211,0.463788449921113,0.5047175996573724,0.7077421014609958,0.5614279465174215,0.5094128749583136,0.8493753088996532,0.7623207901048701,0.8797098447735678,0.9508645991644502,1.0223327711339318,0.5628394766749503,1.3814674700730258,1.4104671868145073,1.3674065587914133,1.5362284332763438,1.5016575461294923,1.6253047460414043,1.4399124317142884,1.3130374558827203,1.7391638721811775,1.8370810421282142,1.239380501074436,1.7648896495148918,1.0288334616840786,1.7567785424833313,1.7350466522510481 -0.15342304153907788,0.19405490278624846,0.1983873072702944,0.08935101526497846,0.18926046088290355,0.24772272017338282,0.2156676072646872,0.2661981916616229,0.20760162252408806,0.15202859266184757,0.28000362986137023,0.3910906692833196,0.1930072688076909,0.2844893716788049,0.1648146684312539,1.4945380909227188,1.6841993165336853,3.3504283450817347,1.0078702903335086,1.6750870191805456,1.8111628000758864,1.5936317756888925,1.4616373008580485,2.4528608965501504,0.9581219485538306,2.0648527150948377,1.755838389905058,1.462174127585239,2.8618948041351837,1.825375500541105,0.39620899503647666,0.31008507368823957,0.30743396001544776,0.45089424744082696,0.28882846557975433,0.377141587455092,0.4923362737263046,0.3111965148007942,0.34790572667508074,0.5087272080846155,0.2294317995408745,0.30703709115192396,0.2786730607689868,0.369982174197271,0.40641648184553714,1.1391789745624545,0.8965383236510955,1.4022482834038563,1.1031320494862213,1.4027018156033584,1.2979355907275305,1.1567124589053939,1.3176894264124686,1.466472224596874,1.210643900736119,1.7283196469210107,0.8190632976610537,1.3267438431334602,1.456022060863565,1.160188896565831,2.621689327877843,2.5753213431478565,3.2762713799925147,2.1520812037328674,2.3718652530898052,3.0070871122553915,3.236018167721558,3.0672937878302364,2.9996545606017286,3.478552095346622,3.6892010516928635,3.206285648734219,4.066448092650029,4.472913485813823,2.2527041046297365,5.5662059102102805,3.764611110795162,3.687279754817804,3.0762809367978354,3.8781466630522266,3.803881149919655,4.801755210765263,4.224217052660146,3.921305508971434,6.264174540571134,5.082404232262175,5.9043562472733635,6.405517016255777,7.266866732432694,4.306469883884529,0.10116132312968565,0.14407483855305403,0.11697259302728846,0.23476746761848782,0.10808082210471226,0.12392511438614241,0.1400930481927529,0.7790020208274936,0.12928498433608573,0.14589193917750126,0.2834568169877614,0.10482262294570675,0.4720443599746133,0.2160606326257196,0.1396338933310481,3.2478226831650785,1.584887902872581,1.4993725577365624,4.910338062847845,1.8431505544124356,2.961800171152921,2.7909404234746407,2.886149906292905,1.0302259136305123,2.960954032268159,2.673731448183152,1.7917630781656357,3.670017233315874,3.526669082994002,2.439605603653868,2.620017321449868,1.286162195968878,1.205724470641464,3.9587796515687854,1.488490310267645,2.393306485130634,2.24582992646725,2.330286678515236,0.8353124814996817,2.390481184481161,2.156806107599343,1.4405530193933558,2.9561145786241796,2.844409283611163,1.9710636237286008,0.8079955357952018,0.5472271837027309,0.6068500599902182,0.45530375327716194,0.520648267018507,0.5649720351845263,0.7830661835459941,0.6334269244649959,0.5723781158793535,0.9340253058082494,0.8552851488452704,0.9730632325072874,1.0547821559208337,1.13072990887582,0.6258245474219957,1.520528274180012,1.5530861320574425,1.5043474139233126,1.691430522060606,1.6538074001249783,1.790736713004741,1.5849257633820366,1.4444296136576003,1.9188117149901711,2.0258204633029586,1.3631556050036073,1.9476251632037875,1.1290372711036294,1.9377769186074798,1.9125837816253737 -0.10012770541882551,0.19026488927788093,0.13007787033843984,0.2988168496937823,0.6481666120096609,0.31617683557594256,0.10458699581251277,0.15407696017795847,0.14558827687622855,0.11771623741852479,0.29198340413856627,0.30852906782211764,0.11056488499672004,0.15211280481223122,0.1688047106109525,1.2831074929576853,1.5121503794849325,2.9770327344672687,0.8709188793619551,1.5149749379917306,1.628963590233834,1.4182941260685462,1.2939272639553199,2.1977469465449113,0.7837345175033927,1.8974491805574238,1.6283283519688894,1.2178791893435013,2.5020873628314835,1.6618621743865716,0.2549464925840639,0.4410369414364124,0.51631908913998,0.29177159628011146,0.30262413786156117,0.38166900168897666,0.4778260900334775,0.38332997270197305,0.46281583758083233,0.1686626445428927,0.9038366038165739,0.41249224800999296,0.5307296384653437,0.4889669644272941,0.23528975217457543,1.1098611995803611,1.1099502049416174,1.3407182173753425,0.9921753500497985,1.2490332973435796,1.2056598884859273,1.353401848373405,1.3373196219926935,1.6018479878605898,1.2548128862418475,1.3706531947578435,1.2632949084093659,1.089612234669489,1.1678634616951056,1.3143008702344456,2.7209864015548306,2.5567488105303555,3.5711560502990083,2.186204152834901,2.631754768599722,3.180273491770707,3.407368625797331,3.2437351245883175,3.105145551038098,3.592215629072506,3.617710646395837,3.4765404473083907,4.031131250359309,4.63512220255906,2.5782708413256312,5.830723850829102,3.936010814531319,3.8688139117256695,3.2211292438984707,4.072810828317386,3.9862548338806847,5.032824483070125,4.430702591257216,4.107574936070234,6.561458064438064,5.3105300401766415,6.1896879365903645,6.697806301102686,7.606695179080825,4.5263625439849635,0.11826571122900248,0.25584818730348063,0.3874185930980454,0.14406679415520504,0.14871411255789316,0.2468274608925597,0.15277930102359327,0.1582457474003729,0.19278443426926395,0.11728901852019694,0.14390260869292967,0.21256813758414728,0.11458740817070753,0.17859700460612582,0.13811609590565238,3.4080336295387275,1.6648272432563889,1.5666458878788967,5.145993922420898,1.9344666839057387,3.101873436402135,2.923700335763973,3.0197817731282637,1.0789918119583253,3.1077294573166996,2.79028929571999,1.8769924192926375,3.8467774482460735,3.6897168309047266,2.5567140468886564,2.750835921615683,1.351993713470992,1.25926037211715,4.150098547280041,1.56311272115118,2.5068539924505138,2.3531198968336438,2.438019600826603,0.8748587045512508,2.510520829824576,2.2493998929673173,1.5093088690265828,3.0995437905937293,2.9757156740004786,2.0662433899395443,0.8485857426245614,0.5707623908634414,0.63900027009456,0.48104921557813324,0.5616282112330722,0.5945598907709748,0.8233222881422536,0.6708285974976664,0.6019759097595896,0.9771070684249538,0.8831936136920028,1.019402841847834,1.0906049961959725,1.1741896360115391,0.6718106445764593,1.6022167432725891,1.634677461655853,1.5801052041430548,1.7787220526987184,1.741271759623242,1.879190730575051,1.665967361175837,1.5186455255019604,2.0124103578813672,2.126219789094273,1.434907357142154,2.0428043408491634,1.1925435984225787,2.0332020556499826,2.009174793204949 -0.18067256047852298,0.19341318036947167,0.11772754626430075,0.27263622303757573,0.36697872015421484,0.16030700372983725,0.13518223377734512,0.10721462893354501,0.19906559588843953,0.2477566520463537,0.54310560381529,0.2049633419626649,0.12839424209272887,0.1256400320067606,0.09836902374240244,1.135576874948066,1.3537719482147117,2.650536779484545,0.7897071072634808,1.3683773080814596,1.4529180332228537,1.2526558010702669,1.1541581149381093,1.9512175046355786,0.7030699978017202,1.6946235501740454,1.4638269315566506,1.0912801216654782,2.2330200555076516,1.4836737227153414,0.48139183291979315,0.6001041945942656,0.6169987280097683,0.6927028828189,0.591144694043898,0.7219783053374563,0.9574281777780892,0.6442207520024625,0.49310718706954637,0.6897961646708871,0.8517788712446309,0.5425226822249202,0.3655525447427549,0.6598753086176801,0.5359190288224601,0.9866571662521607,1.1060730911014,1.0760459985791175,1.0879937355367486,1.4333507177204339,1.2569757453176116,1.2064420936886686,1.4054124723470183,1.2262320145757584,0.9226205043790562,0.9696563680831268,1.2796827996769906,1.1689800099338106,1.363783167188814,1.3523045401966092,2.835170887877137,2.4758786996363993,2.982309334420861,2.6948100011746514,3.110392796445276,3.016675028183718,2.980709641429731,3.3561106280633197,3.0300620787246553,3.1658171955226466,2.8956579028101603,3.5112807491355063,3.629242501859543,3.732331348438094,2.6911958258290998,4.8912049166210805,3.608779558384137,4.065210296473873,4.12067324167751,4.647032478717511,4.38735687108069,4.433958316144299,5.028716200995779,4.582664831430929,5.228645026466,4.46754278034804,5.680245768904103,5.927114851915391,6.0808902372559945,4.259845830904977,0.21093511357262673,0.2898080501060904,0.10060453328183565,0.14990288524586542,0.538137975180652,0.18794289804569703,0.22500612628674377,0.27233056993789795,0.13811839871531253,0.16571060486851347,0.08902479949979136,0.3485879009878664,0.13803350176315202,0.292390080043945,0.1370218968727447,3.02540437706754,1.8153655789094434,1.584038248559586,4.525923130763791,1.597701479612978,2.6464243443324498,2.6301299773369236,2.5468480181248556,1.2237755408195063,2.705748251931713,2.464992837787203,1.5404176535271858,3.440405305335071,3.3147610915941614,2.377581425770511,2.442238322703943,1.473166000475346,1.2743384903172763,3.6503956093333687,1.2912876336023085,2.138728829950148,2.117255381501884,2.0562795406474264,0.9914133944632066,2.185827661575139,1.9872196884422115,1.2385115504001734,2.7728913525575747,2.673647894108543,1.921851077668817,0.7325816386530868,0.5522827360465926,0.6533734065973373,0.65413678587084,0.6683122931305321,0.6713517883672403,0.6971077232959877,0.7662151848997172,0.7115549552138849,0.8028537384131899,0.7385076599157502,0.8737475200435394,0.9067464664992877,0.9228066281246659,0.6491362785095901,1.7578065795248268,1.9858854031506226,1.804713388510647,2.353196978415857,1.9399079314035519,1.5579488820203296,1.2885868653449184,2.1239484374819746,2.1181044843518895,2.0989068762749423,2.0540756005720704,2.230716845171378,1.4672139872204324,1.5768345828032095,2.153769439768153 -0.2966169433468289,0.19472470810959766,0.12073305234088212,0.14919721245989576,0.4053215734411299,0.16342104126019544,0.1500085839703838,0.05242383396647679,0.12122226886479034,0.1967819304890035,0.31302521805750816,0.5672170578241723,0.16953624662946995,0.16722568742461283,0.06872144351324155,1.5434450605153645,1.8939371966604632,3.8070888284567266,1.0144736052550756,1.958245458212801,2.0643593589409717,1.758776751974263,1.467009344183388,2.734501614635033,0.9297360854558823,2.4058035210941706,2.1403477549758967,1.5054306030353077,3.190631065522627,2.044907790078196,0.6555312713607062,0.9701706453848542,0.6458195426521038,0.5493679844663163,0.6151996468918387,0.477633632250102,0.6247264037653131,0.6850946562524913,0.4410741141347484,0.5643797713921102,0.7413215304064984,0.8521761163149913,0.7273513936094181,0.6971689922067428,0.7045533540945724,0.8087207743000436,1.2628358889352738,0.9511937370309198,0.9095738135898553,1.2514865261623114,1.3387144805141158,1.1818392487073457,1.0317812166943534,1.1555142603395945,0.8611233263071466,0.8534607302767244,1.398789491703556,1.1014346818269287,1.1345132533134474,0.999838486540056,2.4994572499940793,1.8586826485378016,2.863557023107728,2.6549334391676536,2.839129591407311,2.8754139148230813,2.52130900544984,2.878228022852085,2.9891204033288896,2.7149176875196113,2.535980255499484,3.1698931126708767,3.593754980618668,3.6750372153830533,2.3171758825299396,4.449972336093671,2.9511590633372307,3.9446071472505753,4.066630572121384,4.407274213505932,4.2702951434323415,3.9525625140451712,4.471143578587844,4.756675992575917,4.756833378278335,4.080810732834128,5.24502291243386,5.820525894987186,5.942216173845903,3.8068895209934386,0.14989023245393984,0.20770629611678681,0.21130545031782927,0.22803455497571284,0.21848170740311285,0.19150077242553631,0.12668795731624397,0.15774059080428943,0.05019631053420193,0.0879504494083216,0.08760380687483453,0.2296408871410756,0.2573311293726384,0.1698193663829022,0.147215216652634,2.8780297603079044,1.9038689052208886,1.431781434498112,4.307808551713682,1.5231881981739512,2.6918278247489407,2.5988304271038496,2.4218353933973664,1.331751383267509,2.6105709522813547,2.285271014853783,1.4894577246820608,3.2058092041438586,2.9972647314697953,2.334795051690195,2.324822753988997,1.5435635686847895,1.1537558851172196,3.4760978001389278,1.2323807063157541,2.1747774890168867,2.092665170730495,1.9567569609787874,1.077679773537683,2.110020600704834,1.8443219555169732,1.1987714157811533,2.5859657017396858,2.420509330799462,1.8877622797917113,0.6659208012701748,0.45986851081656965,0.6324337436749782,0.6344758380083079,0.6460076042278646,0.658363398238103,0.6294615583265813,0.6851015353892029,0.7643828229318207,0.723827743603385,0.6702401214146941,0.8038537464689501,0.8714805260384949,0.9018048808353532,0.5769075512897112,1.7793217954567635,1.887804821516069,1.8004855337314483,2.451770686127658,1.9745971050396631,1.5269572846626374,1.2668156538325932,2.324834406113294,2.398573699380039,2.1249133106242923,2.058280608601768,2.176889530136448,1.2556231574827517,1.5127360398250052,2.1122189304580434 -0.20503104184821722,0.36642354898055707,0.211105969045965,0.15796579639126584,0.2548852422784863,0.18125729695069942,0.10298640470399137,0.11635187835546701,0.07481664576131655,0.10510137540033894,0.26251468602191164,0.4406844847885849,0.12849640033752258,0.12930414083233827,0.10743067848217264,1.5912887232465525,2.154287717980427,3.7588777690707538,1.1141771915666154,1.963359516763786,2.2076391993231987,1.932861394315622,1.5931162782612747,2.6602120225690893,0.8534302470653632,2.626431544017009,2.17549995808572,1.6377475116101508,3.204800367278275,1.910392516666294,0.7561498258234969,0.6064481021070031,0.7883435375284207,0.8513205755839716,0.6505679096645751,0.46467011521386287,0.6604244062673241,0.8225871759478052,0.6513824287519614,0.533197526138883,0.6066840781305547,0.4694700932803075,0.870566955874746,0.4412834955719507,0.5703564285842995,1.185654652747629,1.401220863610948,1.0210243132778947,0.8851622565392321,1.0136825518033354,1.2543579707733663,1.3447075437073355,1.184281296460095,0.9725056770174447,0.546805975882893,1.0061429041174574,1.6819134609250406,1.2042477492878962,1.2280494976899974,0.998917952660757,2.857857180108514,2.2529369759570907,3.042531338608405,2.8161092602124342,2.930167200165233,2.8388932367739015,2.930079355588403,3.0048593008587257,3.2193460592484264,2.9622657088191757,2.7032574364122937,3.5318715333757504,3.373784948582987,3.6875647334270854,2.686250483144757,4.685548011904579,3.110762404421415,4.15123530810923,4.277390332176525,4.633011462721452,4.49122625561496,4.167457991558296,4.702996263259473,5.008214164651173,5.004005708033065,4.293730399187769,5.525548204705249,6.11287341068078,6.250514711741149,4.010776154973267,0.22420848918627076,0.12818393858188723,0.26454237535420044,0.23513388583668596,0.34019342094098526,0.06860818433067127,0.11734351141744437,0.2725304857577077,0.11151560080088663,0.12594933058193203,0.1089829965299593,0.11751170034191419,0.13187447561861865,0.10997838207997823,0.1454530476298384,3.0313874458978,2.007279182752807,1.4964711404970243,4.530210171688892,1.596995610537518,2.839867450444363,2.735369405643966,2.5463162369084644,1.4004463750831697,2.7492063203496757,2.405485903218813,1.576256008294321,3.372952364786221,3.1576166964209484,2.4640385197130783,2.448871044711095,1.6271099747535458,1.201919928888561,3.6553954135832067,1.2892430150735943,2.295465173035138,2.202043625945311,2.05598500876034,1.1314261481474146,2.2218761703074903,1.9405753011184252,1.2692651168232945,2.72039441253321,2.5504403632589083,1.9930542635005948,0.7059109994666243,0.4809832972933572,0.662024149779766,0.6641535909572818,0.6729538416857391,0.6917368144029237,0.670279682096317,0.7211425579351036,0.8117120345105744,0.76186303491219,0.706890544071724,0.8625098490208596,0.9159254020472533,0.9605175494557241,0.6121939463339936,1.8692057269040936,1.9829608650283832,1.891631844229796,2.5807330808910747,2.0768692214121205,1.6075699370815268,1.3263551453553908,2.4446464772144303,2.524218793266008,2.2373583601137152,2.167353909705036,2.2882453635085325,1.3158689793227654,1.590897316320485,2.223516045770637 -0.2577387933633394,0.38153712579074406,0.18177836429303823,0.11642086696025677,0.2752295148288579,0.25997493766748686,0.0985811697529354,0.17237353051257132,0.031101498752175327,0.04948616135684589,0.7998588089088761,0.4754804109833751,0.10246190758547519,0.1743731679575524,0.26890078599711864,1.663733196314692,2.094577623292766,3.5858857456447915,0.9292338744201152,1.788017717601309,2.0143075910474058,1.8326840870756227,1.4327418268799144,2.4892498902011453,0.7118714288613683,2.6212466393959843,2.1183678589848522,1.3931811041556363,3.234549094779157,1.7759057134135896,0.7673179227044378,0.593368625347952,0.6596124392730253,0.9062299529913974,0.66385244813103,0.6410085849158261,0.7958655416460174,0.4655555407739742,0.4946378293337228,0.6234658809409437,0.5875837942006024,0.7644737233452393,0.5524198500844831,0.5699604273428331,0.7714967349830616,1.6661764130894494,1.7498420580501635,1.0700588717866146,0.9789474750852886,0.9944424279654188,1.1040988655189605,1.4124293104526686,1.1552569003192135,1.0316537552050824,0.6177647318799913,1.172431800641677,1.5645371869253952,1.048097820362217,1.4971892428888556,1.019438112059099,3.2212171526535602,2.325192659922426,3.2647705073525746,2.817656557397494,2.956067978013932,2.900321444300614,3.0608929228813557,3.146474636886832,3.6019342201730216,3.123535987928002,3.1943837488004796,3.5096958592795486,3.4595337779123723,3.949194367129969,2.449332866414968,4.927235674162258,3.2618899798340415,4.35939680462651,4.484143782797533,4.860963454265321,4.714063279554919,4.374232812080268,4.9397953151608105,5.2670614196847865,5.253494815622238,4.517686373237132,5.801564582748541,6.424401072520485,6.573507731607737,4.195496524418605,0.22436407650738355,0.08418068634144207,0.24362356056498785,0.20048106022810772,0.22369252160935504,0.07665824819157763,0.20074969096268852,0.1758101124932545,0.2185474563814154,0.3204414036264583,0.34181477162457097,0.16096365338338825,0.12797951155377307,0.19634460528096928,0.1319999450723246,3.1926441125337854,2.118048222967761,1.5744882043278947,4.755711916093251,1.6773901121147603,2.9802223929236815,2.8763514670126877,2.67842195380805,1.4707936723517148,2.8878049224561626,2.524326832343417,1.6567546937375428,3.5413777914171773,3.3143621837233845,2.5963334660212705,2.5744331424568117,1.7116275069069915,1.260763723184699,3.835537554513,1.3509251983558266,2.406620557803429,2.3119421163158624,2.158845629009861,1.1850195066515519,2.330959758143654,2.03395808516762,1.3306127345263117,2.8538262275393267,2.6747651778486174,2.095266229506673,0.7483151001495156,0.5061446089587053,0.6943513646581071,0.6877000904449827,0.7019726869622309,0.723211017084288,0.6992053554187834,0.7579005732508844,0.8549732029860062,0.7896135472105948,0.7515273934894211,0.9009507184325982,0.9598345171452458,1.0119660241795,0.6253688357523358,1.9588000949247817,2.077318938459073,1.985451521537959,2.707796520693453,2.1814728184433996,1.6823464561469348,1.3889303385243918,2.567002729900602,2.651358528068259,2.3481925839694546,2.274265341827644,2.402872973354974,1.380636221823262,1.6696253016039748,2.3328992536332995 -0.3147478514744791,0.2365270248796488,0.1991436129124104,0.30859441088822753,0.20684377378413907,0.25519330786278127,0.22395961581366974,0.2570444529380401,0.060813757879939895,0.13240182895159347,0.7036291348693564,0.3321480181835128,0.23764575111873174,0.22898251503302094,0.2291796121342332,2.616904741942547,1.9245734773875984,3.0076839487287756,2.7044924875147447,1.312820816046682,1.544902775260705,1.763142605810565,4.1614101190825155,1.444937923947107,1.0253650594937507,2.2642932424295847,1.862817594983025,1.516162860345542,2.7883694493455238,2.646862130529655,0.7572992043772284,1.6931606638262038,0.5008476521921857,0.5247170336857824,1.128070314070622,0.5372467695124479,0.9718453789508974,0.6273074428551987,0.484151241737352,0.4737753051626694,1.1762442248137703,0.4236048838672005,0.34968779652346804,0.5432138624624442,0.7641255567765685,1.4611447200656231,1.5229269125429992,0.9789297742704972,1.31921400337184,1.0977545371218806,1.1821664767572655,1.227369868805244,1.2699863387942907,0.938654180096006,0.5859375373447433,0.877143119543178,1.2005108565922349,1.0318664351092555,1.4204262316372631,1.1313180435558987,2.894269097073383,2.307183132904896,3.2726908937733943,3.114378137950544,2.887694126134443,2.877166837540122,2.852371966668429,3.290697842793185,3.268119279420717,2.9879871527701587,3.037197246918601,3.4531283579290655,3.2310449443352556,3.8544977768500397,2.5721187010102002,4.617541933864665,3.147656436711631,4.342168543707328,4.616691212142629,4.699234297374592,4.658277371248876,4.149176260508869,5.015087027533395,5.010725382586282,5.056266506968191,4.313905402962008,5.6805723541076905,6.092436681021872,6.40991281425727,4.185253899841722,0.17443558183428504,0.1709037092312821,0.27362201726585456,0.22012201829463407,0.1468656701012397,0.07802144755250397,0.21371849380471647,0.21632075424424596,0.09700697345559832,0.16490707740251587,0.28836444657804106,0.16872998959064064,0.1355170369464168,0.2365148930598669,0.1267106020399359,3.0254514890872346,2.1189702018513925,1.5181897254961647,4.5977555951245925,1.860815146110725,3.128765707508364,2.8173068947520767,2.5035632749052374,1.8127596446557122,2.792936125637394,2.2821981117432055,1.6210699192879603,3.673826763997711,3.088212172930864,2.5238504283670613,2.442206538139726,1.7145210614868573,1.2192035619183315,3.710292515937808,1.5008596877310851,2.527424683248124,2.26735319439386,2.020811996872642,1.462040218763018,2.256615987720769,1.8420488716863477,1.3051205948879894,2.9619805745124683,2.4951203387868386,2.039284814792125,0.7036455676855224,0.49468913483792765,0.6874832720934282,0.7185209934498477,0.6863570070782551,0.7248507889383378,0.6667635830997051,0.770993063147365,0.8075956255920884,0.7655496226899843,0.7126224985002625,0.8687087608747595,0.9069380503230988,0.9773945289539181,0.6300040925435961,1.9995867993608345,2.103882375340386,2.177982618557496,2.5999419111215585,2.032003827476368,1.923956476043047,1.7236384034394194,2.2852681610457695,2.557382554388041,2.3458779799773914,2.3321359233711374,2.389423388087613,1.6366639903231368,2.0046943011797693,2.2811278844049805 -0.18325183944538898,0.16636561564350663,0.19211796279075286,0.2631816928907965,0.20785372632099122,0.154740033921425,0.16594393827664503,0.2259358576397204,0.140080115223153,0.16513234240978433,0.6098890622049741,0.2042061197706506,0.23888317457255998,0.2500391481683992,0.13748053022844997,1.811916366805359,1.6482241682636347,2.521682517794123,2.986430691534031,1.8029416868770176,1.6970666480008887,1.3013428352417213,3.0208429304553706,2.4460383595752613,2.476703907602639,2.2824997591290876,1.575560618312658,1.4230017239574155,2.719736173786874,2.5175391601698394,0.7738639294160046,0.11458829644611623,0.7793702582587025,0.6241479173282423,0.3293429916405924,0.5372318196920247,0.8910213608784855,0.5884665243907178,0.7402402802908102,1.107088366310498,0.4168195528778049,0.7346227075673549,0.7132871397954095,0.5550743929374868,0.6114101654108476,1.514120105836469,1.4238680099933123,0.9984685699719358,2.0708295710541624,1.1432190093116354,1.165598641360498,1.169189029844616,1.093488462810604,1.1259356342664157,1.1027880523367044,0.8905786466577894,1.0435204541608702,0.9165997556518904,1.6517742967188749,1.205377212058735,2.5465048052978188,2.506170746664903,3.241743758621192,3.6763546851574866,2.9522511041865496,3.0036134592870725,2.160608877280888,2.6885329438568184,3.350010286086224,2.809817027536668,2.9145827791547596,2.9463252792248764,2.949697716769185,3.9111798036302092,2.5389901072248375,4.089826355486104,3.4470429237397373,4.136864286205866,5.359640032518462,4.721086620832017,4.900582566929567,3.288432875462219,4.218005299893425,4.9566266281729225,4.807780561915091,4.163595924104705,4.960990778983424,5.53957521631238,6.370019602846128,4.140083657745243,0.19983093177074782,0.26732747302711446,0.552405052658288,0.15858348583168302,0.25654298757102495,0.09676779337853587,0.11755039722735873,0.1834561089475247,0.42101392991082554,0.1814612102764961,0.23326107944411648,0.10585538300749583,0.20919900493463908,0.19472115744931956,0.15508894098464385,3.5687227834255952,1.9336395688293475,1.4307516827152535,4.779479539664226,2.395807878755962,3.2530610510965903,3.265770539393273,2.824233909538662,1.5012583107531374,2.623279923112197,2.6168020102377416,1.9588549151352086,3.5521231868008023,2.8584775008366883,2.8493160603361396,2.879812715130286,1.5642102099037054,1.1493379948879858,3.8578000576493214,1.9316073908622657,2.626974761992599,2.6295558310312215,2.2787082685315307,1.2110949989899915,2.11972027911882,2.111479310458275,1.5767798485897266,2.8647922846562937,2.3098314170787235,2.3010822861824165,0.6226249954358319,0.5084530604643827,0.6433832650339062,0.8484945181972132,0.6811604125946888,0.7614192582804837,0.5391212036118598,0.6484681413201085,0.7908259854747355,0.7350707353724902,0.6917287179240181,0.7807454201174371,0.8264491817502775,0.977361508913999,0.6182952199718814,1.9991367153413746,2.196473077084544,2.4853889952628787,2.3859308009591316,2.1800944256449473,2.0865860820277424,2.3538534873848698,2.358615391962884,2.1966679618218414,2.1538243407637854,2.549005096720346,2.278161182189484,1.9943984660422451,1.7457725926479888,2.941243216152075 -0.26352587120605814,0.1289522674597947,0.25043092542004525,0.32688191849264286,0.3019521624084702,0.2491730067457823,0.11520346394350744,0.33809354877889986,0.27413375727511335,0.1859048142095956,0.8247847601128929,0.15589749469179018,0.3423835619497581,0.2150861099495902,0.09324539644455018,2.637318656671815,2.1564674743024677,3.5176920864095464,4.010628008462077,2.3557998226790904,1.9957167141087113,1.4985118324453652,4.067286101430083,3.5193443938271356,3.121054941302047,3.5296112410610525,1.841383379531052,2.04594845041965,3.6856122784560044,2.924417516374594,0.6948836064731259,0.7619411321655694,0.5440731629205947,0.503845026149396,0.6266362231888384,0.5696322684830356,0.4261290762596534,0.6450492405197149,0.6622354713963131,0.3861271838670654,0.7598523975976851,0.5677581427275961,0.6491373616153392,0.5780199081096946,0.5965626887955444,1.6848606274818276,1.5634895763518557,1.0224936329483651,2.0948326787406146,1.1793080153004045,1.2855281642157748,1.1935188659234934,1.1305495853286134,1.159556570290123,1.1006622491548077,1.1728585202430046,0.9627798849128408,1.0174608694604337,1.668406920332673,1.1234514591550129,2.666680977572046,2.754212839888641,3.302343526688169,3.927726038758332,3.120470744223657,3.2284821528676555,2.4355109983670604,2.8442720351885487,3.3861600636934406,3.0237932230317464,3.2728603187641703,3.1096122105605963,3.074048149087434,4.0969645929764855,2.6090053253506897,4.316493469217455,3.640946401009616,4.364547127862744,5.667313455788615,4.985981843462975,5.176881577150584,3.475092648484732,4.451626494038403,5.228663620693899,5.077519929609917,4.4024370867258895,5.238585004659923,5.846953483871788,6.730206154438456,4.367919017170381,0.0821319898236014,0.22962147060662985,0.2457198859829867,0.10419447683030189,0.2075536556364877,0.14200250400231168,0.08326275972643951,0.16981294695410634,0.2321719766092039,0.2552931590113212,0.42309768751005095,0.09192437182070136,0.35940303386755096,0.20954722416840366,0.10643543851494236,3.76915364483558,2.043694550551242,1.5097261980528076,5.050446961076308,2.528172764190393,3.4432454309371576,3.4463631543110838,2.98206770182167,1.5791977943710633,2.7666190917312483,2.7657797426543027,2.0676200735020567,3.750874580307416,3.0152232414551032,3.0066532922420333,3.040978018504928,1.6565838004979527,1.2156425161689386,4.074889211306665,2.0388925306408145,2.78448098241251,2.7735171386795128,2.406517522036534,1.2741151095451744,2.2347366483983175,2.2340108349539354,1.6662342698904338,3.0241553335557985,2.4353274029501155,2.427560097108918,0.662024065572215,0.5470758106436857,0.6796017834040415,0.9020579466372359,0.721371682326823,0.8072257944502266,0.5807736251687314,0.6845505264004662,0.8294356810320136,0.7749447634133526,0.7396240878866462,0.8214695957227858,0.8661709094297511,1.0258354878340823,0.6533276512283764,2.119016870375898,2.320472511523686,2.6228918632030402,2.517265533266328,2.305543541280126,2.2100801018923093,2.487534360550911,2.4773271904385945,2.3262559254963615,2.2727871633426853,2.6848916552896736,2.4053382835173567,2.106625392656631,1.84380189412332,3.099577183698782 -0.41206979196668214,0.2038147137162128,0.27790696527297404,0.2236859703784998,0.30517971009892964,0.3541800063447386,0.2601796126514927,0.2814294678515019,0.21514774766413786,0.13770810285168353,0.7366484194957785,0.2525042896964681,0.315239393705384,0.5867451147630776,0.05638082268201405,2.867043634296784,2.180988439687032,3.2840361930400803,3.223563509475008,2.1367231661989567,2.7354075679516567,1.735941156964805,3.623304944769296,3.0298389953267186,2.8779301371253,3.285856426858941,1.9134849741258215,1.9741003354236601,3.8919807779849367,2.528362420085482,0.8928218229466891,0.6623341696875618,0.6130196595165894,0.6986912852488701,0.4362828590616083,0.8923951795507229,0.6331990810744125,0.7438279359995366,0.4665088408654633,0.5069700021454002,0.6123389412057328,0.5216240006673141,0.7533156822853364,0.7925637776071185,0.6587256782200901,1.8052220990759686,1.7354282365588325,1.1562003812208173,2.3244972388041605,1.3144127059816721,1.3855960532110074,1.3136596575582766,1.2723791163817804,1.3164947166329637,1.206981568844855,1.3036540888145964,1.0638719427014554,1.115153767688611,1.8408614615363952,1.273312109230466,2.8926664296551694,3.127719506034204,3.6428563564273087,4.461704193514207,3.518128402588498,3.436595778731303,2.7300154907835905,3.1655450057844217,3.851355318936345,3.3867560975671624,3.597685889222649,3.4891233550706886,3.4044973871304194,4.463982099154069,2.984271743504542,4.76392947437692,4.0345007223214076,4.826379440254221,6.272917615997414,5.517121849331626,5.705863181677312,3.8472339457035973,4.9239696200351,5.789173821626933,5.612110893174393,4.866283784861219,5.793311940880152,6.460765638926891,7.431165513931235,4.837021150370398,0.1504990682527499,0.2511581185723884,0.22701556632748535,0.1957735774858627,0.23884682171553706,0.2505838735978057,0.12201627599578774,0.17416134235482547,0.2883056973186597,0.33144033217010377,0.3789192375123099,0.17021988989862705,0.41069404312254254,0.199157849103254,0.18163278121785054,4.159530030396693,2.2552546992871854,1.6749403651241905,5.582335304004137,2.7962909253604624,3.794035212417172,3.807938919370911,3.303206056346015,1.7498105805081134,3.0603534916423496,3.05790093373013,2.291191087573738,4.135793400754597,3.3379990579056678,3.327507593060706,3.3551512055956554,1.8256144085519583,1.3470938629583906,4.505872171560094,2.25411704910191,3.066173068836579,3.0641186681682364,2.666050965740245,1.4099657763623505,2.4713742945539456,2.4690944741435934,1.8454538268780531,3.3331269403570913,2.696154508276496,2.6865710077705427,0.7225374789658878,0.6094786968492679,0.7538044738531101,1.004077908033971,0.8027528463456272,0.873342024760573,0.6443313056632647,0.7599732275309826,0.9245748486164038,0.8549155983910319,0.8167809246441611,0.9121143627149975,0.9559082645935374,1.1320139417640938,0.7284405220262243,2.3490101598091844,2.567723138867007,2.9021011730842403,2.7763485525446336,2.5501384630016277,2.4373857740750884,2.748314277780656,2.7392940722692165,2.5662856033319845,2.5208961119939963,2.971636120657121,2.6642674398247936,2.3245943951710926,2.0407664455101906,3.425306215301003 -0.3495963899613321,0.18860915158413713,0.20457314769859836,0.22223780972939508,0.28307820270056167,0.30505629778822885,0.4675796013878651,0.22031583529887006,0.3443200828014781,0.18156297046090025,0.6371724182244303,0.977120603038235,0.2757702689232282,0.5554197093058669,0.0701949411912115,3.360430388521778,1.7089552178331773,3.373350114333403,3.9352840027580176,2.507428914481376,2.8080549573461413,2.4687575387467353,3.7308073866559335,3.6758707125284404,2.90186382648384,3.3698818041399217,2.8323191157551273,2.187984139060002,3.8162444876684476,3.038815871310879,0.9027111253150726,0.6057469920477913,0.9105414694388496,0.8378685173335836,0.6668284721208975,0.6583950938480905,0.8341004183527312,0.5751402921796382,0.5748035008654406,0.6776695954769933,0.449061357213967,0.6522305057605319,0.44020871947531937,1.0076984045680377,0.47447421425565395,1.900413746916675,1.8098921132982024,1.2074286307957167,2.4472525444956887,1.3733526060353363,1.4539871329658967,1.3807441841469006,1.3272761261616135,1.379663415372691,1.2697827020039445,1.3626835412812537,1.1175945175996596,1.1758880419562499,1.9300974209304218,1.3322563820545392,3.0330800918959304,3.2178225548212547,3.7291189303837617,4.582829186594139,3.6004207144102898,3.645320312851295,2.949477153746923,3.3023772274422827,3.930788257931079,3.518936346024916,3.7229649901706687,3.6451445765022474,3.675259843759741,4.611511073193805,3.1709501138726983,4.979842265813593,4.206137180632586,5.041273879176019,6.566259384481935,5.767340536580782,5.9807462192675285,4.027006374645686,5.150770344502752,6.051525002380996,5.871531834714641,5.091628598644707,6.066280779920805,6.783763941693969,7.785570394332285,5.064244004159725,0.16231574848893102,0.26512023372758564,0.2370118805989511,0.2090867353208734,0.24855265003770674,0.2666526183860346,0.1378683722587921,0.18091673768655744,0.305941661861065,0.34962052175096375,0.3853817441273413,0.17694984836857908,0.43199951210886967,0.21619548540796807,0.191797758751434,4.356628496942513,2.3589448646565225,1.7498672313005166,5.847831678727488,2.9290172501272003,3.9704957399369327,3.9815395161295046,3.4579166185365753,1.8258407336308737,3.2083389073079043,3.202099797491457,2.405411155576213,4.334205493548421,3.495582715734346,3.4864641190416386,3.514081995684447,1.9091170997014233,1.4066999862774696,4.720064423896089,2.361393866016607,3.207982954001001,3.2021112797926996,2.7905923382220865,1.4699622937379382,2.591801184101825,2.5855294973403278,1.939218383626378,3.493595838857538,2.8234127732233825,2.8153527385010224,0.7505531983540177,0.6231181622866012,0.7779667790287264,1.0507711867925147,0.8329519694671865,0.9193806355689096,0.6736128290475141,0.790621064697697,0.9593620892346862,0.8915171648434567,0.8547537781143186,0.9586515059099601,1.0108575639953583,1.1862342084655764,0.7635327694032948,2.459278260550427,2.6918814850858563,3.0337164075079146,2.903371800425036,2.669381065067193,2.5559025873920027,2.875611517246748,2.8681295723837663,2.684126832109439,2.6429534744120438,3.1091280041870397,2.7998045165578396,2.434593222793135,2.1418041459271806,3.592206596951274 -0.29301270940171337,0.3325504241012404,0.29049565384248255,0.21023968200560683,0.39444530231109826,0.306857045989149,0.3085552713254769,0.2812528257176024,0.4767259820071028,0.19881815515165363,0.6289930576678524,0.5432804122323323,0.3731213527414734,0.5856435839950043,0.2539173400201138,3.167905358821199,2.1724504590404647,3.429357099834586,3.7716767781225724,2.4024168871041813,2.308686750983048,2.632143610260141,3.1669444678082312,4.514941923425322,2.189668237845469,3.479239947958238,2.1652217806264638,2.3465715886975245,3.7297984525566736,2.901181603360488,0.6931508237572553,0.6301453928282047,0.8281868393472682,0.8629411240069631,0.4940344726804519,0.8369296466988262,0.563978474123681,0.6763222711899319,0.6539353962305597,0.6232565836827824,0.7296512878748997,0.5395672810793773,0.6404154285266883,0.7485603959535974,0.7321252557982549,1.6373726585917712,1.7376289956488928,1.5308452761634128,1.59610122827922,1.229043298162972,1.3757584999466588,1.6604590694908958,1.4045715927783475,1.9320962252031064,1.5778924049299448,1.312001111713877,0.8118059237305157,1.316500657296508,1.971526806464047,1.4022690761307597,2.342497529174377,3.0483666882444123,3.5973469768674664,2.8674955307169454,2.759573836639691,3.2178579387485384,4.220200711939887,2.9404548153466106,3.816195173055247,3.047691642944205,2.601138381180423,2.5122173268756076,3.106457135390593,3.209602591987722,3.1447581189334626,3.475426684054278,4.206799200659234,5.242551867828871,4.218188883021987,4.321850166214938,4.942755975492306,5.747785828067533,4.373219787772679,5.691713635009236,4.7110245232183745,3.6270940813405788,4.19903992156664,5.198569814231533,5.3884357055645875,4.502188778647618,0.13587525391461655,0.2383274975856369,0.32148585922970785,0.48896588215283143,0.1673215833901521,0.2730083482421212,0.3391247179288081,0.2180154483574905,0.5414543602270178,0.23763845832371747,0.3079776753858744,0.14484055189807593,0.1852409985522589,0.34768802935527937,0.2350463699226634,3.8998454879544955,2.3160333691081885,1.1998808655790119,3.4318482775569468,2.7032887388336193,2.995361841298144,3.0002032009994517,2.967848884996891,2.2155788264093177,3.705257508176034,2.2404257555193006,1.7755941234336718,4.557749833666083,2.7347587886032314,2.789254850328865,3.1464109650716336,1.8724460772476625,0.9674203462548037,2.7740385739078066,2.1811835822577184,2.4210772108490497,2.417574468548053,2.3957276085154313,1.786727458111287,2.9902193066654243,1.811088736805412,1.4332694949243914,3.674611056734189,2.2106976978783384,2.253614629745839,0.5272879210883956,0.6391052319619333,0.7842559304155171,0.6086470609555982,0.6876709797373709,0.7675309142125656,0.8275702955461713,0.6846626947573441,0.8496593488451234,0.7105547647660109,0.6071802997887022,0.6488084549834613,0.8113581168822556,0.80449234645948,0.6792615673023998,2.11321530815759,2.062232446394377,1.9882084645500329,2.1104958017055564,2.602360168552928,2.3098779690994125,1.9058878999514333,1.9881519289216725,2.0761011496503374,2.061246817810123,2.302567853173328,2.060892002193091,2.258768192521748,2.2211827039713903,1.9707824412773118 -0.4111252962642366,0.5619748893093448,0.29351508613956334,0.29496316268301315,0.6130668969070672,0.29265028618389943,0.4175833981606658,0.29059758887182385,0.4982955215346921,0.29979030107299287,0.5902130102337402,0.5000005032211372,0.34309549597021244,0.4440104762252124,0.3175215155442688,5.353463508050239,4.331251417431633,4.459959628762974,5.002430036664434,5.694880075529294,3.43879340716909,4.800026468184499,3.9953655928325444,5.418467265141164,2.9412960058849595,5.85042689291123,2.9161548411235927,3.2125097444345316,4.925575195714538,3.0903583197027036,0.6880741439555779,0.5125626308018718,0.6638085646507346,0.9734352379661722,1.1189610700520385,0.7069187844583232,0.6066093307847218,0.8612993946806586,0.6093688436200633,0.6495737962517066,0.7410254214315533,0.6132201879167221,0.7915854466123243,0.3786466823092512,0.5795904795701399,1.7641231665023926,2.072455483926166,1.5324599398670382,2.0772898050739963,1.751430730864085,1.4219848634519776,1.9875922827071055,1.4759267599959471,2.0697612146436204,1.7166984159473104,1.5126612418651575,1.0143454045630789,1.5135631678613473,2.132963130807809,1.5150988273813213,2.652679558403204,3.458518411660018,3.9599661266204045,3.212874714289153,3.197453421227859,3.538092616126917,4.69395484742539,3.2376955926183557,4.252799322964993,3.3426200771351016,2.9911393929473937,2.886137707822491,3.465546269154791,3.627822785320647,3.5140140995959546,3.9140067353751995,4.740012084426849,5.889330173985174,4.746610926303454,4.869295941067854,5.552904636471453,6.463625727500297,4.9132800240672845,6.404665786558896,5.2942992530038975,4.090100593818786,4.731826332571979,5.844960617724965,6.066485068795292,5.067547753981068,0.14948065243351122,0.2706206040720523,0.3619317809192975,0.5564499150979251,0.20383312054572794,0.30562327657492055,0.38158933839753206,0.24743347705179722,0.6020899649498728,0.26557412719068496,0.3520767068565101,0.16179537140643835,0.20949147822710532,0.3951796295740076,0.251912734797473,4.384706583554786,2.612067397172225,1.355255487525511,3.8659750144297274,3.038191487558248,3.3660811563526583,3.3771118636688846,3.3364706512647184,2.4968065738598297,4.174256880952824,2.512474555220253,2.003757982401714,5.1268690333458995,3.0792740381185513,3.150414738483214,3.537320291161783,2.1127722405877623,1.0913096264323616,3.1272339895600356,2.448944697499749,2.718453212014265,2.7214329713759944,2.6915439829142263,2.013369580153304,3.37175720282131,2.025627777878114,1.617391657070765,4.135154437184601,2.489224886823541,2.5498080055712267,0.5962295873487287,0.7232435640799311,0.8720527171872271,0.6851801265433277,0.7745334828691367,0.854870153741812,0.9256191920922169,0.7630553321207421,0.9530136040358729,0.793055230606243,0.6881820995197085,0.7340274695143776,0.9055744328375782,0.9021520853549767,0.7648914133239658,2.380935782901697,2.323801004708008,2.2413736276048284,2.3676830693276902,2.918310161452524,2.6009976801723833,2.1471388761175163,2.2333507052539296,2.3339671538205415,2.3156925409739766,2.592744502125655,2.3249404536087366,2.5342477831669505,2.499321257266495,2.2183194517323805 -1.0760351335871368,0.33087430800287954,0.28451798330295164,0.594050928619022,0.3568795771345801,0.38123630493541066,0.4534984522965509,0.09417171430868815,0.297243545534713,0.15811323842895925,0.46072891807662814,0.25399416142451037,0.4789562602509722,0.6768248733887896,0.3588609982559914,11.134830857092854,5.033012458779613,4.629473812797501,6.85813539759225,5.702723996913824,5.253142593440125,4.986597667713356,5.644860529132909,5.706644846553894,4.3660235512462275,6.319002365582641,4.192791569491892,3.971564438501245,6.641441878032266,4.924632623941982,0.7198307700949113,1.2907616750796627,0.8899663481331921,0.36134860237534316,0.3038600006084301,0.755934386127026,0.6367098023655073,1.6335127435450345,0.45948225941876375,1.6571369814084718,0.4567950533884769,0.5201808701745126,0.579381297421461,1.4809667876071804,0.8598232686295543,2.7477163852582698,2.491109511436867,1.925516538898853,2.543349955002755,1.9852762426154178,1.8216891240120041,2.3715358688003314,1.923249561607864,2.6299292155744034,2.0337609419094838,1.8926568158340658,1.293878980378293,1.772397795968018,2.523923593513651,1.914412092158577,3.2616923358406944,4.195977532882675,4.8029794639509324,3.921707446430651,3.8831232223046093,4.2849044699646575,5.703642893865733,3.9661254332424964,5.199962113164252,4.124163479769377,3.6550938540680042,3.5488446044318307,4.238876532461645,4.4137161465499535,4.285454738314391,4.787183304019949,5.779200633781872,7.187783507565027,5.795322986911844,5.93959688177212,6.768864913668705,7.888964790950102,5.999009754767165,7.8269178825631345,6.474682090955213,4.995215365589418,5.783516087725116,7.140087059383096,7.404011551540522,6.183573107355579,0.17988557107812342,0.32740826217383306,0.44048279165124604,0.6816633413665648,0.24451139217500983,0.37481501535225464,0.4630765879986215,0.30463662139977093,0.7306388679968181,0.327576432619674,0.4273063705357022,0.19711980967717896,0.2562382340592171,0.4765846138934504,0.3168875524497534,5.364996084279384,3.190125820608135,1.6563931175058997,4.722170977293085,3.717068671310572,4.111382430547537,4.132999934206202,4.073541550479502,3.050733723675177,5.094043890247856,3.072520262406961,2.4468550349892597,6.267522579269526,3.75623757845484,3.852999324740848,4.327499518108945,2.5781899182130443,1.3314868789852938,3.818031302901603,2.994815196524946,3.318427973601075,3.3295206322084177,3.2840178498470904,2.4580159452761854,4.112492096911208,2.4754170313041306,1.9727271476984694,5.054248044750232,3.0339494979589765,3.1170041409306712,0.731740653215599,0.8748454236022305,1.0646477535219594,0.8340491589867256,0.9423267612325543,1.0357432802025808,1.1306920098340738,0.9291406311091673,1.1707893181272497,0.9738680249094813,0.8403150948776285,0.8962436882195924,1.1090529885341074,1.1007514933681093,0.9300712617062835,2.900415561922626,2.8345959107992886,2.7328924393439067,2.8932917144529817,3.5748404711087405,3.1696044910008996,2.630629670505376,2.7278353573986984,2.851547720285243,2.826016013336363,3.168452448210686,2.834630137405818,3.1016974262943537,3.047579652214451,2.7112779904897444 -0.8850406934273465,0.36288878887708464,0.32365874568638836,0.6225077891035,0.44854665046717196,0.3028021896330284,0.563171031945675,0.502445399797777,0.3241590715059948,0.27632924319073676,0.39546122923226074,0.37315742463991775,0.7272429839576983,0.558631268312492,0.4599071274213322,8.890535732007798,4.308241012737118,4.193528630489109,6.650287306463209,5.650721542902223,4.1450481495848726,4.618063374096229,6.827202359044321,6.073513888476005,4.285529806896651,4.301460671233773,3.968111430519081,4.800466508915759,5.3491951833529345,5.705741356109714,0.5564321302371096,0.6224295291215355,0.5876861010387592,0.573593072987628,0.6814001442415802,0.5940515328848484,0.5166213050948436,0.4407920316987322,0.7778415016847788,0.699545779170816,0.7769525582097687,0.6971443093563204,0.8027486159557946,0.7143892946646618,0.8403958808016607,2.969937160599073,2.72640771716665,2.1041689366632004,2.8531224136216933,2.2275151958701183,2.0176648641378185,2.646275336108729,2.1039187969039297,2.9249193036033043,2.1757373707575347,2.0456494186173586,1.355942331260174,2.0141312303176884,2.6868348277147915,2.122971454994592,3.5556439075510315,4.576172696713744,5.251813734126992,4.291018734062043,4.236208351134908,4.685428640461433,6.246819604396478,4.325971772328029,5.666750042902541,4.495720976798845,3.981136381606005,3.8679117067498203,4.629185280178405,4.781097043260407,4.662340218212897,5.224706001255488,6.3050433415722775,7.851317231947986,6.33368701578755,6.483746036400067,7.396763762926808,8.620520751986724,6.5503340996240285,8.537403234836512,7.06590911124342,5.451449572204295,6.312353633665126,7.798678752540345,8.062781926341515,6.74164762174003,0.1978679935429822,0.3615786982957796,0.47852110628710426,0.7475516213205244,0.2692165172330898,0.4036222742249032,0.5077687312121741,0.32997257888543824,0.8042436355928801,0.35667168551797634,0.46401739916235635,0.2098307047052199,0.2774268606861497,0.5222715142363512,0.3443266437298357,5.853225868709604,3.4850296419001845,1.8106571458723058,5.163621579669621,4.051790002546728,4.485510734236593,4.515466725230853,4.44309541215014,3.322558890604472,5.552697693638252,3.3554351045383255,2.6607104384574773,6.835795869501637,4.092078967806474,4.198741835604236,4.720251067059109,2.8169556764914296,1.457910409181368,4.17212128926898,3.266053681709926,3.620758309894965,3.6366384068820516,3.5825937737384046,2.6798156690010133,4.48304913449597,2.7041990497154824,2.1492514069739954,5.510861455451577,3.307239243870131,3.398397618368835,0.795924045417738,0.9509528355206243,1.1682478984955973,0.9183211682362591,1.030026136730477,1.1396119709653785,1.2459663134137837,1.0171966399912962,1.2733008414383287,1.0619079177650896,0.9152869780623464,0.9781929807863968,1.2169943368643288,1.1829636126009984,1.0077068670368365,3.1599151049665823,3.0963900789323433,2.982186235983256,3.1595858018709095,3.9031162571993767,3.4543199096874426,2.873873032166505,2.9804669701850033,3.113909862596284,3.0849799279506938,3.453858363247485,3.0946457015132713,3.3759578712789757,3.316212922066207,2.958205304833243 -0.7751783442112732,0.8933705697137386,0.21512216421069896,1.0478499436867292,0.37091587643891505,0.6183699709171881,0.5488300083537805,0.3380468729145542,0.3188321144573808,0.648059859406211,0.8838272921731964,0.2785347096200407,1.2315003743246729,0.7020304305401837,0.950633855456593,6.663488884455728,6.38879670432656,3.428424519475474,7.432037611133703,8.953744614661122,5.264967180494051,6.68036466864293,4.291100124898378,6.318300365481374,4.280939800159769,3.589945098736694,6.02892543524567,6.149991379043052,6.23821976294118,7.058079934180769,0.6076956950508929,0.5838556385855775,0.9780969268375737,0.7581808105425947,0.6563058475122838,0.563409638640289,0.7695005525639477,1.1593806316266275,0.9677484475538805,0.32596541005572416,0.5358570043827127,0.5698700177347752,0.6465043396268789,0.5933427695201163,0.7481222279321939,2.3821828054662015,2.95469176202322,2.1728735247448445,2.614381269311112,2.1733530042154636,2.277302662115217,2.819091097281598,1.7564969138859823,3.146954453902958,2.2430041778099676,1.7271108346785118,1.6768659075954924,2.3811517273224667,2.6341872011136256,2.1366006668658817,3.032661330103018,4.5129835519375225,4.871649538317344,3.605218740751671,3.360121334234156,4.683127894293469,4.925739481765396,3.062772364755843,4.209336504447512,3.9126985603626907,3.569828954111745,3.2227603919672045,3.735050846743821,3.8024372720781665,4.430283106004712,4.493103525856432,6.2450448859452345,7.221570513944115,5.240419489501418,4.984155401634234,7.284352460589658,7.169253652550173,4.49127281889548,6.6469209743514925,6.396444249685287,4.5963829963812675,5.1680469056295,6.366794578042165,6.456165515701101,6.104244844851688,0.14502029415001777,0.41167694726500176,0.45705327233234727,0.5999854768685583,0.2781371042833633,0.4330871430370292,0.40812549788110486,0.3303684439241181,0.6751760038165248,0.25668140840324377,0.4829832448188537,0.16485217603627214,0.27114590659540694,0.49095308962578976,0.44183406339898257,4.4247584486270535,3.2546199416877957,2.060012681602707,4.4037430719153985,3.1647522016661997,3.7537105384843095,3.667334791116717,4.162304791520204,4.219024514735999,6.865161881146639,3.52078605547939,3.788396776735049,5.548285160249271,3.9393164921451476,3.401185520213235,3.5688915983033764,2.628351067400718,1.6588411555633595,3.55644159901333,2.551769073367715,3.0293522313307903,2.9551724936532917,3.355607944105778,3.400643833843797,5.537798930254731,2.837454305687451,3.055503766636037,4.474653893050365,3.1806083388826485,2.750715484220099,0.6747534857160254,0.9344865684296176,1.059010796274288,0.7990609669314279,0.7992490284536515,1.1264385999399409,1.0664716297088832,0.6934959983303162,1.0281386148989013,1.0021432696741919,0.7629781057345034,0.8334018655612153,1.021003384060766,0.9556140647989179,0.8716897578914262,2.6910989518897046,2.6865440381611103,2.5710753306434966,2.8075922512622453,3.1252467978824185,2.84242856085115,2.613253065856579,2.6102586727058497,2.71776576879741,2.674860526116498,2.8244043101508725,2.7576934219667737,2.848928968136703,2.815859349437344,2.6094422403891064 -0.48439472357751473,0.6657713898237176,0.21481402041872338,0.8909674699278559,0.3355310347911407,0.4659159046010867,0.7114550817939307,0.3886687856998393,0.2419666141354408,2.2373463986258537,0.8320263490126641,0.47238518344268243,0.9253521638917718,0.9248734511722767,0.9687911143728551,6.407938639345345,7.16214506300278,5.2640286876797315,8.243527707907413,6.243116705354836,4.15212476534089,7.126340851465262,5.690053500206448,6.440025704050238,10.310176019022492,5.4451931677040335,7.02374592160325,3.9477409971760573,5.957146604162837,6.206697098981273,0.7730989729345265,0.5354889387317502,0.5018613821114433,0.5987377737596518,0.5765447548940295,0.42632874732024184,0.5188898336282979,0.9980631257439039,0.9118171526146992,0.5993730967043196,0.9918304314487759,0.38882545097690996,0.5313303591633498,0.30718938249931377,0.31657966638620116,2.434039712624465,2.9009961654879297,2.2307512290121214,2.5353025399696625,2.1967446466840843,1.9927742356478313,2.6838362285462063,1.5681593690226654,3.2470929286380326,2.521145583549848,1.8159383843377277,1.81588223438419,2.010083359635018,2.2898351035626336,1.8536032146847348,3.0073415581563414,4.345144666481953,5.182253131126968,3.124904430318934,3.042742878409319,4.241704994041103,4.438047918665855,2.402699977544038,4.001013571703429,3.826608890205453,2.9858587866964696,3.7873966877071368,2.8907403681914303,3.2764468772155886,4.2671108347057904,4.414325001718607,5.905534005740965,7.416551327332879,4.456564654565724,4.5217838593181465,6.665631508466314,6.484429535230653,3.4713757973004,6.260228972140716,6.389907804846702,3.632849177881612,5.857382102374631,5.294957759946311,5.864752035231816,5.744765158390414,0.17300926660809104,0.3964199795497366,0.4937340192384765,0.6062840495561383,0.23652351502152874,0.41085969219473284,0.3362570756905794,0.327621841427693,0.6901059019363585,0.24986602329265,0.5304124891634342,0.24132562552402864,0.21046337255731762,0.44923358901314475,0.4158247319318843,3.499965281590901,2.845256682707547,1.6449393186499903,3.9474655349418835,3.4436367810587947,3.9069352454802324,3.9025390242583047,3.841294556910918,3.700652660700719,6.330665663717063,3.142061538112964,3.0611275161850755,5.673958747603976,4.196411424134777,3.3407063853749537,2.8232207136733436,2.2975455589470495,1.3231031864768468,3.189101387268116,2.777272385362379,3.1532006197046503,3.1457208187938406,3.0972894828237303,2.9830744434341323,5.109511056695913,2.5317766182407078,2.4691015572223654,4.577537736618757,3.3887880658101914,2.702196055186048,0.6428773211038353,0.8881266614134551,1.063633542357819,0.6712409472421499,0.7424179506648864,1.0363534013351072,0.9745219126270785,0.5323862324271353,0.9553261671126528,1.0061273495417284,0.6206028962419234,0.9157376094174049,0.8658068353517882,0.858011020218266,0.7913895316639246,2.397070189427409,2.494057517087997,2.359850695681722,2.583556031581291,2.745789844239419,2.691265693207052,2.5185540806133417,2.497844883086005,2.5080593658963948,2.52630963334639,2.5257829390680606,2.4342042897131377,2.6158960890917706,2.6056864688773853,2.396883755183804 -0.44007549588625516,0.6187474417547534,0.13512599359582256,1.0886376498521657,0.6001608592704749,0.41381392137262635,1.4467718142902408,0.3200230789273738,0.19131152249506567,2.497234490928427,0.8693246911324845,0.4690845718044076,0.7801415750831103,0.9207538725673894,0.8397395416419736,5.842328116368919,6.61123252737065,5.604189067999474,6.992349420255694,7.986814251459248,6.240066290351841,11.796915192773291,6.854777662746748,7.697367664634517,10.553619395471813,7.792103647772968,6.974932744906934,4.8647182519042005,6.056496156646244,4.734395801914465,0.5286359758749024,0.7647240152600009,0.7099701812737882,0.5811904125630591,0.8742955221604205,0.4674034925426358,0.6023527867695061,0.7678100909712002,0.6843559452906445,0.6419905674319966,0.640620247651468,0.7589856325745701,0.6795460197270138,0.7116962470997764,0.6011746611234359,2.707290682076394,3.2279098158462114,2.478446267851802,2.8128389421482933,2.438634943206414,2.204307994532617,2.995132397365558,1.7431777352821882,3.605338000984188,2.8081807704425934,2.018740140146723,2.0148440977170394,2.21710682323334,2.54043304297042,2.040516491161285,3.3385405511028523,4.818725014642647,5.742732123370962,3.4731265096302883,3.3682056865978223,4.7153434597247035,4.940339682389197,2.669214601081948,4.449290990672668,4.248189613714033,3.301852364741475,4.184780810199963,3.213091712110578,3.640348926166725,4.7236337376091395,4.902113222490887,6.555709473754438,8.22830747191605,4.957218926880174,5.010837993232108,7.408211614298274,7.21750415695212,3.85748756911798,6.957553291423887,7.098397377853409,4.024305887811613,6.4872806942064205,5.887588274527792,6.518744520294553,6.370253875394102,0.19309936022631,0.4388282254710153,0.5481733126040502,0.6669657367531128,0.26072544407293574,0.4574864469233967,0.37461354026370874,0.3635201076035496,0.7685214633920389,0.2792777651411048,0.5827552495619983,0.26660144623807014,0.23221025266078127,0.4962253751352377,0.4548143109223947,3.8929771289211605,3.1636541977162977,1.8323555853066416,4.388860662277659,3.824673402936726,4.339762020398617,4.335292879422085,4.273657642791581,4.11269545998674,7.029652012404453,3.4901160221515406,3.404167461335443,6.298135615805256,4.662055573508672,3.71310887635194,3.139266090749405,2.5538148732446913,1.4735696685545336,3.544492415189448,3.0833635145618454,3.5011616481609655,3.4932099983063813,3.4448835503460997,3.3140302359706673,5.671299412107778,2.8111420167339514,2.744920858834468,5.078875067532617,3.763372512305001,3.0023522335997335,0.7095458047537779,0.9823372318870044,1.172921065759861,0.7485061370618769,0.8143513540114881,1.150684232938119,1.0897307236879459,0.5887826589106575,1.0597485719134163,1.1160534322640288,0.682369040517708,1.0040238846714253,0.9617263285665025,0.9541970400877231,0.8691789980352588,2.661989963220246,2.7712234303983725,2.6252678110360157,2.869413737301693,3.05057038090639,3.00250718879288,2.7948880054346565,2.7792463474786024,2.789970102743739,2.801393457627218,2.799719578860203,2.707291252196265,2.8971539899258563,2.8974610672430265,2.6635992613777373 -0.38522565514928087,1.1049042120979866,0.4975907553063096,0.703264871186964,0.4212155066154717,0.32953865670811466,0.663701150935054,0.46438234115335786,0.3666345459698749,1.1283406837827674,0.6308351290701145,0.4069872756809577,0.6067299568737186,0.5649694998803724,0.6988368248203277,5.272053085325343,7.123416684508591,5.050697740846685,7.652004457121279,6.557931326664241,7.578037917947362,9.648538961556069,5.449970947382316,6.957259133045298,8.325780620293443,7.042856408684411,6.466314812598881,5.5866159495869425,6.269469669164317,5.751656325467834,0.5508288320460061,0.771127099027201,0.9031225041845845,0.6702754880408379,0.7388341109513363,0.7372006105383265,0.7352981613075811,0.6577693840120524,0.8073313066959079,0.4792743203985666,0.5531749173582727,0.6774933051128104,0.672667528726489,0.5041977113352203,0.4074764331017791,2.977297915008939,3.548942455941075,2.7309224985028333,3.115349989371081,2.685206912166128,2.439555467636826,3.280935235148207,1.9031065727289564,3.970191186072931,3.079034647799669,2.223196284075203,2.210072596743996,2.4432257835300337,2.8028400049342643,2.257008480813862,3.6746069766611567,5.307707529790321,6.328858896439355,3.8366042624326666,3.705936423891916,5.199082504659631,5.433989526007815,2.9258202703776712,4.898160848995103,4.679307149180735,3.634408388445174,4.59533905247628,3.54321040180713,4.027807904582371,5.211807049593452,5.394140266484023,7.210139871431389,9.052485115459401,5.464575170099126,5.51107888556519,8.151006035246738,7.929939111050187,4.233360607185001,7.650663736876148,7.805750390107559,4.429557964337452,7.12389249209626,6.484018429291241,7.189751885410452,7.016091259701494,0.2110572473372144,0.4831595995252775,0.6029838488651178,0.7352439761120043,0.28580899893930584,0.50586417965737,0.412662818923757,0.4002137723606754,0.8433100820088297,0.3072891877545461,0.6386372206991248,0.29025972722158766,0.25480037963983315,0.5435654308637559,0.4981906270212514,4.283449184283788,3.48275541829039,2.015069643367343,4.829472514880579,4.205394810919315,4.770678354034422,4.761920408309647,4.697618169179308,4.5223096155496485,7.725000055971316,3.8436697290195294,3.7391850601237158,6.920586190072244,5.12270916165037,4.084684427161153,3.4561933568967054,2.8141420267856345,1.624254922189778,3.901983999687828,3.392284624250954,3.850308681280023,3.8383097851075654,3.788165333937353,3.645853329864892,6.23129515664758,3.0984638727478235,3.0172585406053414,5.580470391352345,4.136346982085298,3.3049623101419376,0.7820956176456721,1.0821052596085603,1.2918123372866348,0.8335109458680223,0.8940768936405579,1.2651957184699614,1.1896879277561019,0.6407011668255714,1.1635008871576384,1.2245070136700942,0.7552073259491447,1.0941377019495409,1.0614334021374938,1.0638966608714016,0.9622224371879117,2.92779437085467,3.05837349403267,2.8831254874640853,3.16139824340538,3.3521900719410525,3.3013034343602534,3.080387022845421,3.0611578754337083,3.0630366874431347,3.085088821139045,3.088991925901989,2.976661549283686,3.1763192668915963,3.1908112893652794,2.9208030894137895 -0.46006361075132884,0.9016088411386538,0.6638010322888721,0.542548310712163,0.7282623195060411,0.41494340335347446,0.5624888569384228,0.5407393951784659,0.42889327856005316,0.8118878768079231,0.41859663021707766,0.7008664593385912,0.5626755835718076,0.46621945605013715,0.7048900610126368,4.182821382804743,6.0814497832870575,4.2514584152890365,6.6885547125408245,7.067850613738089,6.743420966948576,7.470166389949798,5.050187237136272,5.622839412282696,6.9923282300260965,4.763459298724081,5.948060898415792,4.9499870031830655,5.48913651982868,4.812980097262633,0.2604922139609437,0.32184260425386635,0.3073931415755399,0.43987277353838267,0.4141091497031496,0.5009079356824313,0.2075018536564743,0.3997665599593747,0.38574404422657094,0.36717636052260677,0.4130750752806495,0.5075086982689733,0.390918209298814,0.41986868486907813,0.3123666662264425,2.72817026442248,3.500702003328149,2.639651337151713,3.17476484135205,2.9388255854600276,2.2733233172922453,2.964249523089383,2.177687173239292,3.929452315746422,3.08631680052404,2.1525499158350136,2.2145762951627677,2.5376881488421232,2.778182557549201,2.2861957572337754,3.3687328179691227,5.764857767228429,6.011725361793689,4.167841499386199,3.949095189527707,4.716743476814538,5.375988660260445,2.9828049916321726,4.796672278084465,4.532587567066276,3.3664263725839687,4.566451379108434,3.7123477177694815,3.9255911377930053,5.002719460219773,4.998279642189477,7.714196762563878,8.52281211496945,5.96649095747903,5.917243593862995,7.425987572397355,7.908699922418022,4.455172292019261,7.431946207326778,7.593425293282419,4.105688177353281,6.884574257609759,6.71811816976153,6.927555352208074,6.793541121466763,0.20243067629503544,0.5453132872756264,0.5734554420021903,0.724395430305738,0.2916114659462308,0.44459250545774043,0.37310109640343225,0.3653014338969026,0.8066105533712221,0.29473613555880984,0.5971535265875885,0.3537024504480763,0.2718270406925505,0.5063144819555431,0.47173256620044374,4.046900890283275,3.315076237969368,2.0007029614172733,4.780183174323406,4.261153207373609,4.427575727516964,4.771239479374229,4.757092875806725,4.505263764664155,7.628918310408508,3.935680053042586,3.5146306056248506,6.584848506803418,5.112362352935034,4.22831587497924,3.2653865716471024,2.678358898549929,1.6115165338566548,3.862791639294485,3.4381254479065197,3.5736519466210055,3.847037810418178,3.8374368231036344,3.6332064287746304,6.1572559340779085,3.1732671573462694,2.8358957276119523,5.311956034176411,4.1292122106633435,3.4209456911221277,0.727934127666492,1.1361619420007953,1.2131814342972105,0.9312705522691179,0.9638161966262201,1.166677970576526,1.1750618110174176,0.6933056017281807,1.1431620971500644,1.2006341590561498,0.6989379986997544,1.04761541010356,1.110503183109243,1.0206730333422205,0.9462177542636483,2.779548517018416,2.8008191032607677,2.6896210272524304,2.9061362547429654,2.988916433765078,3.023261964260675,2.8310432977538627,2.809513624307141,2.847934423427185,2.875391367021452,2.8687256223496505,2.7785697185700635,2.9615475037994234,2.9255010854519528,2.756221128771615 \ No newline at end of file diff --git a/examples/HydroPowerModels/eval_exa_de.jl b/examples/HydroPowerModels/eval_exa_de.jl deleted file mode 100644 index 294e564..0000000 --- a/examples/HydroPowerModels/eval_exa_de.jl +++ /dev/null @@ -1,178 +0,0 @@ -# eval_exa_de.jl -# -# Load the reference results from eval_jump_de.jl (JuMP+MadNLP/DCPPowerModel or ACPPowerModel) -# and reproduce the same problem in ExaModels+MadNLP. -# Prints a side-by-side comparison of objectives and reservoir states. -# -# Key comparison note: -# JuMP's DCPPowerModel enforces hard KCL (no load shedding variable). -# ExaModels uses a soft KCL with a deficit slack penalized at DEFICIT_COST. -# Use DEFICIT_COST >> max thermal generator cost (4244 $/pu) to match JuMP behavior. -# -# Formulation: auto-detected from reference file, or override with FORMULATION below. -# :dc — DC linearization (fast, matches DCPPowerModel reference) -# :ac_polar — Full AC polar OPF (matches ACPPowerModel reference) -# -# Usage (from this directory): -# julia --project -t auto eval_exa_de.jl - -using DecisionRulesExa -using ExaModels -using JLD2 -using MadNLP -# GPU packages (only needed when USE_GPU = true below): -using MadNLPGPU, KernelAbstractions, CUDA -using CUDSS_jll, cuDNN - -const SCRIPT_DIR = dirname(@__FILE__) -const CASE_DIR = joinpath(SCRIPT_DIR, "bolivia") -const REF_FILE = joinpath(CASE_DIR, "jump_de_reference.jld2") - -include(joinpath(SCRIPT_DIR, "hydro_power_data.jl")) -include(joinpath(SCRIPT_DIR, "hydro_power_exa.jl")) - -# ── Solve-status check (MadNLP 0.8.x) ──────────────────────────────────────── -solve_succeeded(r) = r.status == MadNLP.SOLVE_SUCCEEDED || - r.status == MadNLP.SOLVED_TO_ACCEPTABLE_LEVEL - -# ── Load reference ──────────────────────────────────────────────────────────── - -isfile(REF_FILE) || error("Reference file not found: $REF_FILE\n" * - "Run eval_jump_de.jl first (in DecisionRules.jl).") - -ref = load(REF_FILE) -obj_ref = ref["objective"] -res_ref = ref["reservoir"] # nHyd × (T+1) -x0_ref = ref["initial_state"] # length nHyd -inflows_flat = ref["inflows_flat"] # length T*nHyd, stage-major -targets_flat = ref["targets_flat"] # length T*nHyd, stage-major -max_vol_ref = ref["max_volume"] -T = ref["num_stages"] -nHyd = ref["nHyd"] -formulation = get(ref, "formulation", "DCPPowerModel") - -@info "Reference loaded: obj=$(round(obj_ref; digits=4)), T=$T, nHyd=$nHyd, formulation=$formulation" - -# ── Load ExaModels data ─────────────────────────────────────────────────────── - -const PM_FILE = joinpath(CASE_DIR, "PowerModels.json") -const HYDRO_FILE = joinpath(CASE_DIR, "hydro.json") -const INFLOW_FILE = joinpath(CASE_DIR, "inflows.csv") -const DEMAND_FILE = joinpath(CASE_DIR, "_demand.csv") - -# Load-shedding cost: must be >> max thermal generator cost (Bolivia: ~4244 $/pu) -# to ensure the solver never prefers deficit over thermal dispatch (matching -# JuMP's DCPPowerModel which has no deficit variable at all). -const DEFICIT_COST = 1e5 - -# target_penalty = :auto → ρ = 2 × max_gen_cost, matching JuMP's penalty_l2 = :auto -# (ExaModels uses (ρ/2)·δ², so ρ/2 = max_gen_cost = the same effective multiplier) -const TARGET_PEN_ARG = :auto - -# ── Detect formulation from reference ───────────────────────────────────────── -# Override here if needed: const FORMULATION = :dc or :ac_polar -const FORMULATION = if formulation == "ACPPowerModel" - @info "Detected AC formulation from reference → using :ac_polar" - :ac_polar -else - @info "Detected DC formulation from reference → using :dc" - :dc -end - -@info "Loading ExaModels power data..." -power_data = load_power_data(PM_FILE) -hydro_data = load_hydro_data(HYDRO_FILE, INFLOW_FILE, power_data; num_stages = T * 10) - -@assert hydro_data.nHyd == nHyd "nHyd mismatch: $(hydro_data.nHyd) vs $nHyd" - -demand_mat = isfile(DEMAND_FILE) ? load_demand(DEMAND_FILE, power_data; T = T) : nothing - -TARGET_PEN = auto_target_penalty(power_data, hydro_data) -@info "Auto target penalty: ρ=$(round(TARGET_PEN; digits=2)) (= 2 × max_obj_cost = 2 × $(round(TARGET_PEN/2; digits=2)))" - -@info "Building $(T)-stage ExaModels DE (formulation=$FORMULATION, deficit_cost=$DEFICIT_COST, target_penalty=:auto → $TARGET_PEN)..." -prob = build_hydro_de(power_data, hydro_data, T; - backend = CUDA.CUDABackend(), - float_type = Float64, - formulation = FORMULATION, - target_penalty = TARGET_PEN_ARG, - deficit_cost = DEFICIT_COST, - demand_matrix = demand_mat, -) - -# ── Set problem parameters (same as reference) ──────────────────────────────── - -ExaModels.set_parameter!(prob.core, prob.p_x0, x0_ref) -set_inflows!(prob, inflows_flat) -ExaModels.set_parameter!(prob.core, prob.p_target, targets_flat) - -# ── Solve ───────────────────────────────────────────────────────────────────── - -@info "Solving ExaModels DE..." -result = MadNLP.madnlp(prob.model; print_level = MadNLP.ERROR) -@info " Status: $(result.status) Objective: $(round(result.objective; digits=4))" - -solve_succeeded(result) || @warn "Solve did not fully converge ($(result.status))" - -# ── Extract solution ────────────────────────────────────────────────────────── - -sol = hydro_solution(prob, result) -res_exa = Array(sol.reservoir) # nHyd × (T+1), brought to CPU for comparison - -# ── Objective decomposition ─────────────────────────────────────────────────── -# Decompose into: generator cost + deficit cost + target penalty -# (These should sum to result.objective up to solver tolerance.) - -pg_cpu = Array(sol.pg) # bring to CPU for scalar indexing in generator loop -gen_cost = sum( - g.cost2 * pg_cpu[g_pos, t]^2 + g.cost1 * pg_cpu[g_pos, t] - for (g_pos, g) in enumerate(power_data.gens), t in 1:T -) - -def_cost_total = DEFICIT_COST * sum(sol.deficit) -tgt_pen_total = (TARGET_PEN / 2) * sum(sol.delta .^ 2) - -total_deficit_pu = sum(sol.deficit) # total active load shed (pu·stage) - -# ── Comparison table ────────────────────────────────────────────────────────── - -exa_form_str = FORMULATION === :ac_polar ? "ACPolarOPF" : "DCPPowerModel" - -println("\n" * "="^60) -println(" OBJECTIVE COMPARISON") -println("="^60) -println(" JuMP+MadNLP ($(formulation)): ", round(obj_ref; digits=4)) -println(" ExaModels+MadNLP ($(exa_form_str)): ", round(result.objective; digits=4)) -pct_diff = abs(result.objective - obj_ref) / max(abs(obj_ref), 1.0) * 100 -println(" Relative difference: ", round(pct_diff; digits=2), " %") - -println("\n" * "="^60) -println(" ExaModels OBJECTIVE BREAKDOWN") -println("="^60) -println(" Generator cost: ", round(gen_cost; digits=4)) -println(" Deficit cost: ", round(def_cost_total; digits=4), - " (total shed = ", round(total_deficit_pu; digits=6), " pu·stage)") -println(" Target penalty: ", round(tgt_pen_total; digits=4)) -println(" Sum of parts: ", round(gen_cost + def_cost_total + tgt_pen_total; digits=4)) -println(" MadNLP objective: ", round(result.objective; digits=4)) - -println("\n NOTE: Both JuMP (penalty_l2=:auto) and ExaModels (target_penalty=:auto)") -println(" use effective L2 coefficient = max_gen_cost = ", round(TARGET_PEN/2; digits=2)) -println(" ExaModels: (ρ/2)·δ² with ρ=", round(TARGET_PEN; digits=2), ". JuMP: penalty_l2·δ².") -println(" ExaModels gen cost only: ", round(gen_cost; digits=4)) - -println("\n" * "="^60) -println(" RESERVOIR STATES — end of each stage (per hydro unit)") -println("="^60) -println(" Stage: ", join(lpad.(0:T, 9))) -for r in 1:nHyd - println(" Hydro $r (ref): ", join(lpad.(round.(res_ref[r, :]; digits=1), 9))) - println(" Hydro $r (exa): ", join(lpad.(round.(res_exa[r, :]; digits=1), 9))) - max_err = maximum(abs.(res_ref[r, :] .- res_exa[r, :])) - println(" Hydro $r |err|: ", round(max_err; digits=2), "\n") -end - -total_err = maximum(abs.(res_ref .- res_exa)) -println("="^60) -println(" Max |reservoir error| across all units/stages: ", round(total_err; digits=2)) -println("="^60) diff --git a/examples/HydroPowerModels/hydro_power_data.jl b/examples/HydroPowerModels/hydro_power_data.jl deleted file mode 100644 index bc7f5b4..0000000 --- a/examples/HydroPowerModels/hydro_power_data.jl +++ /dev/null @@ -1,392 +0,0 @@ -# hydro_power_data.jl -# -# Parses a HydroPowerModels case from standard input files: -# PowerModels.json — power system topology (PowerModels.jl JSON format) -# hydro.json — hydro unit parameters -# inflows.csv — inflow scenario data (stages × scenarios per hydro) -# demand.csv — optional per-stage bus demands (stages × loads) -# -# The power system part uses the same data conventions as ExaModelsPower.jl -# (DC-OPF susceptance formula, branch-variable formulation). - -using JSON, CSV, Tables, Statistics, Random - -# ── Power system data structures ───────────────────────────────────────────── - -struct PowerBusData - idx::Int # bus index (1-based, same as position for Bolivia) - bus_type::Int # 1=PQ, 2=PV, 3=REF/swing - gs::Float64 # shunt conductance (pu) - bs::Float64 # shunt susceptance (pu) - vmin::Float64 # minimum voltage magnitude (pu) - vmax::Float64 # maximum voltage magnitude (pu) -end - -struct PowerGenData - idx::Int # generator index - bus::Int # bus index this generator is connected to - pmin::Float64 # minimum active power (pu) - pmax::Float64 # maximum active power (pu) - qmin::Float64 # minimum reactive power (pu) - qmax::Float64 # maximum reactive power (pu) - cost1::Float64 # linear cost coefficient ($/pu·h) - cost2::Float64 # quadratic cost coefficient ($/pu²·h); 0 for DC linear -end - -struct PowerBranchData - idx::Int # branch index - f_bus::Int # from-bus index - t_bus::Int # to-bus index - b::Float64 # DC susceptance = −br_x / (br_r² + br_x²) [ExaModelsPower formula] - rate_a::Float64 # thermal limit (pu); pf ∈ [−rate_a, rate_a] - angmin::Float64 # minimum angle difference (rad) - angmax::Float64 # maximum angle difference (rad) - # AC parameters (raw MATPOWER/PowerModels fields) - br_r::Float64 # resistance - br_x::Float64 # reactance - g_fr::Float64 # from-bus shunt conductance - b_fr::Float64 # from-bus shunt susceptance - g_to::Float64 # to-bus shunt conductance - b_to::Float64 # to-bus shunt susceptance - tap::Float64 # transformer turns ratio (1.0 = no transformer) - shift::Float64 # transformer phase shift (rad) -end - -struct PowerLoadData - idx::Int # load index in PowerModels.json - bus::Int # bus this load belongs to -end - -""" - PowerData - -Parsed power system data from PowerModels.json. - -- `buses`, `gens`, `branches`, `loads` are sorted by index. -- Bus indices are 1-based and consecutive for Bolivia (index == position). -- `ref_buses` holds bus positions (indices) of swing/reference buses (type 3). -- `cost_deficit` is the load-shedding penalty in \$/pu·h. -""" -struct PowerData - nBus::Int - nGen::Int - nBranch::Int - nLoad::Int - buses::Vector{PowerBusData} - gens::Vector{PowerGenData} - branches::Vector{PowerBranchData} - loads::Vector{PowerLoadData} - ref_buses::Vector{Int} # bus indices of reference buses - baseMVA::Float64 - cost_deficit::Float64 - # Default per-bus demand (pu) from PowerModels.json load.pd / load.qd - default_bus_demand::Vector{Float64} # length nBus (active) - default_bus_reactive_demand::Vector{Float64} # length nBus (reactive) -end - -# ── Hydro data structures ───────────────────────────────────────────────────── - -struct HydroUnitData - pos::Int # 1-based position in hydro array (matches hydro.json order) - gen_pos::Int # position of this unit's generator in power_data.gens (sorted by gen index) - max_vol::Float64 - min_vol::Float64 - max_turn::Float64 # maximum turbine outflow (m³/s equivalent) - min_turn::Float64 - pf::Float64 # production factor (turbine coupling: baseMVA·pg = pf·outflow) - spill_cost::Float64 - min_out_cost::Float64 - min_vol_cost::Float64 -end - -struct UpstreamTurn - downstream_pos::Int # position of the downstream hydro unit - upstream_pos::Int # position of the upstream hydro whose OUTFLOW contributes -end - -struct UpstreamSpill - downstream_pos::Int - upstream_pos::Int # position of the upstream hydro whose SPILL contributes -end - -""" - HydroData - -Parsed hydro-unit data from hydro.json + inflows.csv. - -`scenario_inflows[r]` is a (nStagesSample × nScenarios) matrix for hydro unit r. -""" -struct HydroData - nHyd::Int - units::Vector{HydroUnitData} - upstream_turns::Vector{UpstreamTurn} - upstream_spills::Vector{UpstreamSpill} - K::Float64 # water-balance conversion factor - initial_volumes::Vector{Float64} # length nHyd - scenario_inflows::Vector{Matrix{Float64}} - nScenarios::Int - nStagesSample::Int -end - -# ── Power data loader ───────────────────────────────────────────────────────── - -""" - load_power_data(pm_file) -> PowerData - -Parse a PowerModels.jl JSON file into `PowerData`. -Includes both DC (b susceptance) and AC (br_r, br_x, g_fr, b_fr, tap, shift, etc.) -fields for use with either formulation. -""" -function load_power_data(pm_file::AbstractString) - pm = JSON.parsefile(pm_file) - - baseMVA = Float64(pm["baseMVA"]) - cost_deficit = Float64(get(pm, "cost_deficit", 0.0)) - - # ── Buses ──────────────────────────────────────────────────────────────── - buses_raw = [(pm["bus"][k]["index"], - pm["bus"][k]["bus_type"], - Float64(get(pm["bus"][k], "gs", 0.0)), - Float64(get(pm["bus"][k], "bs", 0.0)), - Float64(get(pm["bus"][k], "vmin", 0.9)), - Float64(get(pm["bus"][k], "vmax", 1.1))) - for k in keys(pm["bus"])] - sort!(buses_raw, by = x -> x[1]) - buses = [PowerBusData(b[1], b[2], b[3], b[4], b[5], b[6]) for b in buses_raw] - nBus = length(buses) - - ref_buses = [b.idx for b in buses if b.bus_type == 3] - - # ── Generators (cost format: ncost=2 → [c1,c0]; ncost=3 → [c2,c1,c0]) ── - gens_raw = Tuple[] - for k in keys(pm["gen"]) - g = pm["gen"][k] - cost_arr = Float64.(g["cost"]) - ncost = Int(g["ncost"]) - c1 = ncost >= 2 ? cost_arr[ncost == 2 ? 1 : 2] : 0.0 # linear coefficient - c2 = ncost >= 3 ? cost_arr[1] : 0.0 # quadratic coefficient - push!(gens_raw, (g["index"], g["gen_bus"], - Float64(get(g, "pmin", 0.0)), Float64(g["pmax"]), - Float64(get(g, "qmin", -Inf)), Float64(get(g, "qmax", Inf)), - c1, c2)) - end - sort!(gens_raw, by = x -> x[1]) - gens = [PowerGenData(g[1], g[2], g[3], g[4], g[5], g[6], g[7], g[8]) for g in gens_raw] - nGen = length(gens) - - # ── Branches ───────────────────────────────────────────────────────────── - brs_raw = Tuple[] - for k in keys(pm["branch"]) - br = pm["branch"][k] - br_r = Float64(get(br, "br_r", 0.0)) - br_x = Float64(br["br_x"]) - r2x2 = br_r^2 + br_x^2 - b_val = r2x2 > 0 ? -br_x / r2x2 : 0.0 # DC susceptance (ExaModelsPower formula) - tap_val = Float64(get(br, "tap", 1.0)); tap_val = tap_val ≈ 0 ? 1.0 : tap_val - shift_val = Float64(get(br, "shift", 0.0)) - push!(brs_raw, (br["index"], br["f_bus"], br["t_bus"], - b_val, - Float64(get(br, "rate_a", Inf)), - Float64(get(br, "angmin", -π)), - Float64(get(br, "angmax", π)), - br_r, br_x, - Float64(get(br, "g_fr", 0.0)), - Float64(get(br, "b_fr", 0.0)), - Float64(get(br, "g_to", 0.0)), - Float64(get(br, "b_to", 0.0)), - tap_val, shift_val)) - end - sort!(brs_raw, by = x -> x[1]) - branches = [PowerBranchData(b[1], b[2], b[3], b[4], b[5], b[6], b[7], - b[8], b[9], b[10], b[11], b[12], b[13], b[14], b[15]) - for b in brs_raw] - nBranch = length(branches) - - # ── Loads ───────────────────────────────────────────────────────────────── - loads_raw = Tuple[] - for k in keys(pm["load"]) - l = pm["load"][k] - push!(loads_raw, (l["index"], l["load_bus"], - Float64(get(l, "pd", 0.0)), - Float64(get(l, "qd", 0.0)))) - end - sort!(loads_raw, by = x -> x[1]) - loads = [PowerLoadData(l[1], l[2]) for l in loads_raw] - nLoad = length(loads) - - # Default per-bus demand: sum loads at each bus from PowerModels.json - default_bus_demand = zeros(Float64, nBus) - default_bus_reactive_demand = zeros(Float64, nBus) - for (l_idx, l_bus, l_pd, l_qd) in loads_raw - default_bus_demand[l_bus] += l_pd - default_bus_reactive_demand[l_bus] += l_qd - end - - return PowerData(nBus, nGen, nBranch, nLoad, - buses, gens, branches, loads, - ref_buses, baseMVA, cost_deficit, - default_bus_demand, default_bus_reactive_demand) -end - -# ── Hydro data loader ───────────────────────────────────────────────────────── - -""" - load_hydro_data(hydro_file, inflows_file, power_data; num_stages=nothing) - -> HydroData - -Parse `hydro.json` and `inflows.csv` into `HydroData`. - -`power_data` is needed to map `index_grid` (generator index) to `gen_pos` -(position in `power_data.gens`). -""" -function load_hydro_data(hydro_file::AbstractString, - inflows_file::AbstractString, - power_data::PowerData; - num_stages::Union{Int,Nothing} = nothing) - - hydro_json = JSON.parsefile(hydro_file)["Hydrogenerators"] - nHyd = length(hydro_json) - - # Build gen_index → gen_pos map - gen_idx_to_pos = Dict(g.idx => pos for (pos, g) in enumerate(power_data.gens)) - - # Build hydro.index → hydro_pos map (for upstream connections) - hydro_idx_to_pos = Dict(Int(h["index"]) => pos for (pos, h) in enumerate(hydro_json)) - - initial_volumes = [Float64(h["initial_volume"]) for h in hydro_json] - - # HydroUnitData - units = HydroUnitData[] - for (pos, h) in enumerate(hydro_json) - ig = Int(h["index_grid"]) - gen_pos = get(gen_idx_to_pos, ig, -1) - gen_pos > 0 || @warn "Hydro unit $pos ($(h["name"])): index_grid=$ig not found in generators" - push!(units, HydroUnitData( - pos, gen_pos, - Float64(h["max_volume"]), Float64(h["min_volume"]), - Float64(h["max_turn"]), Float64(h["min_turn"]), - Float64(h["production_factor"]), - Float64(h["spill_cost"]), - Float64(get(h, "minimal_outflow_violation_cost", 0.0)), - Float64(get(h, "minimal_volume_violation_cost", 0.0)), - )) - end - - # Upstream connections: downstream_turn[i] uses hydro.index values - upstream_turns = UpstreamTurn[] - upstream_spills = UpstreamSpill[] - for (pos, h) in enumerate(hydro_json) - for ds_idx in h["downstream_turn"] - ds_pos = get(hydro_idx_to_pos, Int(ds_idx), nothing) - ds_pos !== nothing && push!(upstream_turns, UpstreamTurn(ds_pos, pos)) - end - for ds_idx in h["downstream_spill"] - ds_pos = get(hydro_idx_to_pos, Int(ds_idx), nothing) - ds_pos !== nothing && push!(upstream_spills, UpstreamSpill(ds_pos, pos)) - end - end - - # Inflows - allinflows = CSV.read(inflows_file, Tables.matrix; header=false) - nrows, ncols = size(allinflows) - nScenarios = div(ncols, nHyd) - nStagesSample = isnothing(num_stages) ? nrows : num_stages - - if !isnothing(num_stages) && num_stages > nrows - repeats = div(num_stages, nrows) + 1 - allinflows = vcat([allinflows for _ in 1:repeats]...) - end - allinflows = allinflows[1:nStagesSample, :] - - scenario_inflows = Vector{Matrix{Float64}}(undef, nHyd) - for r in 1:nHyd - scenario_inflows[r] = Float64.(allinflows[:, ((r-1)*nScenarios+1):(r*nScenarios)]) - end - - # Water balance conversion factor K = 0.0036 (standard HydroPowerModels.jl value) - # Converts turbine outflow (m³/s equivalent) to reservoir volume per stage. - K = 0.0036 - - return HydroData(nHyd, units, upstream_turns, upstream_spills, - K, initial_volumes, scenario_inflows, nScenarios, nStagesSample) -end - -# ── Demand loader ───────────────────────────────────────────────────────────── - -""" - load_demand(demand_file, power_data; T=nothing) -> Matrix{Float64} - -Load demand from a CSV file (rows = stages, cols = load indices in order). -Returns a [T × nBus] matrix of per-bus demands (pu). - -If `T` is specified, truncates or repeats rows to match T stages. -If the file has only 1 row, it is repeated for all stages. -""" -function load_demand(demand_file::AbstractString, - power_data::PowerData; - T::Union{Int,Nothing} = nothing) - raw = CSV.read(demand_file, Tables.matrix; header=false) - nrows, ncols = size(raw) - nLoad = power_data.nLoad - ncols == nLoad || @warn "demand file has $ncols cols but nLoad=$nLoad; using min" - - nT = isnothing(T) ? nrows : T - # Repeat rows if needed - if nrows < nT - repeats = div(nT, nrows) + 1 - raw = vcat([raw for _ in 1:repeats]...) - end - raw = raw[1:nT, :] - - # Map load columns to buses - bus_demand = zeros(Float64, nT, power_data.nBus) - for (j, load) in enumerate(power_data.loads) - j > ncols && break - for t in 1:nT - bus_demand[t, load.bus] += Float64(raw[t, j]) - end - end - return bus_demand # [T × nBus] -end - -# ── Scenario sampling ───────────────────────────────────────────────────────── - -""" - sample_scenario(hydro_data, T) -> Vector{Float64} - -Sample one inflow trajectory of length `T*nHyd` (flat, stage-major order). - -Uses **joint** scenario sampling: at each stage one scenario index `ω` is drawn -and applied to all hydro reservoirs, preserving the spatial correlation present -in the historical inflow data. This matches SDDP's `SDDP.parameterize` semantics. -""" -function sample_scenario(hydro_data::HydroData, T::Int) - nHyd = hydro_data.nHyd - w = Vector{Float64}(undef, T * nHyd) - for t in 1:T - t_row = mod1(t, hydro_data.nStagesSample) - # One scenario index per stage — all reservoirs share it (joint sampling). - j = rand(1:hydro_data.nScenarios) - for r in 1:nHyd - w[(t-1)*nHyd + r] = hydro_data.scenario_inflows[r][t_row, j] - end - end - return w -end - -""" - mean_inflow(hydro_data, T) -> Vector{Float64} - -Return the mean inflow trajectory over scenarios as a flat T*nHyd vector. -""" -function mean_inflow(hydro_data::HydroData, T::Int) - nHyd = hydro_data.nHyd - w = Vector{Float64}(undef, T * nHyd) - for t in 1:T - t_row = mod1(t, hydro_data.nStagesSample) - for r in 1:nHyd - w[(t-1)*nHyd + r] = mean(hydro_data.scenario_inflows[r][t_row, :]) - end - end - return w -end diff --git a/examples/HydroPowerModels/hydro_power_exa.jl b/examples/HydroPowerModels/hydro_power_exa.jl deleted file mode 100644 index 40feee9..0000000 --- a/examples/HydroPowerModels/hydro_power_exa.jl +++ /dev/null @@ -1,936 +0,0 @@ -# hydro_power_exa.jl -# -# Builds a multi-stage deterministic equivalent for the Hydro power system -# directly in ExaModels — no JuMP, no MOI.Parameters. -# -# Supports two OPF formulations (same AC polar math as ExaModelsPower.jl): -# :dc — DC linearization (default; fast, single branch flow variable) -# :ac_polar — Full AC polar-coordinate OPF (vm, va, pg, qg, p_fr/q_fr/p_to/q_to) -# -# Multi-stage structure (T stages): -# min Σ_t [ Σ_g gen_cost(g, pg[t,g]) -# + cost_deficit · Σ_b deficit[t,b] -# + (ρ/2) · Σ_r δ[t,r]² ] -# s.t. (DC or AC OPF constraints) -# reservoir dynamics (initial condition, water balance, turbine coupling) -# p_target[t,r] − reservoir[t+1,r] − δ[t,r] = 0 ← ADDED LAST -# -# Target constraints are added last so result.multipliers[target_con_range] -# gives ∇_{x̂} Q directly (envelope theorem for policy gradient). - -using ExaModels -using MadNLP -using LinearAlgebra - -# ── Index helpers ───────────────────────────────────────────────────────────── -# All arrays are flat, stage-major: index (t, i) → (t-1)*n + i - -@inline _bi(nB, t, b) = (t-1)*nB + b # bus / deficit -@inline _gi(nG, t, g) = (t-1)*nG + g # generator -@inline _bri(nBR, t, br) = (t-1)*nBR + br # branch / pf -@inline _ri(nH, t, r) = (t-1)*nH + r # hydro: reservoir / outflow / spill / delta - -# ── Problem struct ──────────────────────────────────────────────────────────── - -""" - HydroExaDEProblem - -Holds the ExaModels deterministic equivalent for the hydro power system. - -Parameters: -- `p_demand` : per-bus per-stage active demand (length T*nBus, stage-major) -- `p_reactive_demand` : per-bus per-stage reactive demand (length T*nBus; nothing for DC) -- `p_x0` : initial reservoir levels (length nHyd) -- `p_inflow` : inflow trajectory (length T*nHyd, stage-major) -- `p_target` : NN-predicted target levels (length T*nHyd, stage-major) -""" -struct HydroExaDEProblem - core - model - # parameters (ExaModels parameter objects) - p_demand - p_reactive_demand # nothing for :dc formulation - p_x0 - p_inflow - p_target - p_penalty_half # ExaModels parameter for (ρ/2)*mult (length T*nHyd) - base_penalty_half::Float64 # ρ/2 at multiplier=1 - p_penalty_l1 # ExaModels parameter for L1 penalty (length T*nHyd) - base_penalty_l1::Float64 # L1 coefficient at multiplier=1 - # sizes - nHyd::Int - nBus::Int - nGen::Int - nBranch::Int - horizon::Int - # formulation - formulation::Symbol # :dc or :ac_polar - # range into result.multipliers for target constraints - target_con_range::UnitRange{Int} -end - -# ── AC branch coefficient helper ────────────────────────────────────────────── - -""" - _ac_branch_coeffs(br, T) -> NamedTuple - -Compute ExaModelsPower-compatible branch coefficients c1..c8 (in type T). - -Formulas match ExaPowerIO.BranchData (same as PowerModels.jl AC polar convention): - tr = tap·cos(shift), ti = tap·sin(shift), ttm = tr² + ti² - g = br_r / (br_r² + br_x²), b = −br_x / (br_r² + br_x²) - c1 = (−g·tr − b·ti) / ttm (to-end active, vm_f*vm_t cross term) - c2 = (−b·tr + g·ti) / ttm (to-end reactive cross term) - c3 = (−g·tr + b·ti) / ttm (from-end active cross term) - c4 = (−b·tr − g·ti) / ttm (from-end reactive cross term) - c5 = (g + g_fr) / ttm (from-end active self term) - c6 = (b + b_fr) / ttm (from-end reactive self term) - c7 = g + g_to (to-end active self term) - c8 = b + b_to (to-end reactive self term) - -Power flow constraints (= 0 form): - p_fr − c5·vm_f² − c3·vm_f·vm_t·cos(θ_f−θ_t) − c4·vm_f·vm_t·sin(θ_f−θ_t) = 0 - q_fr + c6·vm_f² + c4·vm_f·vm_t·cos(θ_f−θ_t) − c3·vm_f·vm_t·sin(θ_f−θ_t) = 0 - p_to − c7·vm_t² − c1·vm_t·vm_f·cos(θ_t−θ_f) − c2·vm_t·vm_f·sin(θ_t−θ_f) = 0 - q_to + c8·vm_t² + c2·vm_t·vm_f·cos(θ_t−θ_f) − c1·vm_t·vm_f·sin(θ_t−θ_f) = 0 -""" -function _ac_branch_coeffs(br::PowerBranchData, ::Type{T}) where {T} - r2x2 = br.br_r^2 + br.br_x^2 - g = r2x2 > 0 ? T(br.br_r / r2x2) : zero(T) - b = r2x2 > 0 ? T(-br.br_x / r2x2) : zero(T) - tap = T(br.tap) - sh = T(br.shift) - tr = tap * cos(sh) - ti = tap * sin(sh) - ttm = tr^2 + ti^2 - ttm = ttm > 0 ? ttm : one(T) - return ( - c1 = (-g * tr - b * ti) / ttm, - c2 = (-b * tr + g * ti) / ttm, - c3 = (-g * tr + b * ti) / ttm, - c4 = (-b * tr - g * ti) / ttm, - c5 = (g + T(br.g_fr)) / ttm, - c6 = (b + T(br.b_fr)) / ttm, - c7 = g + T(br.g_to), - c8 = b + T(br.b_to), - ) -end - -# ── auto target penalty ─────────────────────────────────────────────────────── - -""" - auto_target_penalty(power_data, hydro_data) -> Float64 - -Compute the automatic target-penalty coefficient ρ such that ExaModels' -`(ρ/2)·δ²` uses the same effective multiplier as JuMP's `penalty_l2 = :auto`. - -JuMP's `:auto` takes the maximum absolute linear coefficient in the subproblem -objective, which includes generator costs AND hydro penalty costs (spill, -min-outflow violation, min-volume violation). We mirror that here: - - ρ = 2 × max(max_gen_cost, max_spill_cost, max_min_out_cost, max_min_vol_cost) -""" -function auto_target_penalty(power_data::PowerData, hydro_data::HydroData) - max_gen = maximum(max(g.cost1, g.cost2) for g in power_data.gens) - max_hyd = maximum( - max(h.spill_cost, h.min_out_cost, h.min_vol_cost) - for h in hydro_data.units - ) - return 2.0 * max(max_gen, max_hyd) -end - -# ── Builder ─────────────────────────────────────────────────────────────────── - -""" - build_hydro_de(power_data, hydro_data, T; - backend=nothing, float_type=Float64, formulation=:dc, - target_penalty=:auto, target_penalty_l1=:auto, - demand_matrix=nothing, - reactive_demand_matrix=nothing, deficit_cost=nothing) - -> HydroExaDEProblem - -Build the T-stage hydro-power deterministic equivalent. - -`formulation` selects the OPF model: -- `:dc` — DC linearization (default; fast) -- `:ac_polar` — AC polar-coordinate OPF (full nonlinear) - -`demand_matrix` is an optional [T × nBus] matrix of initial active demands (pu). -If nothing, uses `power_data.default_bus_demand` for all stages. - -`reactive_demand_matrix` is an optional [T × nBus] matrix for reactive demand -(AC only). If nothing, uses `power_data.default_bus_reactive_demand`. - -`deficit_cost` overrides `power_data.cost_deficit` (the load-shedding penalty per pu). -Pass a large value (e.g. 1e5, >> max thermal cost) to effectively enforce hard KCL. - -`target_penalty` sets the L2 coefficient ρ for the `(ρ/2)·δ²` target slack penalty. -Pass `:auto` (default) to use `2 × max_gen_cost`, matching JuMP's `penalty_l2 = :auto`. - -`target_penalty_l1` sets the L1 coefficient for the `λ·|δ|` target slack penalty. -Pass `:auto` (default) to use the same value as L2 ρ. Pass `nothing` to disable L1. -The L1 term is reformulated as `λ·(δ⁺ + δ⁻)` with `δ = δ⁺ − δ⁻`, `δ⁺,δ⁻ ≥ 0`. -""" -function build_hydro_de(power_data::PowerData, - hydro_data::HydroData, - T::Int; - backend = nothing, - float_type::Type{<:AbstractFloat} = Float64, - formulation::Symbol = :dc, - target_penalty::Union{Real,Symbol} = :auto, - target_penalty_l1::Union{Real,Symbol,Nothing} = :auto, - demand_matrix = nothing, - reactive_demand_matrix = nothing, - deficit_cost::Union{Nothing,Real} = nothing, - load_scaler::Real = 1.0) - - formulation in (:dc, :ac_polar) || - error("formulation must be :dc or :ac_polar, got :$formulation") - - if formulation === :dc - return _build_dc_hydro_de(power_data, hydro_data, T; - backend=backend, float_type=float_type, - target_penalty=target_penalty, - target_penalty_l1=target_penalty_l1, - demand_matrix=demand_matrix, - deficit_cost=deficit_cost, - load_scaler=load_scaler) - else - return _build_ac_hydro_de(power_data, hydro_data, T; - backend=backend, float_type=float_type, - target_penalty=target_penalty, - target_penalty_l1=target_penalty_l1, - demand_matrix=demand_matrix, - reactive_demand_matrix=reactive_demand_matrix, - deficit_cost=deficit_cost, - load_scaler=load_scaler) - end -end - -# ── DC builder ──────────────────────────────────────────────────────────────── - -function _build_dc_hydro_de(power_data::PowerData, - hydro_data::HydroData, - T::Int; - backend = nothing, - float_type::Type{<:AbstractFloat} = Float64, - target_penalty::Union{Real,Symbol} = :auto, - target_penalty_l1::Union{Real,Symbol,Nothing} = :auto, - demand_matrix = nothing, - deficit_cost::Union{Nothing,Real} = nothing, - load_scaler::Real = 1.0) - - nBus = power_data.nBus - nGen = power_data.nGen - nBranch = power_data.nBranch - nHyd = hydro_data.nHyd - K = float_type(hydro_data.K) - ρ = float_type(target_penalty === :auto ? auto_target_penalty(power_data, hydro_data) : target_penalty) - ρ_l1 = if target_penalty_l1 === :auto - ρ - elseif target_penalty_l1 === nothing - zero(float_type) - else - float_type(target_penalty_l1) - end - use_l1 = ρ_l1 > 0 - baseMVA = float_type(power_data.baseMVA) - cd = float_type(deficit_cost !== nothing ? deficit_cost : power_data.cost_deficit) - - core = ExaModels.ExaCore(float_type; backend = backend) - - # ── Variables ───────────────────────────────────────────────────────────── - - # Voltage angles: T*nBus (free) - va = ExaModels.variable(core, T * nBus) - - # Generator active power: T*nGen - pg_lb = float_type.(repeat([g.pmin for g in power_data.gens], T)) - pg_ub = float_type.(repeat([g.pmax for g in power_data.gens], T)) - pg = ExaModels.variable(core, T * nGen; lvar = pg_lb, uvar = pg_ub) - - # Branch power flows (DC, one per undirected branch): T*nBranch - pf_lb = float_type.(repeat([-b.rate_a for b in power_data.branches], T)) - pf_ub = float_type.(repeat([ b.rate_a for b in power_data.branches], T)) - pf = ExaModels.variable(core, T * nBranch; lvar = pf_lb, uvar = pf_ub) - - # Deficit (load shedding): T*nBus (non-negative) - deficit = ExaModels.variable(core, T * nBus; lvar = float_type(0)) - - # Reservoir levels: (T+1)*nHyd - res_lb = float_type.(repeat([h.min_vol for h in hydro_data.units], T+1)) - res_ub = float_type.(repeat([h.max_vol for h in hydro_data.units], T+1)) - reservoir = ExaModels.variable(core, (T+1) * nHyd; lvar = res_lb, uvar = res_ub) - - # Turbine outflow: T*nHyd - out_lb = float_type.(repeat([h.min_turn for h in hydro_data.units], T)) - out_ub = float_type.(repeat([h.max_turn for h in hydro_data.units], T)) - outflow = ExaModels.variable(core, T * nHyd; lvar = out_lb, uvar = out_ub) - - # Spill: T*nHyd (non-negative) - spill = ExaModels.variable(core, T * nHyd; lvar = float_type(0)) - - # Target slack: δ = δ⁺ − δ⁻ with δ⁺,δ⁻ ≥ 0 (L1+L2 Lagrangian penalty) - delta_pos = ExaModels.variable(core, T * nHyd; lvar = float_type(0)) - delta_neg = ExaModels.variable(core, T * nHyd; lvar = float_type(0)) - - # ── Parameters ──────────────────────────────────────────────────────────── - - init_demand = if demand_matrix !== nothing - float_type.(load_scaler .* [demand_matrix[t, b] for t in 1:T for b in 1:nBus]) - else - float_type.(load_scaler .* repeat(power_data.default_bus_demand, T)) - end - - p_demand = ExaModels.parameter(core, init_demand) - p_x0 = ExaModels.parameter(core, zeros(float_type, nHyd)) - p_inflow = ExaModels.parameter(core, zeros(float_type, T * nHyd)) - p_target = ExaModels.parameter(core, zeros(float_type, T * nHyd)) - p_penalty_half = ExaModels.parameter(core, fill(float_type(ρ / 2), T * nHyd)) - p_penalty_l1 = ExaModels.parameter(core, fill(ρ_l1, T * nHyd)) - - # ── Objective ───────────────────────────────────────────────────────────── - - gen_cost_items = [(t = t, g = g_pos, - c1 = float_type(g.cost1), c2 = float_type(g.cost2)) - for t in 1:T for (g_pos, g) in enumerate(power_data.gens)] - ExaModels.objective(core, - item.c2 * pg[_gi(nGen, item.t, item.g)]^2 - + item.c1 * pg[_gi(nGen, item.t, item.g)] - for item in gen_cost_items - ) - - def_cost_items = [(t = t, b = b, c = cd) for t in 1:T for b in 1:nBus] - ExaModels.objective(core, - item.c * deficit[_bi(nBus, item.t, item.b)] - for item in def_cost_items - ) - - # L2 penalty: (ρ/2)·(δ⁺ − δ⁻)² - delta_items = [(idx = _ri(nHyd, t, r),) for t in 1:T for r in 1:nHyd] - ExaModels.objective(core, - p_penalty_half[item.idx] * (delta_pos[item.idx] - delta_neg[item.idx])^2 - for item in delta_items - ) - - # L1 penalty: λ·(δ⁺ + δ⁻) - if use_l1 - ExaModels.objective(core, - p_penalty_l1[item.idx] * (delta_pos[item.idx] + delta_neg[item.idx]) - for item in delta_items - ) - end - - # ── Constraints ─────────────────────────────────────────────────────────── - n_con = 0 - - # 1. Reference angle: va[t, ref] = 0 - nRef = length(power_data.ref_buses) - ref_items = [(t = t, ref = ref) for t in 1:T for ref in power_data.ref_buses] - ExaModels.constraint(core, - va[_bi(nBus, item.t, item.ref)] - for item in ref_items - ) - n_con += T * nRef - - # 2. Ohm's law: b·(va_f - va_t) - pf = 0 - ohm_items = [(t = t, - f = br.f_bus, - tb = br.t_bus, - br = br_pos, - b = float_type(br.b)) - for t in 1:T for (br_pos, br) in enumerate(power_data.branches)] - ExaModels.constraint(core, - item.b * (va[_bi(nBus, item.t, item.f)] - va[_bi(nBus, item.t, item.tb)]) - - pf[_bri(nBranch, item.t, item.br)] - for item in ohm_items - ) - n_con += T * nBranch - - # 3. Phase angle difference limits: angmin ≤ va_f - va_t ≤ angmax - ang_lb = float_type.(repeat([br.angmin for br in power_data.branches], T)) - ang_ub = float_type.(repeat([br.angmax for br in power_data.branches], T)) - ang_items = [(t = t, f = br.f_bus, tb = br.t_bus) - for t in 1:T for br in power_data.branches] - ExaModels.constraint(core, - va[_bi(nBus, item.t, item.f)] - va[_bi(nBus, item.t, item.tb)] - for item in ang_items; - lcon = ang_lb, ucon = ang_ub, - ) - n_con += T * nBranch - - # 4. KCL power balance (T * nBus equalities) - kcl_init_items = [(t = t, b = b) for t in 1:T for b in 1:nBus] - c_kcl = ExaModels.constraint(core, - p_demand[_bi(nBus, item.t, item.b)] - for item in kcl_init_items - ) - kcl_gen_items = [(t = t, brow = _bi(nBus, t, g.bus), gcol = _gi(nGen, t, g_pos)) - for t in 1:T for (g_pos, g) in enumerate(power_data.gens)] - ExaModels.constraint!(core, c_kcl, - item.brow => -pg[item.gcol] - for item in kcl_gen_items - ) - kcl_fr_items = [(t = t, brow = _bi(nBus, t, br.f_bus), bcol = _bri(nBranch, t, br_pos)) - for t in 1:T for (br_pos, br) in enumerate(power_data.branches)] - ExaModels.constraint!(core, c_kcl, - item.brow => pf[item.bcol] - for item in kcl_fr_items - ) - kcl_to_items = [(t = t, brow = _bi(nBus, t, br.t_bus), bcol = _bri(nBranch, t, br_pos)) - for t in 1:T for (br_pos, br) in enumerate(power_data.branches)] - ExaModels.constraint!(core, c_kcl, - item.brow => -pf[item.bcol] - for item in kcl_to_items - ) - kcl_def_items = [(t = t, brow = _bi(nBus, t, b), dcol = _bi(nBus, t, b)) - for t in 1:T for b in 1:nBus] - ExaModels.constraint!(core, c_kcl, - item.brow => -deficit[item.dcol] - for item in kcl_def_items - ) - n_con += T * nBus - - # 5. Initial reservoir condition - ic_items = [(r = r,) for r in 1:nHyd] - ExaModels.constraint(core, - reservoir[_ri(nHyd, 1, item.r)] - p_x0[item.r] - for item in ic_items - ) - n_con += nHyd - - # 6. Water balance - wb_items = [(res_next = _ri(nHyd, t+1, r), - res_curr = _ri(nHyd, t, r), - out_idx = _ri(nHyd, t, r), - spill_idx = _ri(nHyd, t, r), - inflow_p = _ri(nHyd, t, r), - K = K) - for t in 1:T for r in 1:nHyd] - c_wb = ExaModels.constraint(core, - reservoir[item.res_next] - reservoir[item.res_curr] - + item.K * outflow[item.out_idx] - + spill[item.spill_idx] - - item.K * p_inflow[item.inflow_p] - for item in wb_items - ) - if !isempty(hydro_data.upstream_turns) - wb_turn_items = [(row = _ri(nHyd, t, conn.downstream_pos), - col = _ri(nHyd, t, conn.upstream_pos), K = K) - for t in 1:T for conn in hydro_data.upstream_turns] - ExaModels.constraint!(core, c_wb, - item.row => -item.K * outflow[item.col] - for item in wb_turn_items - ) - end - if !isempty(hydro_data.upstream_spills) - wb_spill_items = [(row = _ri(nHyd, t, conn.downstream_pos), - col = _ri(nHyd, t, conn.upstream_pos)) - for t in 1:T for conn in hydro_data.upstream_spills] - ExaModels.constraint!(core, c_wb, - item.row => -spill[item.col] - for item in wb_spill_items - ) - end - n_con += T * nHyd - - # 7. Turbine coupling - tc_items = [(gen_col = _gi(nGen, t, h.gen_pos), - out_col = _ri(nHyd, t, h.pos), - baseMVA = baseMVA, - pf_h = float_type(h.pf)) - for t in 1:T for h in hydro_data.units] - ExaModels.constraint(core, - item.baseMVA * pg[item.gen_col] - item.pf_h * outflow[item.out_col] - for item in tc_items - ) - n_con += T * nHyd - - # ── TARGET CONSTRAINTS (ADDED LAST) ─────────────────────────────────────── - # x̂ − x − (δ⁺ − δ⁻) = 0 - target_items = [(param_idx = _ri(nHyd, t, r), - res_idx = _ri(nHyd, t+1, r), - delta_idx = _ri(nHyd, t, r)) - for t in 1:T for r in 1:nHyd] - ExaModels.constraint(core, - p_target[item.param_idx] - reservoir[item.res_idx] - delta_pos[item.delta_idx] + delta_neg[item.delta_idx] - for item in target_items - ) - target_con_range = (n_con + 1):(n_con + T * nHyd) - - model = ExaModels.ExaModel(core) - - return HydroExaDEProblem( - core, model, - p_demand, nothing, p_x0, p_inflow, p_target, - p_penalty_half, Float64(ρ / 2), - p_penalty_l1, Float64(ρ_l1), - nHyd, nBus, nGen, nBranch, T, - :dc, target_con_range, - ) -end - -# ── AC polar builder ────────────────────────────────────────────────────────── - -function _build_ac_hydro_de(power_data::PowerData, - hydro_data::HydroData, - T::Int; - backend = nothing, - float_type::Type{<:AbstractFloat} = Float64, - target_penalty::Union{Real,Symbol} = :auto, - target_penalty_l1::Union{Real,Symbol,Nothing} = :auto, - demand_matrix = nothing, - reactive_demand_matrix = nothing, - deficit_cost::Union{Nothing,Real} = nothing, - load_scaler::Real = 1.0) - - nBus = power_data.nBus - nGen = power_data.nGen - nBranch = power_data.nBranch - nHyd = hydro_data.nHyd - K = float_type(hydro_data.K) - ρ = float_type(target_penalty === :auto ? auto_target_penalty(power_data, hydro_data) : target_penalty) - ρ_l1 = if target_penalty_l1 === :auto - ρ - elseif target_penalty_l1 === nothing - zero(float_type) - else - float_type(target_penalty_l1) - end - use_l1 = ρ_l1 > 0 - baseMVA = float_type(power_data.baseMVA) - cd = float_type(deficit_cost !== nothing ? deficit_cost : power_data.cost_deficit) - - core = ExaModels.ExaCore(float_type; backend = backend) - - # ── Variables ───────────────────────────────────────────────────────────── - - # Voltage angles: T*nBus (free) - va = ExaModels.variable(core, T * nBus) - - # Voltage magnitudes: T*nBus (bounded; initialized to 1.0) - vm_lb = float_type.(repeat([b.vmin for b in power_data.buses], T)) - vm_ub = float_type.(repeat([b.vmax for b in power_data.buses], T)) - vm = ExaModels.variable(core, T * nBus; - lvar = vm_lb, uvar = vm_ub, - start = ones(float_type, T * nBus)) - - # Generator active power: T*nGen - pg_lb = float_type.(repeat([g.pmin for g in power_data.gens], T)) - pg_ub = float_type.(repeat([g.pmax for g in power_data.gens], T)) - pg = ExaModels.variable(core, T * nGen; lvar = pg_lb, uvar = pg_ub) - - # Generator reactive power: T*nGen - qg_lb = float_type.(repeat([isfinite(g.qmin) ? g.qmin : -1e4 for g in power_data.gens], T)) - qg_ub = float_type.(repeat([isfinite(g.qmax) ? g.qmax : 1e4 for g in power_data.gens], T)) - qg = ExaModels.variable(core, T * nGen; lvar = qg_lb, uvar = qg_ub) - - # Branch from-end active/reactive power flows: T*nBranch each - p_fr_lb = float_type.(repeat([-b.rate_a for b in power_data.branches], T)) - p_fr_ub = float_type.(repeat([ b.rate_a for b in power_data.branches], T)) - p_fr = ExaModels.variable(core, T * nBranch; lvar = p_fr_lb, uvar = p_fr_ub) - q_fr = ExaModels.variable(core, T * nBranch; lvar = p_fr_lb, uvar = p_fr_ub) - - # Branch to-end active/reactive power flows: T*nBranch each - p_to = ExaModels.variable(core, T * nBranch; lvar = p_fr_lb, uvar = p_fr_ub) - q_to = ExaModels.variable(core, T * nBranch; lvar = p_fr_lb, uvar = p_fr_ub) - - # Active deficit (load shedding): T*nBus (non-negative) - deficit = ExaModels.variable(core, T * nBus; lvar = float_type(0)) - - # Reactive deficit (free; allows reactive balance at zero cost) - deficit_q = ExaModels.variable(core, T * nBus) - - # Reservoir levels: (T+1)*nHyd - res_lb = float_type.(repeat([h.min_vol for h in hydro_data.units], T+1)) - res_ub = float_type.(repeat([h.max_vol for h in hydro_data.units], T+1)) - reservoir = ExaModels.variable(core, (T+1) * nHyd; lvar = res_lb, uvar = res_ub) - - # Turbine outflow: T*nHyd - out_lb = float_type.(repeat([h.min_turn for h in hydro_data.units], T)) - out_ub = float_type.(repeat([h.max_turn for h in hydro_data.units], T)) - outflow = ExaModels.variable(core, T * nHyd; lvar = out_lb, uvar = out_ub) - - # Spill: T*nHyd (non-negative) - spill = ExaModels.variable(core, T * nHyd; lvar = float_type(0)) - - # Target slack: δ = δ⁺ − δ⁻ with δ⁺,δ⁻ ≥ 0 (L1+L2 Lagrangian penalty) - delta_pos = ExaModels.variable(core, T * nHyd; lvar = float_type(0)) - delta_neg = ExaModels.variable(core, T * nHyd; lvar = float_type(0)) - - # ── Parameters ──────────────────────────────────────────────────────────── - - init_demand = if demand_matrix !== nothing - float_type.(load_scaler .* [demand_matrix[t, b] for t in 1:T for b in 1:nBus]) - else - float_type.(load_scaler .* repeat(power_data.default_bus_demand, T)) - end - - init_reactive_demand = if reactive_demand_matrix !== nothing - float_type.(load_scaler .* [reactive_demand_matrix[t, b] for t in 1:T for b in 1:nBus]) - else - float_type.(load_scaler .* repeat(power_data.default_bus_reactive_demand, T)) - end - - p_demand = ExaModels.parameter(core, init_demand) - p_reactive_demand = ExaModels.parameter(core, init_reactive_demand) - p_x0 = ExaModels.parameter(core, zeros(float_type, nHyd)) - p_inflow = ExaModels.parameter(core, zeros(float_type, T * nHyd)) - p_target = ExaModels.parameter(core, zeros(float_type, T * nHyd)) - p_penalty_half = ExaModels.parameter(core, fill(float_type(ρ / 2), T * nHyd)) - p_penalty_l1 = ExaModels.parameter(core, fill(ρ_l1, T * nHyd)) - - # ── Precompute branch AC coefficients ───────────────────────────────────── - - br_ac = [_ac_branch_coeffs(br, float_type) for br in power_data.branches] - - # ── Objective ───────────────────────────────────────────────────────────── - - gen_cost_items = [(t = t, g = g_pos, - c1 = float_type(g.cost1), c2 = float_type(g.cost2)) - for t in 1:T for (g_pos, g) in enumerate(power_data.gens)] - ExaModels.objective(core, - item.c2 * pg[_gi(nGen, item.t, item.g)]^2 - + item.c1 * pg[_gi(nGen, item.t, item.g)] - for item in gen_cost_items - ) - - def_cost_items = [(t = t, b = b, c = cd) for t in 1:T for b in 1:nBus] - ExaModels.objective(core, - item.c * deficit[_bi(nBus, item.t, item.b)] - for item in def_cost_items - ) - - # L2 penalty: (ρ/2)·(δ⁺ − δ⁻)² - delta_items = [(idx = _ri(nHyd, t, r),) for t in 1:T for r in 1:nHyd] - ExaModels.objective(core, - p_penalty_half[item.idx] * (delta_pos[item.idx] - delta_neg[item.idx])^2 - for item in delta_items - ) - - # L1 penalty: λ·(δ⁺ + δ⁻) - if use_l1 - ExaModels.objective(core, - p_penalty_l1[item.idx] * (delta_pos[item.idx] + delta_neg[item.idx]) - for item in delta_items - ) - end - - # ── Constraints ─────────────────────────────────────────────────────────── - n_con = 0 - - # 1. Reference angle: va[t, ref] = 0 - nRef = length(power_data.ref_buses) - ref_items = [(t = t, ref = ref) for t in 1:T for ref in power_data.ref_buses] - ExaModels.constraint(core, - va[_bi(nBus, item.t, item.ref)] - for item in ref_items - ) - n_con += T * nRef - - # 2. AC from-end active power flow: p_fr − c5·vm_f² − c3·vm_f·vm_t·cos(θ) − c4·vm_f·vm_t·sin(θ) = 0 - pfr_items = [(t = t, - f = br.f_bus, tb = br.t_bus, br = br_pos, - c3 = br_ac[br_pos].c3, c4 = br_ac[br_pos].c4, c5 = br_ac[br_pos].c5) - for t in 1:T for (br_pos, br) in enumerate(power_data.branches)] - ExaModels.constraint(core, - p_fr[_bri(nBranch, item.t, item.br)] - - item.c5 * vm[_bi(nBus, item.t, item.f)]^2 - - item.c3 * vm[_bi(nBus, item.t, item.f)] * vm[_bi(nBus, item.t, item.tb)] - * cos(va[_bi(nBus, item.t, item.f)] - va[_bi(nBus, item.t, item.tb)]) - - item.c4 * vm[_bi(nBus, item.t, item.f)] * vm[_bi(nBus, item.t, item.tb)] - * sin(va[_bi(nBus, item.t, item.f)] - va[_bi(nBus, item.t, item.tb)]) - for item in pfr_items - ) - n_con += T * nBranch - - # 3. AC from-end reactive power flow: q_fr + c6·vm_f² + c4·vm_f·vm_t·cos(θ) − c3·vm_f·vm_t·sin(θ) = 0 - qfr_items = [(t = t, - f = br.f_bus, tb = br.t_bus, br = br_pos, - c3 = br_ac[br_pos].c3, c4 = br_ac[br_pos].c4, c6 = br_ac[br_pos].c6) - for t in 1:T for (br_pos, br) in enumerate(power_data.branches)] - ExaModels.constraint(core, - q_fr[_bri(nBranch, item.t, item.br)] - + item.c6 * vm[_bi(nBus, item.t, item.f)]^2 - + item.c4 * vm[_bi(nBus, item.t, item.f)] * vm[_bi(nBus, item.t, item.tb)] - * cos(va[_bi(nBus, item.t, item.f)] - va[_bi(nBus, item.t, item.tb)]) - - item.c3 * vm[_bi(nBus, item.t, item.f)] * vm[_bi(nBus, item.t, item.tb)] - * sin(va[_bi(nBus, item.t, item.f)] - va[_bi(nBus, item.t, item.tb)]) - for item in qfr_items - ) - n_con += T * nBranch - - # 4. AC to-end active power flow: p_to − c7·vm_t² − c1·vm_t·vm_f·cos(θ_t−θ_f) − c2·vm_t·vm_f·sin(θ_t−θ_f) = 0 - pto_items = [(t = t, - f = br.f_bus, tb = br.t_bus, br = br_pos, - c1 = br_ac[br_pos].c1, c2 = br_ac[br_pos].c2, c7 = br_ac[br_pos].c7) - for t in 1:T for (br_pos, br) in enumerate(power_data.branches)] - ExaModels.constraint(core, - p_to[_bri(nBranch, item.t, item.br)] - - item.c7 * vm[_bi(nBus, item.t, item.tb)]^2 - - item.c1 * vm[_bi(nBus, item.t, item.tb)] * vm[_bi(nBus, item.t, item.f)] - * cos(va[_bi(nBus, item.t, item.tb)] - va[_bi(nBus, item.t, item.f)]) - - item.c2 * vm[_bi(nBus, item.t, item.tb)] * vm[_bi(nBus, item.t, item.f)] - * sin(va[_bi(nBus, item.t, item.tb)] - va[_bi(nBus, item.t, item.f)]) - for item in pto_items - ) - n_con += T * nBranch - - # 5. AC to-end reactive power flow: q_to + c8·vm_t² + c2·vm_t·vm_f·cos(θ_t−θ_f) − c1·vm_t·vm_f·sin(θ_t−θ_f) = 0 - qto_items = [(t = t, - f = br.f_bus, tb = br.t_bus, br = br_pos, - c1 = br_ac[br_pos].c1, c2 = br_ac[br_pos].c2, c8 = br_ac[br_pos].c8) - for t in 1:T for (br_pos, br) in enumerate(power_data.branches)] - ExaModels.constraint(core, - q_to[_bri(nBranch, item.t, item.br)] - + item.c8 * vm[_bi(nBus, item.t, item.tb)]^2 - + item.c2 * vm[_bi(nBus, item.t, item.tb)] * vm[_bi(nBus, item.t, item.f)] - * cos(va[_bi(nBus, item.t, item.tb)] - va[_bi(nBus, item.t, item.f)]) - - item.c1 * vm[_bi(nBus, item.t, item.tb)] * vm[_bi(nBus, item.t, item.f)] - * sin(va[_bi(nBus, item.t, item.tb)] - va[_bi(nBus, item.t, item.f)]) - for item in qto_items - ) - n_con += T * nBranch - - # 6. Phase angle difference limits: angmin ≤ va_f − va_t ≤ angmax - ang_lb = float_type.(repeat([br.angmin for br in power_data.branches], T)) - ang_ub = float_type.(repeat([br.angmax for br in power_data.branches], T)) - ang_items = [(t = t, f = br.f_bus, tb = br.t_bus) - for t in 1:T for br in power_data.branches] - ExaModels.constraint(core, - va[_bi(nBus, item.t, item.f)] - va[_bi(nBus, item.t, item.tb)] - for item in ang_items; - lcon = ang_lb, ucon = ang_ub, - ) - n_con += T * nBranch - - # 7. Active KCL: pd + gs·vm² − deficit − Σpg + Σp_fr + Σp_to = 0 - kcl_p_init = [(t = t, b = b, gs = float_type(power_data.buses[b].gs)) - for t in 1:T for b in 1:nBus] - c_kcl_p = ExaModels.constraint(core, - p_demand[_bi(nBus, item.t, item.b)] - + item.gs * vm[_bi(nBus, item.t, item.b)]^2 - for item in kcl_p_init - ) - kcl_pg_items = [(t = t, brow = _bi(nBus, t, g.bus), gcol = _gi(nGen, t, g_pos)) - for t in 1:T for (g_pos, g) in enumerate(power_data.gens)] - ExaModels.constraint!(core, c_kcl_p, - item.brow => -pg[item.gcol] - for item in kcl_pg_items - ) - kcl_pfr_items = [(t = t, brow = _bi(nBus, t, br.f_bus), bcol = _bri(nBranch, t, br_pos)) - for t in 1:T for (br_pos, br) in enumerate(power_data.branches)] - ExaModels.constraint!(core, c_kcl_p, - item.brow => p_fr[item.bcol] - for item in kcl_pfr_items - ) - kcl_pto_items = [(t = t, brow = _bi(nBus, t, br.t_bus), bcol = _bri(nBranch, t, br_pos)) - for t in 1:T for (br_pos, br) in enumerate(power_data.branches)] - ExaModels.constraint!(core, c_kcl_p, - item.brow => p_to[item.bcol] - for item in kcl_pto_items - ) - kcl_def_items = [(t = t, brow = _bi(nBus, t, b), dcol = _bi(nBus, t, b)) - for t in 1:T for b in 1:nBus] - ExaModels.constraint!(core, c_kcl_p, - item.brow => -deficit[item.dcol] - for item in kcl_def_items - ) - n_con += T * nBus - - # 8. Reactive KCL: qd − bs·vm² − deficit_q − Σqg + Σq_fr + Σq_to = 0 - kcl_q_init = [(t = t, b = b, bs = float_type(power_data.buses[b].bs)) - for t in 1:T for b in 1:nBus] - c_kcl_q = ExaModels.constraint(core, - p_reactive_demand[_bi(nBus, item.t, item.b)] - - item.bs * vm[_bi(nBus, item.t, item.b)]^2 - for item in kcl_q_init - ) - kcl_qg_items = [(t = t, brow = _bi(nBus, t, g.bus), gcol = _gi(nGen, t, g_pos)) - for t in 1:T for (g_pos, g) in enumerate(power_data.gens)] - ExaModels.constraint!(core, c_kcl_q, - item.brow => -qg[item.gcol] - for item in kcl_qg_items - ) - kcl_qfr_items = [(t = t, brow = _bi(nBus, t, br.f_bus), bcol = _bri(nBranch, t, br_pos)) - for t in 1:T for (br_pos, br) in enumerate(power_data.branches)] - ExaModels.constraint!(core, c_kcl_q, - item.brow => q_fr[item.bcol] - for item in kcl_qfr_items - ) - kcl_qto_items = [(t = t, brow = _bi(nBus, t, br.t_bus), bcol = _bri(nBranch, t, br_pos)) - for t in 1:T for (br_pos, br) in enumerate(power_data.branches)] - ExaModels.constraint!(core, c_kcl_q, - item.brow => q_to[item.bcol] - for item in kcl_qto_items - ) - ExaModels.constraint!(core, c_kcl_q, - item.brow => -deficit_q[item.dcol] - for item in kcl_def_items - ) - n_con += T * nBus - - # 9. Initial reservoir condition - ic_items = [(r = r,) for r in 1:nHyd] - ExaModels.constraint(core, - reservoir[_ri(nHyd, 1, item.r)] - p_x0[item.r] - for item in ic_items - ) - n_con += nHyd - - # 10. Water balance - wb_items = [(res_next = _ri(nHyd, t+1, r), - res_curr = _ri(nHyd, t, r), - out_idx = _ri(nHyd, t, r), - spill_idx = _ri(nHyd, t, r), - inflow_p = _ri(nHyd, t, r), - K = K) - for t in 1:T for r in 1:nHyd] - c_wb = ExaModels.constraint(core, - reservoir[item.res_next] - reservoir[item.res_curr] - + item.K * outflow[item.out_idx] - + spill[item.spill_idx] - - item.K * p_inflow[item.inflow_p] - for item in wb_items - ) - if !isempty(hydro_data.upstream_turns) - wb_turn_items = [(row = _ri(nHyd, t, conn.downstream_pos), - col = _ri(nHyd, t, conn.upstream_pos), K = K) - for t in 1:T for conn in hydro_data.upstream_turns] - ExaModels.constraint!(core, c_wb, - item.row => -item.K * outflow[item.col] - for item in wb_turn_items - ) - end - if !isempty(hydro_data.upstream_spills) - wb_spill_items = [(row = _ri(nHyd, t, conn.downstream_pos), - col = _ri(nHyd, t, conn.upstream_pos)) - for t in 1:T for conn in hydro_data.upstream_spills] - ExaModels.constraint!(core, c_wb, - item.row => -spill[item.col] - for item in wb_spill_items - ) - end - n_con += T * nHyd - - # 11. Turbine coupling - tc_items = [(gen_col = _gi(nGen, t, h.gen_pos), - out_col = _ri(nHyd, t, h.pos), - baseMVA = baseMVA, - pf_h = float_type(h.pf)) - for t in 1:T for h in hydro_data.units] - ExaModels.constraint(core, - item.baseMVA * pg[item.gen_col] - item.pf_h * outflow[item.out_col] - for item in tc_items - ) - n_con += T * nHyd - - # ── TARGET CONSTRAINTS (ADDED LAST) ─────────────────────────────────────── - # x̂ − x − (δ⁺ − δ⁻) = 0 - target_items = [(param_idx = _ri(nHyd, t, r), - res_idx = _ri(nHyd, t+1, r), - delta_idx = _ri(nHyd, t, r)) - for t in 1:T for r in 1:nHyd] - ExaModels.constraint(core, - p_target[item.param_idx] - reservoir[item.res_idx] - delta_pos[item.delta_idx] + delta_neg[item.delta_idx] - for item in target_items - ) - target_con_range = (n_con + 1):(n_con + T * nHyd) - - model = ExaModels.ExaModel(core) - - return HydroExaDEProblem( - core, model, - p_demand, p_reactive_demand, p_x0, p_inflow, p_target, - p_penalty_half, Float64(ρ / 2), - p_penalty_l1, Float64(ρ_l1), - nHyd, nBus, nGen, nBranch, T, - :ac_polar, target_con_range, - ) -end - -# ── Parameter updates ───────────────────────────────────────────────────────── - -""" - set_demand!(prob, demand_matrix) - -Update the per-stage bus demands. `demand_matrix` is [T × nBus] (Float64 or Float32). -""" -function set_demand!(prob::HydroExaDEProblem, demand_matrix::AbstractMatrix) - T, nB = size(demand_matrix) - T == prob.horizon || error("demand_matrix must have T=$(prob.horizon) rows") - nB == prob.nBus || error("demand_matrix must have nBus=$(prob.nBus) cols") - flat = [demand_matrix[t, b] for t in 1:T for b in 1:nB] - ExaModels.set_parameter!(prob.core, prob.p_demand, flat) - return prob -end - -""" - set_inflows!(prob, w) - -Set the inflow trajectory. `w` is a flat vector of length `T*nHyd` (stage-major). -""" -function set_inflows!(prob::HydroExaDEProblem, w::AbstractVector) - expected = prob.horizon * prob.nHyd - length(w) == expected || error("w must have length T*nHyd=$expected") - ExaModels.set_parameter!(prob.core, prob.p_inflow, w) - return prob -end - -# ── Post-processing ─────────────────────────────────────────────────────────── - -""" - hydro_solution(prob, result) -> NamedTuple - -Reshape the flat solution vector into named components. -`delta` is reconstructed as `delta_pos - delta_neg`. - -DC: (va, pg, pf, deficit, reservoir, outflow, spill, delta) -AC: (va, vm, pg, qg, p_fr, q_fr, p_to, q_to, deficit, deficit_q, - reservoir, outflow, spill, delta) -""" -function hydro_solution(prob::HydroExaDEProblem, result) - T = prob.horizon - nH = prob.nHyd - nG = prob.nGen - nBR = prob.nBranch - nB = prob.nBus - sol = result.solution - off = 0 - - if prob.formulation === :dc - va_sol = reshape(sol[off .+ (1:T*nB)], nB, T); off += T*nB - pg_sol = reshape(sol[off .+ (1:T*nG)], nG, T); off += T*nG - pf_sol = reshape(sol[off .+ (1:T*nBR)], nBR, T); off += T*nBR - def_sol = reshape(sol[off .+ (1:T*nB)], nB, T); off += T*nB - res_sol = reshape(sol[off .+ (1:(T+1)*nH)], nH, T+1); off += (T+1)*nH - out_sol = reshape(sol[off .+ (1:T*nH)], nH, T); off += T*nH - spill_sol = reshape(sol[off .+ (1:T*nH)], nH, T); off += T*nH - dp_sol = reshape(sol[off .+ (1:T*nH)], nH, T); off += T*nH - dn_sol = reshape(sol[off .+ (1:T*nH)], nH, T); off += T*nH - delta_sol = dp_sol .- dn_sol - return (va=va_sol, pg=pg_sol, pf=pf_sol, deficit=def_sol, - reservoir=res_sol, outflow=out_sol, spill=spill_sol, delta=delta_sol) - else # :ac_polar - va_sol = reshape(sol[off .+ (1:T*nB)], nB, T); off += T*nB - vm_sol = reshape(sol[off .+ (1:T*nB)], nB, T); off += T*nB - pg_sol = reshape(sol[off .+ (1:T*nG)], nG, T); off += T*nG - qg_sol = reshape(sol[off .+ (1:T*nG)], nG, T); off += T*nG - p_fr_sol = reshape(sol[off .+ (1:T*nBR)], nBR, T); off += T*nBR - q_fr_sol = reshape(sol[off .+ (1:T*nBR)], nBR, T); off += T*nBR - p_to_sol = reshape(sol[off .+ (1:T*nBR)], nBR, T); off += T*nBR - q_to_sol = reshape(sol[off .+ (1:T*nBR)], nBR, T); off += T*nBR - def_sol = reshape(sol[off .+ (1:T*nB)], nB, T); off += T*nB - def_q_sol = reshape(sol[off .+ (1:T*nB)], nB, T); off += T*nB - res_sol = reshape(sol[off .+ (1:(T+1)*nH)], nH, T+1); off += (T+1)*nH - out_sol = reshape(sol[off .+ (1:T*nH)], nH, T); off += T*nH - spill_sol = reshape(sol[off .+ (1:T*nH)], nH, T); off += T*nH - dp_sol = reshape(sol[off .+ (1:T*nH)], nH, T); off += T*nH - dn_sol = reshape(sol[off .+ (1:T*nH)], nH, T); off += T*nH - delta_sol = dp_sol .- dn_sol - return (va=va_sol, vm=vm_sol, pg=pg_sol, qg=qg_sol, - p_fr=p_fr_sol, q_fr=q_fr_sol, p_to=p_to_sol, q_to=q_to_sol, - deficit=def_sol, deficit_q=def_q_sol, - reservoir=res_sol, outflow=out_sol, spill=spill_sol, delta=delta_sol) - end -end diff --git a/examples/HydroPowerModels/train_hydro_exa.jl b/examples/HydroPowerModels/train_hydro_exa.jl deleted file mode 100644 index 6ec71e9..0000000 --- a/examples/HydroPowerModels/train_hydro_exa.jl +++ /dev/null @@ -1,371 +0,0 @@ -# train_hydro_exa.jl -# -# HydroPowerModels training with ExaModels + MadNLP (DC or AC OPF). -# Uses train_tsddr from DecisionRulesExa — no custom functions or structs needed. -# -# Usage: -# julia --project -t auto train_hydro_exa.jl - -using DecisionRulesExa -using ExaModels -using Flux -using Statistics, Random, Dates -using Wandb, Logging -using JLD2 -using MadNLP -using MadNLPGPU, KernelAbstractions, CUDA -using CUDSS, CUDSS_jll, cuDNN - -const SCRIPT_DIR = dirname(@__FILE__) -include(joinpath(SCRIPT_DIR, "hydro_power_data.jl")) -include(joinpath(SCRIPT_DIR, "hydro_power_exa.jl")) - -# ── Configuration ───────────────────────────────────────────────────────────── - -const CASE_NAME = "bolivia" -const FORMULATION = :ac_polar # :dc or :ac_polar -const FORM_LABEL = FORMULATION === :ac_polar ? "ACPPowerModel" : "DCPPowerModel" - -const CASE_DIR = joinpath(SCRIPT_DIR, CASE_NAME) -const PM_FILE = joinpath(CASE_DIR, "PowerModels.json") -const HYDRO_FILE = joinpath(CASE_DIR, "hydro.json") -const INFLOW_FILE = joinpath(CASE_DIR, "inflows.csv") -const DEMAND_FILE = joinpath(CASE_DIR, "demand.csv") - -const LAYERS = [128, 128] -const ACTIVATION = sigmoid -const NUM_STAGES = parse(Int, get(ENV, "DR_NUM_STAGES", "126")) -const NUM_EPOCHS = parse(Int, get(ENV, "DR_NUM_EPOCHS", "80")) -const NUM_BATCHES = 100 -const NUM_TRAIN_PER_BATCH = 1 -const NUM_EVAL_SCENARIOS = 4 -const EVAL_EVERY = 25 -const LR = 1f-3 -const GRAD_CLIP = parse(Float32, get(ENV, "DR_GRAD_CLIP", "10")) - -const TARGET_PEN_ARG = :auto -const DEFICIT_COST = 1e5 -const USE_GPU = true -const load_scaler = 0.6 -const NUM_WORKERS = 1 - -const _PENALTY_MODE = get(ENV, "DR_PENALTY_SCHEDULE", "annealed") -const PENALTY_SCHEDULE = if _PENALTY_MODE == "annealed" - [ - (1, div(NUM_EPOCHS * NUM_BATCHES, 4), 0.1), - (div(NUM_EPOCHS * NUM_BATCHES, 4) + 1, div(NUM_EPOCHS * NUM_BATCHES, 4) * 2, 1.0), - (div(NUM_EPOCHS * NUM_BATCHES, 4) * 2 + 1, div(NUM_EPOCHS * NUM_BATCHES, 4) * 3, 10.0), - (div(NUM_EPOCHS * NUM_BATCHES, 4) * 3 + 1, NUM_EPOCHS * NUM_BATCHES, 30.0), - ] -else - [(1, NUM_EPOCHS * NUM_BATCHES, 1.0)] -end - -# Optional: ramp num_train_per_batch and eval scenarios over training. -# Set to `nothing` to use fixed NUM_TRAIN_PER_BATCH / NUM_EVAL_SCENARIOS. -const NUM_TRAIN_SCHEDULE = nothing # e.g. [(1,500,1),(501,2000,4),(2001,4000,8)] -const EVAL_SCHEDULE = nothing # e.g. [(1,2000,4),(2001,4000,32)] - -const SOLVER_KWARGS = (print_level = MadNLP.ERROR, tol = 1e-6, max_iter = 9000) - -const _CLIP_TAG = GRAD_CLIP > 0 ? "-clip$(Int(GRAD_CLIP))" : "" -const _SCHED_TAG = _PENALTY_MODE == "annealed" ? "-anneal" : "-const" -const RUN_NAME = "$(CASE_NAME)-$(FORM_LABEL)-h$(NUM_STAGES)-deteq-gpu$(_CLIP_TAG)$(_SCHED_TAG)-$(Dates.format(now(), "yyyymmdd-HHMMSS"))" -const MODEL_DIR = joinpath(CASE_DIR, FORM_LABEL, "models") -mkpath(MODEL_DIR) -const MODEL_PATH = joinpath(MODEL_DIR, RUN_NAME * ".jld2") - -const PRE_TRAINED = nothing - -# ── Load data ───────────────────────────────────────────────────────────────── - -@info "Loading power system data..." -power_data = load_power_data(PM_FILE) -@info " nBus=$(power_data.nBus) nGen=$(power_data.nGen)" - -@info "Loading hydro data..." -hydro_data = load_hydro_data(HYDRO_FILE, INFLOW_FILE, power_data; - num_stages = NUM_STAGES * 10) -nHyd = hydro_data.nHyd -T = NUM_STAGES -@info " nHyd=$(nHyd) nScenarios=$(hydro_data.nScenarios)" - -demand_mat = if isfile(DEMAND_FILE) - @info "Loading demand from $(DEMAND_FILE)..." - load_demand(DEMAND_FILE, power_data; T = T) -else - nothing -end - -# ── Build ExaModels DE ──────────────────────────────────────────────────────── - -resolved_pen = TARGET_PEN_ARG === :auto ? - auto_target_penalty(power_data, hydro_data) : - Float64(TARGET_PEN_ARG) -@info "Auto target penalty: ρ=$(round(resolved_pen; digits=2))" - -backend = USE_GPU ? (@info "Using GPU backend"; CUDA.CUDABackend()) : - (@info "Using CPU backend"; nothing) - -function _build_de() - build_hydro_de(power_data, hydro_data, T; - backend = backend, - float_type = Float64, - formulation = FORMULATION, - target_penalty = TARGET_PEN_ARG, - deficit_cost = DEFICIT_COST, - demand_matrix = demand_mat, - load_scaler = load_scaler, - ) -end - -@info "Building $(T)-stage ExaModels DE (formulation=$FORMULATION)..." -prob = _build_de() - -@info "Building $(NUM_WORKERS)-worker problem pool..." -problem_pool = [(prob, prob.p_x0, prob.p_target, prob.p_inflow)] -for i in 2:NUM_WORKERS - p = _build_de() - push!(problem_pool, (p, p.p_x0, p.p_target, p.p_inflow)) -end -@info " Pool ready: $(NUM_WORKERS) independent DE instances on GPU" - -x0_init = Float32.([clamp(hydro_data.initial_volumes[r], - hydro_data.units[r].min_vol, - hydro_data.units[r].max_vol) - for r in 1:nHyd]) - -# ── Smoke test ──────────────────────────────────────────────────────────────── - -w_mean = mean_inflow(hydro_data, T) -ExaModels.set_parameter!(prob.core, prob.p_x0, x0_init) -ExaModels.set_parameter!(prob.core, prob.p_inflow, w_mean) -ExaModels.set_parameter!(prob.core, prob.p_target, zeros(T * nHyd)) -@info "Smoke test: solving DE with mean inflows..." -result0 = MadNLP.madnlp(prob.model; SOLVER_KWARGS..., print_level = MadNLP.WARN) -@info " Status: $(result0.status) Objective: $(round(result0.objective; digits=4))" -isfinite(result0.objective) || error("Smoke test returned non-finite objective") -solve_succeeded(result0) || @warn "Smoke test did not fully converge; proceeding anyway" - -resolved_pen_l1 = prob.base_penalty_l1 - -# ── Policy ──────────────────────────────────────────────────────────────────── - -policy = StateConditionedPolicy(nHyd, nHyd, nHyd, LAYERS; - activation = ACTIVATION, - encoder_type = Flux.LSTM) - -if !isnothing(PRE_TRAINED) - @info "Loading pre-trained model from $(PRE_TRAINED)..." - Flux.loadmodel!(policy, JLD2.load(PRE_TRAINED, "model_state")) -end - -# ── W&B logging ─────────────────────────────────────────────────────────────── - -lg = WandbLogger( - project = "RL", - name = RUN_NAME, - save_code = false, - config = Dict( - "case" => CASE_NAME, - "formulation" => FORM_LABEL, - "num_stages" => T, - "layers" => LAYERS, - "activation" => string(ACTIVATION), - "target_penalty" => "auto=$(round(resolved_pen; digits=2))", - "target_penalty_l1" => "auto=$(round(resolved_pen_l1; digits=2))", - "deficit_cost" => DEFICIT_COST, - "num_epochs" => NUM_EPOCHS, - "num_batches" => NUM_BATCHES, - "num_train_per_batch" => NUM_TRAIN_PER_BATCH, - "num_eval_scenarios" => NUM_EVAL_SCENARIOS, - "eval_every" => EVAL_EVERY, - "lr" => LR, - "grad_clip" => GRAD_CLIP, - "backend" => USE_GPU ? "GPU" : "CPU", - "load_scaler" => load_scaler, - "penalty_schedule" => string(PENALTY_SCHEDULE), - "num_train_schedule" => string(something(NUM_TRAIN_SCHEDULE, "fixed")), - "eval_schedule" => string(something(EVAL_SCHEDULE, "fixed")), - "num_workers" => NUM_WORKERS, - ), -) - -# ── Training ────────────────────────────────────────────────────────────────── - -Random.seed!(8788) - -best_obj = Inf -epoch_losses = Float64[] - -stage_demand = demand_mat === nothing ? nothing : demand_mat[1:1, :] -function _build_rollout_de() - build_hydro_de(power_data, hydro_data, 1; - backend = nothing, - float_type = Float64, - formulation = FORMULATION, - target_penalty = TARGET_PEN_ARG, - deficit_cost = DEFICIT_COST, - demand_matrix = stage_demand, - load_scaler = load_scaler, - ) -end -rollout_prob = _build_rollout_de() -n_rollout_pool = max(NUM_WORKERS, NUM_EVAL_SCENARIOS) -rollout_pool = [_build_rollout_de() for _ in 1:n_rollout_pool] -@info "Rollout pool ready: $(n_rollout_pool) CPU stage-problem copies" - -function set_hydro_rollout_stage!(stage_prob, state_in, wt, target, stage) - ExaModels.set_parameter!(stage_prob.core, stage_prob.p_x0, state_in) - ExaModels.set_parameter!(stage_prob.core, stage_prob.p_inflow, wt) - if demand_mat !== nothing - set_demand!(stage_prob, load_scaler .* demand_mat[stage:stage, :]) - end - ExaModels.set_parameter!(stage_prob.core, stage_prob.p_target, target) - return stage_prob -end - -hydro_realized_state(stage_prob, result) = - Array(hydro_solution(stage_prob, result).reservoir[:, end]) - -function hydro_objective_no_target_penalty(stage_prob, result) - sol = hydro_solution(stage_prob, result) - delta = Array(sol.delta) - penalty_l2_cost = (resolved_pen / 2) * sum(abs2, delta) - penalty_l1_cost = resolved_pen_l1 * sum(abs, delta) - return result.objective - penalty_l2_cost - penalty_l1_cost -end - -Random.seed!(8789) -eval_scenarios = [sample_scenario(hydro_data, T) for _ in 1:NUM_EVAL_SCENARIOS] -rollout_evaluation = RolloutEvaluation( - rollout_prob, - x0_init, - eval_scenarios; - horizon = T, - n_uncertainty = nHyd, - set_stage_parameters! = set_hydro_rollout_stage!, - realized_state = hydro_realized_state, - objective_no_target_penalty = hydro_objective_no_target_penalty, - madnlp_kwargs = SOLVER_KWARGS, - warmstart = true, - stride = EVAL_EVERY, - policy_state = :target, - stage_problem_pool = rollout_pool, - active_scenarios = NUM_EVAL_SCENARIOS, -) -realized_rollout_evaluation = RolloutEvaluation( - rollout_prob, - x0_init, - eval_scenarios; - horizon = T, - n_uncertainty = nHyd, - set_stage_parameters! = set_hydro_rollout_stage!, - realized_state = hydro_realized_state, - objective_no_target_penalty = hydro_objective_no_target_penalty, - madnlp_kwargs = SOLVER_KWARGS, - warmstart = true, - stride = EVAL_EVERY, - policy_state = :realized, - stage_problem_pool = rollout_pool, - active_scenarios = NUM_EVAL_SCENARIOS, -) - -Random.seed!(8788) - -function _schedule_value(schedule, iter, default) - for (lo, hi, val) in schedule - lo <= iter <= hi && return val - end - return default -end - -current_penalty_mult = Ref(NaN) - -train_tsddr( - policy, - x0_init, - prob, - prob.p_x0, - prob.p_target, - prob.p_inflow, - () -> sample_scenario(hydro_data, T); - num_batches = NUM_EPOCHS * NUM_BATCHES, - num_train_per_batch = NUM_TRAIN_PER_BATCH, - optimizer = GRAD_CLIP > 0 ? - Flux.Optimisers.OptimiserChain( - Flux.Optimisers.ClipGrad(GRAD_CLIP), - Flux.Adam(LR), - ) : Flux.Adam(LR), - madnlp_kwargs = SOLVER_KWARGS, - warmstart = true, - problem_pool = problem_pool, - adjust_hyperparameters = (iter, opt_state, n) -> begin - mult = _schedule_value(PENALTY_SCHEDULE, iter, last(PENALTY_SCHEDULE)[3]) - if mult != current_penalty_mult[] - current_penalty_mult[] = mult - ρ_half_scaled = prob.base_penalty_half * mult - ρ_l1_scaled = prob.base_penalty_l1 * mult - penalty_vals = fill(ρ_half_scaled, T * nHyd) - penalty_l1_vals = fill(ρ_l1_scaled, T * nHyd) - for (p, _, _, _) in problem_pool - ExaModels.set_parameter!(p.core, p.p_penalty_half, penalty_vals) - ExaModels.set_parameter!(p.core, p.p_penalty_l1, penalty_l1_vals) - end - @info "Penalty multiplier → $mult (ρ/2 = $(round(ρ_half_scaled; digits=2)), λ_l1 = $(round(ρ_l1_scaled; digits=2)))" - end - if !isnothing(EVAL_SCHEDULE) - n_eval = _schedule_value(EVAL_SCHEDULE, iter, NUM_EVAL_SCENARIOS) - rollout_evaluation.active_scenarios = n_eval - realized_rollout_evaluation.active_scenarios = n_eval - end - return isnothing(NUM_TRAIN_SCHEDULE) ? n : _schedule_value(NUM_TRAIN_SCHEDULE, iter, n) - end, - record_loss = (iter, m, loss, tag) -> begin - metrics = Dict{String, Any}(tag => loss, "batch" => iter) - isfinite(loss) && push!(epoch_losses, loss) - - if iter % EVAL_EVERY == 0 - rollout_evaluation(iter, m) - realized_rollout_evaluation(iter, m) - metrics["metrics/rollout_objective_no_target_penalty"] = - rollout_evaluation.last_objective_no_target_penalty - metrics["metrics/rollout_objective_no_deficit"] = - rollout_evaluation.last_objective_no_target_penalty - metrics["metrics/rollout_target_violation_share"] = - rollout_evaluation.last_violation_share - metrics["metrics/rollout_realized_objective_no_target_penalty"] = - realized_rollout_evaluation.last_objective_no_target_penalty - metrics["metrics/rollout_realized_objective_no_deficit"] = - realized_rollout_evaluation.last_objective_no_target_penalty - metrics["metrics/rollout_realized_target_violation_share"] = - realized_rollout_evaluation.last_violation_share - metrics["metrics/rollout_n_ok"] = - realized_rollout_evaluation.last_n_ok - end - - if !isnan(current_penalty_mult[]) - metrics["metrics/target_penalty_multiplier"] = current_penalty_mult[] - end - - batch_in_epoch = (iter - 1) % NUM_BATCHES + 1 - if batch_in_epoch == NUM_BATCHES - epoch = (iter - 1) ÷ NUM_BATCHES + 1 - mean_loss = isempty(epoch_losses) ? NaN : mean(epoch_losses) - n_ok = length(epoch_losses) - empty!(epoch_losses) - Wandb.log(lg, Dict("metrics/epoch_objective" => mean_loss, "epoch" => epoch)) - @info "Epoch $epoch/$NUM_EPOCHS mean=$(round(mean_loss; digits=2)) ok=$n_ok/$NUM_BATCHES" - if isfinite(mean_loss) && mean_loss < best_obj - global best_obj = mean_loss - jldsave(MODEL_PATH; model_state = Flux.state(cpu(m))) - @info " → New best: $(round(mean_loss; digits=4)) — saved $MODEL_PATH" - end - end - Wandb.log(lg, metrics) - return false - end, -) - -close(lg) -@info "Done. Best model saved to: $(MODEL_PATH)" diff --git a/examples/HydroPowerModels/train_hydro_exa_critic.jl b/examples/HydroPowerModels/train_hydro_exa_critic.jl deleted file mode 100644 index 3d9a5a0..0000000 --- a/examples/HydroPowerModels/train_hydro_exa_critic.jl +++ /dev/null @@ -1,465 +0,0 @@ -# train_hydro_exa_critic.jl -# -# HydroPowerModels training with ExaModels + MadNLP (DC or AC OPF). -# Uses train_tsddr from DecisionRulesExa with a scalar critic control variate. -# -# Usage: -# julia --project -t auto train_hydro_exa_critic.jl - -using DecisionRulesExa -using ExaModels -using Flux -using Statistics, Random, Dates -using Wandb, Logging -using JLD2 -using MadNLP -using MadNLPGPU, KernelAbstractions, CUDA -using CUDSS, CUDSS_jll, cuDNN - -const SCRIPT_DIR = dirname(@__FILE__) -include(joinpath(SCRIPT_DIR, "hydro_power_data.jl")) -include(joinpath(SCRIPT_DIR, "hydro_power_exa.jl")) - -# ── Configuration ───────────────────────────────────────────────────────────── - -const CASE_NAME = "bolivia" -const FORMULATION = :ac_polar # :dc or :ac_polar -const FORM_LABEL = FORMULATION === :ac_polar ? "ACPPowerModel" : "DCPPowerModel" - -const CASE_DIR = joinpath(SCRIPT_DIR, CASE_NAME) -const PM_FILE = joinpath(CASE_DIR, "PowerModels.json") -const HYDRO_FILE = joinpath(CASE_DIR, "hydro.json") -const INFLOW_FILE = joinpath(CASE_DIR, "inflows.csv") -const DEMAND_FILE = joinpath(CASE_DIR, "demand.csv") - -const LAYERS = [128, 128] -const ACTIVATION = sigmoid -const NUM_STAGES = 96 -const NUM_EPOCHS = 80 -const NUM_BATCHES = 100 -const MAX_EVAL_SCENARIOS = 32 -const EVAL_EVERY = 25 - -const EVAL_SCHEDULE = [ - (1, div(NUM_EPOCHS * NUM_BATCHES, 2), 4), - (div(NUM_EPOCHS * NUM_BATCHES, 2) + 1, NUM_EPOCHS * NUM_BATCHES, MAX_EVAL_SCENARIOS), -] -const LR = 1f-3 -const GRAD_CLIP = 10.0f0 -const CRITIC_LR = 5f-4 -const CRITIC_HIDDEN = [256, 128] -const CRITIC_VALUE_LOSS_WEIGHT = 1.0 -const CRITIC_GRADIENT_LOSS_WEIGHT = 0.0 -const CRITIC_CV_WEIGHT = 0.5 -const CRITIC_UPDATES_PER_BATCH = 2 -const CRITIC_BUFFER_SIZE = 512 -const CRITIC_BATCH_SIZE = 32 - -const TARGET_PEN_ARG = :auto -const DEFICIT_COST = 1e5 -const USE_GPU = true -const load_scaler = 0.6 -const NUM_WORKERS = 4 -const CRITIC_ROLLOUT_SAMPLES_PER_BATCH = 0 # eval rollouts feed the critic via external_critic_samples -const CRITIC_POLICY_STATE = :target # set to :realized for closed-loop critic targets -const CRITIC_ROLLOUT_OBJECTIVE = :objective -const NUM_CHEAP_CRITIC_SAMPLES_PER_BATCH = 4 * NUM_WORKERS - -const PENALTY_SCHEDULE = [ - (1, div(NUM_EPOCHS * NUM_BATCHES, 4), 0.1), - (div(NUM_EPOCHS * NUM_BATCHES, 4) + 1, div(NUM_EPOCHS * NUM_BATCHES, 4) * 2, 1.0), - (div(NUM_EPOCHS * NUM_BATCHES, 4) * 2 + 1, div(NUM_EPOCHS * NUM_BATCHES, 4) * 3, 10.0), - (div(NUM_EPOCHS * NUM_BATCHES, 4) * 3 + 1, NUM_EPOCHS * NUM_BATCHES, 30.0), -] - -const NUM_TRAIN_SCHEDULE = [ - (1, div(NUM_EPOCHS * NUM_BATCHES, 5), NUM_WORKERS), - (div(NUM_EPOCHS * NUM_BATCHES, 5) + 1, div(NUM_EPOCHS * NUM_BATCHES, 5) * 2, 2 * NUM_WORKERS), - (div(NUM_EPOCHS * NUM_BATCHES, 5) * 2 + 1, div(NUM_EPOCHS * NUM_BATCHES, 5) * 3, 4 * NUM_WORKERS), - (div(NUM_EPOCHS * NUM_BATCHES, 5) * 3 + 1, div(NUM_EPOCHS * NUM_BATCHES, 5) * 4, 8 * NUM_WORKERS), - (div(NUM_EPOCHS * NUM_BATCHES, 5) * 4 + 1, NUM_EPOCHS * NUM_BATCHES, 8 * NUM_WORKERS), -] - -const SOLVER_KWARGS = (print_level = MadNLP.ERROR, tol = 1e-6, max_iter = 9000) - -const RUN_NAME = "$(CASE_NAME)-$(FORM_LABEL)-h$(NUM_STAGES)-deteq-gpu-critic-cv-$(Dates.format(now(), "yyyymmdd-HHMMSS"))" -const MODEL_DIR = joinpath(CASE_DIR, FORM_LABEL, "models") -mkpath(MODEL_DIR) -const MODEL_PATH = joinpath(MODEL_DIR, RUN_NAME * ".jld2") - -const PRE_TRAINED = nothing - -# ── Load data ───────────────────────────────────────────────────────────────── - -@info "Loading power system data..." -power_data = load_power_data(PM_FILE) -@info " nBus=$(power_data.nBus) nGen=$(power_data.nGen)" - -@info "Loading hydro data..." -hydro_data = load_hydro_data(HYDRO_FILE, INFLOW_FILE, power_data; - num_stages = NUM_STAGES * 10) -nHyd = hydro_data.nHyd -T = NUM_STAGES -@info " nHyd=$(nHyd) nScenarios=$(hydro_data.nScenarios)" - -demand_mat = if isfile(DEMAND_FILE) - @info "Loading demand from $(DEMAND_FILE)..." - load_demand(DEMAND_FILE, power_data; T = T) -else - nothing -end - -# ── Build ExaModels DE ──────────────────────────────────────────────────────── - -resolved_pen = TARGET_PEN_ARG === :auto ? - auto_target_penalty(power_data, hydro_data) : - Float64(TARGET_PEN_ARG) -@info "Auto target penalty: ρ=$(round(resolved_pen; digits=2))" - -backend = USE_GPU ? (@info "Using GPU backend"; CUDA.CUDABackend()) : - (@info "Using CPU backend"; nothing) - -function _build_de() - build_hydro_de(power_data, hydro_data, T; - backend = backend, - float_type = Float64, - formulation = FORMULATION, - target_penalty = TARGET_PEN_ARG, - deficit_cost = DEFICIT_COST, - demand_matrix = demand_mat, - load_scaler = load_scaler, - ) -end - -@info "Building $(T)-stage ExaModels DE (formulation=$FORMULATION)..." -prob = _build_de() - -@info "Building $(NUM_WORKERS)-worker problem pool..." -problem_pool = [(prob, prob.p_x0, prob.p_target, prob.p_inflow)] -for i in 2:NUM_WORKERS - p = _build_de() - push!(problem_pool, (p, p.p_x0, p.p_target, p.p_inflow)) -end -@info " Pool ready: $(NUM_WORKERS) independent DE instances on GPU" - -x0_init = Float32.([clamp(hydro_data.initial_volumes[r], - hydro_data.units[r].min_vol, - hydro_data.units[r].max_vol) - for r in 1:nHyd]) - -# ── Critic/control variate ─────────────────────────────────────────────────── - -volume_scale = Float32.([max(abs(u.max_vol), abs(u.min_vol), 1.0) for u in hydro_data.units]) -inflow_scale = Float32.([ - max(maximum(abs, hydro_data.scenario_inflows[r]), 1.0) - for r in 1:nHyd -]) - -const _full_inflow_scale = repeat(inflow_scale, T) -const _full_volume_scale = repeat(volume_scale, T) - -function hydro_critic_featurizer(initial_state, w_flat, xhat_flat) - x0_scaled = Float32.(initial_state) ./ volume_scale - w_scaled = Float32.(w_flat) ./ _full_inflow_scale - x_scaled = Float32.(xhat_flat) ./ _full_volume_scale - return vcat(x0_scaled, w_scaled, x_scaled) -end - -critic_input_dim = nHyd + 2 * T * nHyd -critic_layers = Any[] -critic_in = critic_input_dim -for h in CRITIC_HIDDEN - push!(critic_layers, Flux.Dense(critic_in => h, tanh)) - global critic_in = h -end -push!(critic_layers, Flux.Dense(critic_in => 1)) -critic = Flux.Chain(critic_layers...) - -control_variate = ScalarCriticControlVariate( - critic; - featurizer = hydro_critic_featurizer, - value_loss_weight = CRITIC_VALUE_LOSS_WEIGHT, - gradient_loss_weight = CRITIC_GRADIENT_LOSS_WEIGHT, -) - -# ── Smoke test ──────────────────────────────────────────────────────────────── - -w_mean = mean_inflow(hydro_data, T) -ExaModels.set_parameter!(prob.core, prob.p_x0, x0_init) -ExaModels.set_parameter!(prob.core, prob.p_inflow, w_mean) -ExaModels.set_parameter!(prob.core, prob.p_target, zeros(T * nHyd)) -@info "Smoke test: solving DE with mean inflows..." -result0 = MadNLP.madnlp(prob.model; SOLVER_KWARGS..., print_level = MadNLP.WARN) -@info " Status: $(result0.status) Objective: $(round(result0.objective; digits=4))" -isfinite(result0.objective) || error("Smoke test returned non-finite objective") -solve_succeeded(result0) || @warn "Smoke test did not fully converge; proceeding anyway" - -# ── Policy ──────────────────────────────────────────────────────────────────── - -policy = StateConditionedPolicy(nHyd, nHyd, nHyd, LAYERS; - activation = ACTIVATION, - encoder_type = Flux.LSTM) - -if !isnothing(PRE_TRAINED) - @info "Loading pre-trained model from $(PRE_TRAINED)..." - Flux.loadmodel!(policy, JLD2.load(PRE_TRAINED, "model_state")) -end - -# ── W&B logging ─────────────────────────────────────────────────────────────── - -lg = WandbLogger( - project = "RL", - name = RUN_NAME, - save_code = false, - config = Dict( - "case" => CASE_NAME, - "formulation" => FORM_LABEL, - "num_stages" => T, - "layers" => LAYERS, - "activation" => string(ACTIVATION), - "target_penalty" => "auto=$(round(resolved_pen; digits=2))", - "deficit_cost" => DEFICIT_COST, - "num_epochs" => NUM_EPOCHS, - "num_batches" => NUM_BATCHES, - "max_eval_scenarios" => MAX_EVAL_SCENARIOS, - "eval_schedule" => string(EVAL_SCHEDULE), - "eval_every" => EVAL_EVERY, - "lr" => LR, - "grad_clip" => GRAD_CLIP, - "critic_lr" => CRITIC_LR, - "critic_hidden" => CRITIC_HIDDEN, - "critic_value_loss_weight" => CRITIC_VALUE_LOSS_WEIGHT, - "critic_gradient_loss_weight" => CRITIC_GRADIENT_LOSS_WEIGHT, - "critic_cv_weight" => CRITIC_CV_WEIGHT, - "critic_updates_per_batch" => CRITIC_UPDATES_PER_BATCH, - "critic_buffer_size" => CRITIC_BUFFER_SIZE, - "critic_batch_size" => CRITIC_BATCH_SIZE, - "critic_training_target" => "rollout", - "critic_rollout_samples_per_batch" => CRITIC_ROLLOUT_SAMPLES_PER_BATCH, - "critic_policy_state" => string(CRITIC_POLICY_STATE), - "critic_rollout_objective" => string(CRITIC_ROLLOUT_OBJECTIVE), - "num_cheap_critic_samples_per_batch" => NUM_CHEAP_CRITIC_SAMPLES_PER_BATCH, - "backend" => USE_GPU ? "GPU" : "CPU", - "load_scaler" => load_scaler, - "penalty_schedule" => string(PENALTY_SCHEDULE), - "num_train_schedule" => string(NUM_TRAIN_SCHEDULE), - "num_workers" => NUM_WORKERS, - ), -) - -# ── Training ────────────────────────────────────────────────────────────────── - -Random.seed!(8788) - -best_obj = Inf -epoch_losses = Float64[] - -stage_demand = demand_mat === nothing ? nothing : demand_mat[1:1, :] -function _build_rollout_de() - build_hydro_de(power_data, hydro_data, 1; - backend = nothing, - float_type = Float64, - formulation = FORMULATION, - target_penalty = TARGET_PEN_ARG, - deficit_cost = DEFICIT_COST, - demand_matrix = stage_demand, - load_scaler = load_scaler, - ) -end -rollout_prob = _build_rollout_de() -rollout_pool = [_build_rollout_de() for _ in 1:NUM_WORKERS] -@info "Rollout pool ready: $(NUM_WORKERS) CPU stage-problem copies" - -function set_hydro_rollout_stage!(stage_prob, state_in, wt, target, stage) - ExaModels.set_parameter!(stage_prob.core, stage_prob.p_x0, state_in) - ExaModels.set_parameter!(stage_prob.core, stage_prob.p_inflow, wt) - if demand_mat !== nothing - set_demand!(stage_prob, load_scaler .* demand_mat[stage:stage, :]) - end - ExaModels.set_parameter!(stage_prob.core, stage_prob.p_target, target) - return stage_prob -end - -hydro_realized_state(stage_prob, result) = - Array(hydro_solution(stage_prob, result).reservoir[:, end]) - -function hydro_objective_no_target_penalty(stage_prob, result) - sol = hydro_solution(stage_prob, result) - return result.objective - (resolved_pen / 2) * sum(abs2, Array(sol.delta)) -end - -Random.seed!(8789) -eval_scenarios = [sample_scenario(hydro_data, T) for _ in 1:MAX_EVAL_SCENARIOS] -rollout_evaluation = RolloutEvaluation( - rollout_prob, - x0_init, - eval_scenarios; - horizon = T, - n_uncertainty = nHyd, - set_stage_parameters! = set_hydro_rollout_stage!, - realized_state = hydro_realized_state, - objective_no_target_penalty = hydro_objective_no_target_penalty, - madnlp_kwargs = SOLVER_KWARGS, - warmstart = true, - stride = EVAL_EVERY, - policy_state = :target, - stage_problem_pool = rollout_pool, - active_scenarios = 4, -) -realized_rollout_evaluation = RolloutEvaluation( - rollout_prob, - x0_init, - eval_scenarios; - horizon = T, - n_uncertainty = nHyd, - set_stage_parameters! = set_hydro_rollout_stage!, - realized_state = hydro_realized_state, - objective_no_target_penalty = hydro_objective_no_target_penalty, - madnlp_kwargs = SOLVER_KWARGS, - warmstart = true, - stride = EVAL_EVERY, - policy_state = :realized, - stage_problem_pool = rollout_pool, - active_scenarios = 4, -) - -critic_training_target = RolloutCriticTarget( - rollout_prob; - horizon = T, - n_uncertainty = nHyd, - set_stage_parameters! = set_hydro_rollout_stage!, - realized_state = hydro_realized_state, - objective_no_target_penalty = hydro_objective_no_target_penalty, - madnlp_kwargs = SOLVER_KWARGS, - warmstart = true, - policy_state = CRITIC_POLICY_STATE, - objective_value = CRITIC_ROLLOUT_OBJECTIVE, -) - -Random.seed!(8788) - -function _schedule_value(schedule, iter, default) - for (lo, hi, val) in schedule - lo <= iter <= hi && return val - end - return default -end - -current_penalty_mult = Ref(NaN) -shared_critic_samples = Any[] - -train_tsddr( - policy, - x0_init, - prob, - prob.p_x0, - prob.p_target, - prob.p_inflow, - () -> sample_scenario(hydro_data, T); # returns flat Float32 vector, length T*nHyd - num_batches = NUM_EPOCHS * NUM_BATCHES, - num_train_per_batch = NUM_WORKERS, - optimizer = Flux.Optimisers.OptimiserChain( - Flux.Optimisers.ClipGrad(GRAD_CLIP), - Flux.Adam(LR), - ), - madnlp_kwargs = SOLVER_KWARGS, - warmstart = true, - problem_pool = problem_pool, - control_variate = control_variate, - actor_gradient_mode = :control_variate, - critic_cv_weight = CRITIC_CV_WEIGHT, - critic_updates_per_batch = CRITIC_UPDATES_PER_BATCH, - critic_buffer_size = CRITIC_BUFFER_SIZE, - critic_batch_size = CRITIC_BATCH_SIZE, - critic_training_target = critic_training_target, - critic_rollout_samples_per_batch = CRITIC_ROLLOUT_SAMPLES_PER_BATCH, - num_cheap_critic_samples_per_batch = NUM_CHEAP_CRITIC_SAMPLES_PER_BATCH, - critic_optimizer = Flux.Adam(CRITIC_LR), - external_critic_samples = shared_critic_samples, - adjust_hyperparameters = (iter, opt_state, n) -> begin - mult = _schedule_value(PENALTY_SCHEDULE, iter, last(PENALTY_SCHEDULE)[3]) - if mult != current_penalty_mult[] - current_penalty_mult[] = mult - ρ_half_scaled = prob.base_penalty_half * mult - penalty_vals = fill(ρ_half_scaled, T * nHyd) - for (p, _, _, _) in problem_pool - ExaModels.set_parameter!(p.core, p.p_penalty_half, penalty_vals) - end - @info "Penalty multiplier → $mult (ρ/2 = $(round(ρ_half_scaled; digits=2)))" - end - n_eval = _schedule_value(EVAL_SCHEDULE, iter, MAX_EVAL_SCENARIOS) - rollout_evaluation.active_scenarios = n_eval - realized_rollout_evaluation.active_scenarios = n_eval - return _schedule_value(NUM_TRAIN_SCHEDULE, iter, n) - end, - record_loss = (iter, m, loss, tag) -> begin - metrics = Dict{String, Any}(tag => loss, "batch" => iter) - isfinite(loss) && push!(epoch_losses, loss) - - if iter % EVAL_EVERY == 0 - rollout_evaluation(iter, m) - realized_rollout_evaluation(iter, m) - append!(shared_critic_samples, - critic_samples_from_evaluation( - rollout_evaluation; - objective_key = CRITIC_ROLLOUT_OBJECTIVE, - )) - metrics["metrics/rollout_objective_no_target_penalty"] = - rollout_evaluation.last_objective_no_target_penalty - metrics["metrics/rollout_objective_no_deficit"] = - rollout_evaluation.last_objective_no_target_penalty - metrics["metrics/rollout_target_violation_share"] = - rollout_evaluation.last_violation_share - metrics["metrics/rollout_realized_objective_no_target_penalty"] = - realized_rollout_evaluation.last_objective_no_target_penalty - metrics["metrics/rollout_realized_objective_no_deficit"] = - realized_rollout_evaluation.last_objective_no_target_penalty - metrics["metrics/rollout_realized_target_violation_share"] = - realized_rollout_evaluation.last_violation_share - metrics["metrics/rollout_n_ok"] = - realized_rollout_evaluation.last_n_ok - end - - if !isnan(current_penalty_mult[]) - metrics["metrics/target_penalty_multiplier"] = current_penalty_mult[] - end - metrics["metrics/num_train_per_batch"] = - _schedule_value(NUM_TRAIN_SCHEDULE, iter, 1) - metrics["metrics/active_eval_scenarios"] = - _schedule_value(EVAL_SCHEDULE, iter, MAX_EVAL_SCENARIOS) - - batch_in_epoch = (iter - 1) % NUM_BATCHES + 1 - if batch_in_epoch == NUM_BATCHES - epoch = (iter - 1) ÷ NUM_BATCHES + 1 - mean_loss = isempty(epoch_losses) ? NaN : mean(epoch_losses) - n_ok = length(epoch_losses) - empty!(epoch_losses) - Wandb.log(lg, Dict("metrics/epoch_objective" => mean_loss, "epoch" => epoch)) - @info "Epoch $epoch/$NUM_EPOCHS mean=$(round(mean_loss; digits=2)) ok=$n_ok/$NUM_BATCHES" - if isfinite(mean_loss) && mean_loss < best_obj - global best_obj = mean_loss - jldsave(MODEL_PATH; - model_state = Flux.state(cpu(m)), - critic_state = Flux.state(cpu(critic)), - critic_config = Dict( - "mode" => "control_variate", - "training_target" => "rollout", - "policy_state" => string(CRITIC_POLICY_STATE), - "rollout_objective" => string(CRITIC_ROLLOUT_OBJECTIVE), - "critic_cv_weight" => CRITIC_CV_WEIGHT, - "value_loss_weight" => CRITIC_VALUE_LOSS_WEIGHT, - "gradient_loss_weight" => CRITIC_GRADIENT_LOSS_WEIGHT, - "critic_rollout_samples_per_batch" => CRITIC_ROLLOUT_SAMPLES_PER_BATCH, - "num_cheap_critic_samples_per_batch" => NUM_CHEAP_CRITIC_SAMPLES_PER_BATCH, - ), - ) - @info " → New best: $(round(mean_loss; digits=4)) — saved $MODEL_PATH" - end - end - Wandb.log(lg, metrics) - return false - end, -) - -close(lg) -@info "Done. Best model saved to: $(MODEL_PATH)" diff --git a/src/DecisionRulesExa.jl b/src/DecisionRulesExa.jl index 4e23112..5c6c17a 100644 --- a/src/DecisionRulesExa.jl +++ b/src/DecisionRulesExa.jl @@ -1,7 +1,39 @@ +""" + DecisionRulesExa + +GPU-accelerated companion to DecisionRules.jl for Two-Stage Deep Decision Rules +(TS-DDR) training with ExaModels and MadNLP. + +DecisionRulesExa implements the same target-projection workflow as +DecisionRules.jl: + +1. a policy predicts target states, +2. an NLP projects those targets onto the feasible set, and +3. target-constraint multipliers provide the policy-gradient signal. + +The package formulates inner optimization problems as `ExaModels.ExaModel` +instances solved by MadNLP, enabling GPU-native solves and warm-started repeated +training solves. + +# Main Types +- [`DeterministicEquivalentProblem`](@ref): deterministic equivalent with + explicit target parameters. +- [`EmbeddedDeterministicEquivalentProblem`](@ref): deterministic equivalent + whose target policy is embedded with `VectorNonlinearOracle`. +- [`StateConditionedPolicy`](@ref): recurrent policy for sequential target + rollout. +- [`MLPPolicy`](@ref): stateless policy for full-horizon target prediction. + +# Main Training APIs +- [`train_tsddr`](@ref): open-loop target-parameter training. +- [`train_tsddr_embedded`](@ref): embedded-policy training. +- [`rollout_tsddr`](@ref): stage-wise deployment-style evaluation. +""" module DecisionRulesExa using ExaModels using MadNLP +using CUDA using NLPModels using LinearAlgebra using Random @@ -12,6 +44,7 @@ using ChainRulesCore include("utils.jl") include("deterministic_equivalent.jl") +include("embedded_deterministic_equivalent.jl") include("policy.jl") include("critic_control_variate.jl") include("training.jl") @@ -39,9 +72,23 @@ export # Policies MLPPolicy, StateConditionedPolicy, + ContextualPolicy, + context_at, + stage_phase_context, + vcat_contexts, + ConstantStatePolicy, + FixedOutputPolicy, + bounded_state_policy, + load_stateconditioned_policy!, + + # Embedded-NN deterministic equivalent + EmbeddedDeterministicEquivalentProblem, + build_embedded_deterministic_equivalent, + invalidate_policy_cache!, # Training solve_succeeded, + prepare_solve!, materialize_tangent, _all_finite_gradient, AbstractCriticControlVariate, @@ -60,6 +107,7 @@ export critic_samples_from_evaluation, simulate_tsddr, train_tsddr, + train_tsddr_embedded, # Stage-wise rollout evaluation rollout_tsddr, diff --git a/src/critic_control_variate.jl b/src/critic_control_variate.jl index a1953d0..0341984 100644 --- a/src/critic_control_variate.jl +++ b/src/critic_control_variate.jl @@ -9,32 +9,82 @@ abstract type AbstractCriticTrainingTarget end """ DeterministicEquivalentCriticTarget() -Train critic value targets from the full deterministic-equivalent objective. -This is useful for ablations and for pure DE control-variate experiments. +Select critic value targets from the full deterministic-equivalent training +objective. + +# Returns +- `DeterministicEquivalentCriticTarget`: a target selector for deterministic- + equivalent critic supervision. + +# Notes +Use this target for ablations or for control-variate experiments tied to the +training surrogate rather than to deployed rollout performance. """ struct DeterministicEquivalentCriticTarget <: AbstractCriticTrainingTarget end """ - RolloutCriticTarget(stage_problem; kwargs...) - -Train critic value targets from stage-wise rollout evaluation. This is the -preferred target when the critic is meant to guide convergence of the deployed -rollout objective rather than the deterministic-equivalent surrogate. - -Required keyword callbacks match `rollout_tsddr`: -- `set_stage_parameters!` -- `realized_state` - -By default `policy_state = :target`, matching the differentiable target -recurrence used by the actor. Set `policy_state = :realized` to train on -closed-loop realized-state rollout targets. - -By default `objective_value = :objective`, so critic value targets include the -same target-penalty contribution that appears in the dual actor signal. Set -`objective_value = :objective_no_target_penalty` to train on the rollout -objective with target-slack penalties removed. + RolloutCriticTarget( + stage_problem; + horizon::Int, + n_uncertainty::Int, + set_stage_parameters!::Function, + realized_state::Function, + objective_no_target_penalty::Function = (prob, result) -> result.objective, + madnlp_kwargs = NamedTuple(), + warmstart::Bool = true, + policy_state::Symbol = :target, + reuse_solver::Bool = false, + objective_value::Symbol = :objective, + state_bounds = nothing, + project_state = nothing, + retry_on_failure::Bool = true, + ) -> RolloutCriticTarget + +Select critic value targets from stage-wise rollout evaluation. + +# Arguments +- `stage_problem`: single-stage optimization problem template used by + [`rollout_tsddr`](@ref). + +# Keywords +- `horizon::Int`: number of rollout stages. +- `n_uncertainty::Int`: dimension of each per-stage uncertainty slice. +- `set_stage_parameters!::Function`: callback that writes state, + uncertainty, target, and stage index into `stage_problem`. +- `realized_state::Function`: callback that extracts the realized next state + from a solved stage. +- `objective_no_target_penalty::Function`: callback returning the stage + objective with target-tracking penalties removed. +- `madnlp_kwargs`: keyword arguments forwarded to the MadNLP solver wrapper. +- `warmstart::Bool`: whether rollout solves should warm-start from previous + stage information. +- `policy_state::Symbol`: `:target` trains against the differentiable target + recurrence; `:realized` trains against closed-loop realized states. +- `reuse_solver::Bool`: whether rollout evaluation may reuse one solver + object across stages. +- `objective_value::Symbol`: `:objective` uses the full rollout objective; + `:objective_no_target_penalty` removes target-slack penalties. +- `state_bounds`: optional `(lower, upper)` projection bounds for realized + states. +- `project_state`: optional custom projection callback for realized states. +- `retry_on_failure::Bool`: whether failed stage solves should be retried with + a cold-start solver. + +# Returns +- `RolloutCriticTarget`: a target selector carrying the rollout callbacks and + options. + +# Throws +- Throws an error if `policy_state` is not `:target` or `:realized`. +- Throws an error if `objective_value` is not `:objective` or + `:objective_no_target_penalty`. + +# Notes +This is the preferred target when the critic is meant to guide convergence of +the deployed rollout objective rather than the deterministic-equivalent +surrogate. """ -struct RolloutCriticTarget{S,R,O,M} <: AbstractCriticTrainingTarget +struct RolloutCriticTarget{S,R,O,M,B,P} <: AbstractCriticTrainingTarget stage_problem horizon::Int n_uncertainty::Int @@ -46,6 +96,9 @@ struct RolloutCriticTarget{S,R,O,M} <: AbstractCriticTrainingTarget policy_state::Symbol reuse_solver::Bool objective_value::Symbol + state_bounds::B + project_state::P + retry_on_failure::Bool end function RolloutCriticTarget( @@ -60,6 +113,9 @@ function RolloutCriticTarget( policy_state::Symbol = :target, reuse_solver::Bool = false, objective_value::Symbol = :objective, + state_bounds = nothing, + project_state = nothing, + retry_on_failure::Bool = true, ) policy_state in (:target, :realized) || error("policy_state must be :target or :realized") @@ -77,32 +133,66 @@ function RolloutCriticTarget( policy_state, reuse_solver, objective_value, + state_bounds, + project_state, + retry_on_failure, ) end """ NoCriticControlVariate() -Default no-op critic configuration. Passing this to `train_tsddr` recovers the -original dual-multiplier actor update. +Construct the no-op critic configuration. + +# Returns +- `NoCriticControlVariate`: a sentinel that disables critic/control-variate + terms. + +# Notes +Passing this value to `train_tsddr` recovers the original dual-multiplier actor +update. """ struct NoCriticControlVariate <: AbstractCriticControlVariate end """ - ScalarCriticControlVariate(critic; featurizer=default_critic_featurizer, - value_loss_weight=0.1, - gradient_loss_weight=1.0) - -Wrap a scalar Flux-compatible critic `C(w, xhat)` for optional TS-DDR -control-variate training. The critic is called as `critic(features)`, where -`features = featurizer(initial_state, uncertainty, xhat)`. - -The critic loss is - - value_loss_weight * mse(C, objective) - + gradient_loss_weight * mse(gradient(xhat -> C, xhat), target_multipliers) - -Either loss weight may be zero. + ScalarCriticControlVariate( + critic; + featurizer = default_critic_featurizer, + value_loss_weight::Real = 0.1, + gradient_loss_weight::Real = 1.0, + ) -> ScalarCriticControlVariate + +Wrap a scalar Flux-compatible critic for optional TS-DDR control-variate +training. + +# Arguments +- `critic`: callable scalar model evaluated as `critic(features)`. + +# Keywords +- `featurizer`: callable + `featurizer(initial_state, uncertainty, xhat) -> features`. +- `value_loss_weight::Real`: nonnegative weight on objective-value matching. +- `gradient_loss_weight::Real`: nonnegative weight on target-gradient + matching. + +# Returns +- `ScalarCriticControlVariate`: critic configuration with loss weights stored + as `Float64`. + +# Throws +- Throws an error if either loss weight is negative. + +# Notes +For each [`CriticSample`](@ref), the critic loss is + +```math +w_v |C(f) - J|^2 ++ w_g \\frac{1}{n}\\|\\nabla_{\\hat{x}} C(f) - \\lambda_{\\hat{x}}\\|_2^2, +``` + +where `f = featurizer(initial_state, uncertainty, xhat)`, `J` is the scalar +objective target, and ``\\lambda_{\\hat{x}}`` is the target multiplier array. +Either weight may be zero. """ struct ScalarCriticControlVariate{C,F} <: AbstractCriticControlVariate critic::C @@ -128,11 +218,33 @@ function ScalarCriticControlVariate( end """ - CriticSample(initial_state, uncertainty, xhat, objective_value, - target_multipliers; metadata=nothing) + CriticSample( + initial_state, + uncertainty, + xhat, + objective_value::Real, + target_multipliers; + metadata = nothing, + ) -> CriticSample + +Store one already-solved TS-DDR scenario as scalar-critic supervision. + +# Arguments +- `initial_state`: initial state used for the scenario. +- `uncertainty`: scenario uncertainty trajectory. +- `xhat`: policy target trajectory. +- `objective_value::Real`: scalar value target for the critic. +- `target_multipliers`: multiplier-like target with the same shape as `xhat`. + +# Keywords +- `metadata`: optional payload retained with the sample. + +# Returns +- `CriticSample`: sample with `objective_value` converted to `Float64`. -Training sample for a scalar critic. Samples are produced from already-solved -TS-DDR scenarios and do not require additional optimization solves. +# Notes +Creating a `CriticSample` does not run any optimization solve; samples are +intended to be built from existing training or rollout results. """ struct CriticSample{I,W,X,L,M} initial_state::I @@ -161,6 +273,21 @@ function CriticSample( ) end +""" + CriticReplayBuffer(max_size::Integer) -> CriticReplayBuffer + +Construct a fixed-capacity FIFO replay buffer for [`CriticSample`](@ref)s. + +# Arguments +- `max_size::Integer`: maximum number of samples retained; negative values are + clamped to zero. + +# Returns +- `CriticReplayBuffer`: empty replay buffer with capacity `max(0, max_size)`. + +# Notes +A capacity of zero disables buffering, so push operations become no-ops. +""" mutable struct CriticReplayBuffer{S} samples::Vector{S} max_size::Int @@ -169,6 +296,22 @@ end CriticReplayBuffer(max_size::Integer) = CriticReplayBuffer{Any}(Any[], max(0, Int(max_size))) +""" + push_critic_sample!(buffer, sample) -> buffer + +Append one [`CriticSample`](@ref) to the buffer, evicting the oldest sample if +the buffer is at capacity. + +# Arguments +- `buffer::CriticReplayBuffer`: replay buffer to mutate. +- `sample::CriticSample`: sample to append. + +# Returns +- `buffer`: the same buffer object, after optional insertion and eviction. + +# Notes +If `buffer.max_size == 0`, the function returns without storing `sample`. +""" function push_critic_sample!(buffer::CriticReplayBuffer, sample::CriticSample) buffer.max_size == 0 && return buffer push!(buffer.samples, sample) @@ -177,6 +320,18 @@ function push_critic_sample!(buffer::CriticReplayBuffer, sample::CriticSample) return buffer end +""" + push_critic_samples!(buffer, samples) -> buffer + +Append multiple [`CriticSample`](@ref)s to the buffer in order. + +# Arguments +- `buffer::CriticReplayBuffer`: replay buffer to mutate. +- `samples`: iterable of [`CriticSample`](@ref) values. + +# Returns +- `buffer`: the same buffer after appending the supplied samples. +""" function push_critic_samples!(buffer::CriticReplayBuffer, samples) for sample in samples push_critic_sample!(buffer, sample) @@ -185,10 +340,17 @@ function push_critic_samples!(buffer::CriticReplayBuffer, samples) end """ - default_critic_featurizer(initial_state, uncertainty, xhat) + default_critic_featurizer(initial_state, uncertainty, xhat) -> AbstractVector + +Concatenate flattened critic inputs into one feature vector. + +# Arguments +- `initial_state`: initial state for the scenario. +- `uncertainty`: uncertainty trajectory for the scenario. +- `xhat`: policy target trajectory for the scenario. -Default critic featurizer: concatenate flattened initial state, uncertainty, and -policy target trajectory. +# Returns +- `AbstractVector`: `vcat(vec(initial_state), vec(uncertainty), vec(xhat))`. """ default_critic_featurizer(initial_state, uncertainty, xhat) = vcat(vec(initial_state), vec(uncertainty), vec(xhat)) @@ -205,9 +367,21 @@ function _critic_value(critic, featurizer, initial_state, uncertainty, xhat) end """ - critic_value(control_variate, initial_state, uncertainty, xhat) + critic_value(control_variate, initial_state, uncertainty, xhat) -> Number Evaluate the scalar critic on one scenario. + +# Arguments +- `control_variate::ScalarCriticControlVariate`: critic configuration. +- `initial_state`: initial state for the scenario. +- `uncertainty`: uncertainty trajectory for the scenario. +- `xhat`: policy target trajectory for the scenario. + +# Returns +- `Number`: scalar critic prediction. + +# Throws +- Throws an error if the critic returns a non-scalar array. """ critic_value( cv::ScalarCriticControlVariate, @@ -219,8 +393,23 @@ critic_value( """ critic_xhat_gradient(control_variate, initial_state, uncertainty, xhat) -Return `gradient(xhat -> C(initial_state, uncertainty, xhat), xhat)` and check -that it has the same shape as `xhat`. +Differentiate the scalar critic with respect to the policy target trajectory. + +# Arguments +- `control_variate::ScalarCriticControlVariate`: critic configuration. +- `initial_state`: initial state for the scenario. +- `uncertainty`: uncertainty trajectory for the scenario. +- `xhat`: policy target trajectory for the scenario. + +# Returns +- An array with the same shape as `xhat`, equal to + `gradient(x -> critic_value(control_variate, initial_state, uncertainty, x), xhat)`. + +# Throws +- Throws an error if the critic gradient shape differs from `xhat`. + +# Notes +If Zygote reports `nothing`, the gradient is replaced by `zero(xhat)`. """ function critic_xhat_gradient( cv::ScalarCriticControlVariate, @@ -285,9 +474,32 @@ function _critic_loss_with( end """ - critic_loss(control_variate, samples; value_loss_weight, gradient_loss_weight) + critic_loss( + control_variate, + samples; + value_loss_weight = control_variate.value_loss_weight, + gradient_loss_weight = control_variate.gradient_loss_weight, + ) -> Real Compute the scalar critic loss on a collection of `CriticSample`s. + +# Arguments +- `control_variate::ScalarCriticControlVariate`: critic configuration. +- `samples`: collection of [`CriticSample`](@ref) values. + +# Keywords +- `value_loss_weight`: nonnegative override for objective-value loss weight. +- `gradient_loss_weight`: nonnegative override for target-gradient loss + weight. + +# Returns +- `Real`: average critic loss over `samples`, or `0.0` for an empty + collection. + +# Throws +- Throws an error if either loss weight is negative. +- Throws an error if a sample's target multipliers or critic gradient do not + match the shape of `xhat`. """ critic_loss(cv::ScalarCriticControlVariate, samples; kwargs...) = _critic_loss_with(cv.critic, cv, samples; kwargs...) @@ -303,10 +515,32 @@ function _critic_minibatch(samples, batch_size) end """ - update_critic!(opt_state, control_variate, samples; batch_size=nothing) - -Run one critic optimizer step and return the numeric loss. Only critic -parameters are updated. + update_critic!( + opt_state, + control_variate, + samples; + batch_size = nothing, + ) -> Float64 + +Run one optimizer step for the scalar critic. + +# Arguments +- `opt_state`: Flux optimizer state for `control_variate.critic`. +- `control_variate::ScalarCriticControlVariate`: critic configuration. +- `samples`: replay samples available for training. + +# Keywords +- `batch_size`: optional minibatch size; `nothing` or a value greater than the + sample count uses all samples. + +# Returns +- `Float64`: critic loss on the selected batch, or `NaN` when the selected + batch is empty. + +# Notes +Only critic parameters are updated. If the materialized gradient is `nothing` +or contains non-finite values, the optimizer update is skipped while the loss +is still reported. """ function update_critic!( opt_state, diff --git a/src/deterministic_equivalent.jl b/src/deterministic_equivalent.jl index bf672b5..6c422da 100644 --- a/src/deterministic_equivalent.jl +++ b/src/deterministic_equivalent.jl @@ -9,15 +9,32 @@ """ DeterministicEquivalentProblem -Holds an ExaModels parametric NLP for the deterministic equivalent subproblem +Container for an ExaModels parametric NLP representing a deterministic +equivalent subproblem. - Q(w, x̂) = min_{x,u,δ} Σ_t stage_cost(t, x_t, u_t, w_t) + (ρ/2)‖δ‖² - s.t. x₁ = x₀ - dynamics(t, x_t, u_t, w_t, x_{t+1}) = 0 - x̂_t - x_t - δ_t = 0 (target constraints, **added last**) +# Fields -We add the target constraints last so their multipliers are a contiguous slice of -`result.multipliers`. +- `core`: ExaModels core used to build variables, parameters, objectives, and + constraints. +- `model`: ExaModels model passed to MadNLP. +- `x`, `u`, `δ`: Flat state, control, and target-slack variables. +- `p_x0`, `p_w`, `p_target`: Initial-state, uncertainty, and target parameters. +- `nx`, `nu`, `nw`, `horizon`: State, control, uncertainty, and time dimensions. +- `target_con_range`: Range of target-constraint multipliers in solver results. + +# Notes + +The subproblem has the form + +```math +Q(w, \\hat{x}) = + \\min_{x,u,\\delta} + \\sum_t c_t(x_t, u_t, w_t) + \\frac{\\rho}{2}\\|\\delta\\|^2 +``` + +subject to the initial condition, dynamics constraints, and target constraints +``\\hat{x}_t - x_t - \\delta_t = 0``. The target constraints are added last so +their multipliers occupy the contiguous slice `target_con_range`. """ struct DeterministicEquivalentProblem core @@ -42,8 +59,17 @@ end """ MadNLPCache -Optional cache to re-use a MadNLP solver instance across repeated solves -(warm-start + reusing symbolic factorizations). +Cache for reusing a MadNLP solver across repeated solves. + +# Fields + +- `solver`: Cached `MadNLP.MadNLPSolver`. +- `last_result`: Most recent solver result, used for optional warm starts. + +# Notes + +Reusing the solver can avoid repeated symbolic setup and can warm-start the +next primal iterate from the previous solution. """ mutable struct MadNLPCache solver @@ -53,27 +79,45 @@ end """ build_deterministic_equivalent(; kwargs...) -> DeterministicEquivalentProblem -Generic builder for a deterministic-equivalent dynamic NLP. - -Keyword arguments: -- `horizon::Int` : number of stages T (states are 1..T, controls are 1..T-1) -- `nx::Int` : state dimension -- `nu::Int` : control dimension (demo assumes `nu == nx` for default dynamics) -- `nw::Int` : disturbance dimension (default: `nx`) -- `backend` : ExaModels backend (e.g., `nothing` for CPU, `CUDABackend()` for GPU) -- `float_type` : numeric type (Float64 recommended for MadNLP) -- `x_bounds` : `(lb, ub)` applied to all state variables -- `u_bounds` : `(lb, ub)` applied to all control variables -- `slack_penalty` : ρ ≥ 0, weight for (ρ/2)‖δ‖² - -- `dynamics_eq` : function `(t, i, x, u, w, nx, nu, nw) -> expr == 0` - returns the scalar equality residual for dimension `i` at stage `t`. -- `stage_cost` : function `(t, i, x, u, w, nx, nu, nw) -> expr` returns a scalar term. - -Notes: -- All variables are stored in flat vectors to keep the interface simple and robust. -- Target constraints are added *last* and written as `x̂ - x - δ = 0` so that their - multipliers are directly the gradient w.r.t. `x̂` (envelope theorem). +Build a deterministic-equivalent dynamic nonlinear program. + +# Keywords + +- `horizon::Int`: Number of stages. States are indexed over `1:horizon`; + controls and uncertainties over `1:(horizon - 1)`. +- `nx::Int`: State dimension. +- `nu::Int = nx`: Control dimension. +- `nw::Int = nx`: Uncertainty dimension. +- `backend = nothing`: ExaModels backend, such as `nothing` for CPU or a CUDA + backend for GPU execution. +- `float_type::Type{<:AbstractFloat} = Float64`: Scalar type used by the model. +- `x_bounds::Tuple{<:Real,<:Real} = (-Inf, Inf)`: Lower and upper bounds applied + to every state variable. +- `u_bounds = (-Inf, Inf)`: Control bounds, either a scalar `(lb, ub)` tuple or + a tuple of length-`nu` lower and upper bound vectors. +- `slack_penalty::Real = 1.0`: Nonnegative target-slack penalty weight ``ρ``. +- `dynamics_eq::Function = default_dynamics_eq`: Function + `(t, i, x, u, w, nx, nu, nw) -> residual` defining one scalar dynamics + equality. +- `stage_cost::Function = default_stage_cost`: Function + `(t, i, x, u, w, nx, nu, nw) -> term` defining one scalar objective term. + +# Returns + +- `DeterministicEquivalentProblem`: A mutable problem container with parameters + that can be updated by `set_x0!`, `set_uncertainty!`, and `set_targets!`. + +# Throws + +Throws an error if dimensions are invalid, if vector control bounds have the +wrong length, or if the default dynamics/cost are used with dimensions other +than `nu == nx` and `nw == nx`. + +# Notes + +All variables are stored in flat vectors. Target constraints are added last and +written as ``\\hat{x} - x - \\delta = 0`` so the envelope theorem identifies their +multipliers with gradients with respect to the target trajectory. """ function build_deterministic_equivalent(; horizon::Int, @@ -180,11 +224,28 @@ end """ build_linear_tracking_problem(; kwargs...) -Convenience wrapper that builds a *simple* deterministic equivalent problem with: -- dynamics: x_{t+1} = x_t + u_t + w_t -- stage cost: (1/2) x_t^2 + (1/2) u_t^2 +Build the default linear-quadratic tracking demonstration problem. + +# Keywords + +- `horizon::Int`: Number of stages. +- `nx::Int = 1`: State, control, and uncertainty dimension. +- `backend = nothing`: ExaModels backend. +- `float_type::Type{<:AbstractFloat} = Float64`: Scalar type used by the model. +- `x_bounds::Tuple{<:Real,<:Real} = (-Inf, Inf)`: State bounds. +- `u_bounds::Tuple{<:Real,<:Real} = (-1.0, 1.0)`: Control bounds. +- `slack_penalty::Real = 10.0`: Target-slack penalty weight. -This is meant as an end-to-end demo and a template for your real model. +# Returns + +- `DeterministicEquivalentProblem`: Problem with dynamics + ``x_{t+1} = x_t + u_t + w_t`` and stage cost + ``(x_t^2 + u_t^2) / 2``. + +# Notes + +This helper is intended as a small end-to-end example and as a template for +model-specific deterministic-equivalent builders. """ function build_linear_tracking_problem(; horizon::Int, @@ -215,11 +276,28 @@ end # -------------------------- """ -Default per-dimension dynamics residual for the demo: + default_dynamics_eq(t, i, x, u, w, nx::Int, nu::Int, nw::Int) + +Return the default scalar dynamics residual. + +# Arguments - x_{t+1,i} - x_{t,i} - u_{t,i} - w_{t,i} == 0 +- `t`: Stage index. +- `i`: State component index. +- `x`: Flat state variable vector. +- `u`: Flat control variable vector. +- `w`: Flat uncertainty parameter vector. +- `nx::Int`: State dimension. +- `nu::Int`: Control dimension. +- `nw::Int`: Uncertainty dimension. -Assumes `nu == nx` and `nw == nx`. +# Returns + +- Scalar residual ``x_{t+1,i} - x_{t,i} - u_{t,i} - w_{t,i}``. + +# Notes + +The default residual assumes `nu == nx` and `nw == nx`. """ function default_dynamics_eq(t, i, x, u, w, nx::Int, nu::Int, nw::Int) return x[x_index(nx, t + 1, i)] - @@ -229,9 +307,24 @@ function default_dynamics_eq(t, i, x, u, w, nx::Int, nu::Int, nw::Int) end """ -Default per-dimension stage cost term for the demo: + default_stage_cost(t, i, x, u, w, nx::Int, nu::Int, nw::Int) + +Return the default scalar stage-cost term. - (1/2) x_{t,i}^2 + (1/2) u_{t,i}^2 +# Arguments + +- `t`: Stage index. +- `i`: State/control component index. +- `x`: Flat state variable vector. +- `u`: Flat control variable vector. +- `w`: Flat uncertainty parameter vector. +- `nx::Int`: State dimension. +- `nu::Int`: Control dimension. +- `nw::Int`: Uncertainty dimension. + +# Returns + +- Scalar cost ``(x_{t,i}^2 + u_{t,i}^2) / 2``. """ function default_stage_cost(t, i, x, u, w, nx::Int, nu::Int, nw::Int) return (x[x_index(nx, t, i)]^2 + u[u_index(nu, t, i)]^2) / 2 @@ -242,9 +335,22 @@ end # -------------------------- """ - set_x0!(prob, x0) + set_x0!(prob::DeterministicEquivalentProblem, x0::AbstractVector) + +Update the initial-state parameter. + +# Arguments -Update initial state parameter (length nx). +- `prob::DeterministicEquivalentProblem`: Problem to update. +- `x0::AbstractVector`: Initial state with length `prob.nx`. + +# Returns + +- `prob`: The updated problem. + +# Throws + +Throws an error if `length(x0) != prob.nx`. """ function set_x0!(prob::DeterministicEquivalentProblem, x0::AbstractVector) length(x0) == prob.nx || error("x0 length must be nx=$(prob.nx), got $(length(x0))") @@ -253,12 +359,29 @@ function set_x0!(prob::DeterministicEquivalentProblem, x0::AbstractVector) end """ - set_uncertainty!(prob, w) + set_uncertainty!(prob::DeterministicEquivalentProblem, w::AbstractVector) + +Update the disturbance-trajectory parameter. -Update disturbance trajectory parameter. -`w` must have length `(T-1)*nw` or `T*nw`; in the latter case the first `(T-1)*nw` -elements are used (the last stage's uncertainty only enters the policy rollout, not -the NLP dynamics). +# Arguments + +- `prob::DeterministicEquivalentProblem`: Problem to update. +- `w::AbstractVector`: Disturbance trajectory with length `(T - 1) * nw` or + `T * nw`. + +# Returns + +- `prob`: The updated problem. + +# Throws + +Throws an error if `w` has any length other than `(T - 1) * nw` or `T * nw`. + +# Notes + +When `w` has length `T * nw`, only the first `(T - 1) * nw` entries are used in +the NLP dynamics. The final-stage uncertainty may be needed by a policy rollout +but does not enter these dynamics constraints. """ function set_uncertainty!(prob::DeterministicEquivalentProblem, w::AbstractVector) expected = (prob.horizon - 1) * prob.nw @@ -274,9 +397,22 @@ function set_uncertainty!(prob::DeterministicEquivalentProblem, w::AbstractVecto end """ - set_targets!(prob, xhat) + set_targets!(prob::DeterministicEquivalentProblem, xhat::AbstractVector) + +Update the target-trajectory parameter. + +# Arguments -Update target trajectory parameter (length T*nx). +- `prob::DeterministicEquivalentProblem`: Problem to update. +- `xhat::AbstractVector`: Target trajectory with length `prob.horizon * prob.nx`. + +# Returns + +- `prob`: The updated problem. + +# Throws + +Throws an error if `length(xhat) != prob.horizon * prob.nx`. """ function set_targets!(prob::DeterministicEquivalentProblem, xhat::AbstractVector) expected = prob.horizon * prob.nx @@ -292,7 +428,20 @@ end """ init_madnlp_cache(prob; solver_kwargs...) -> MadNLPCache -Create and store a `MadNLP.MadNLPSolver` for repeated solves. +Create a cached MadNLP solver for repeated solves. + +# Arguments + +- `prob::DeterministicEquivalentProblem`: Problem whose ExaModel will be solved. + +# Keywords + +- `solver_kwargs...`: Keyword arguments forwarded to `MadNLP.MadNLPSolver`. + +# Returns + +- `MadNLPCache`: Cache containing the solver and an initially empty + `last_result`. """ function init_madnlp_cache(prob::DeterministicEquivalentProblem; solver_kwargs...) solver = MadNLP.MadNLPSolver(prob.model; solver_kwargs...) @@ -300,19 +449,62 @@ function init_madnlp_cache(prob::DeterministicEquivalentProblem; solver_kwargs.. end """ - solve!(prob; solver_kwargs...) -> result + solve!(prob::DeterministicEquivalentProblem; solver_kwargs...) -> result -Solve once by instantiating a fresh MadNLP solver (simplest, but allocates). +Solve a deterministic-equivalent problem with a fresh MadNLP solver. + +# Arguments + +- `prob::DeterministicEquivalentProblem`: Problem to solve. + +# Keywords + +- `solver_kwargs...`: Keyword arguments forwarded to `MadNLP.madnlp`. + +# Returns + +- `result`: MadNLP result object. + +# Notes + +This path is simple but allocates a new solver for every call. """ function solve!(prob::DeterministicEquivalentProblem; solver_kwargs...) return MadNLP.madnlp(prob.model; solver_kwargs...) end """ - solve!(prob, cache; warmstart=true, solver_kwargs...) -> result + solve!(prob::DeterministicEquivalentProblem, cache::MadNLPCache; warmstart=true, solver_kwargs...) -> result + +Solve a deterministic-equivalent problem with a cached MadNLP solver. -Solve using a cached solver instance. Optionally warm-start the primal -variables from the previous solution. +# Arguments + +- `prob::DeterministicEquivalentProblem`: Problem to solve. +- `cache::MadNLPCache`: Cached solver and previous result. + +# Keywords + +- `warmstart::Bool = true`: Whether to copy the previous primal solution into + the model initial point before solving. +- `solver_kwargs...`: Keyword arguments forwarded to `MadNLP.solve!`. + +# Returns + +- `result`: MadNLP result object, also stored in `cache.last_result`. + +# Notes + +Warm starts are used only when `warmstart` is true and `cache.last_result` is +available. + +MadNLP's iteration counter `cnt.k` is cumulative across `solve!` calls on the +same solver instance and is never reset by MadNLP itself. Without resetting it +(together with `cnt.acceptable_cnt` and `cnt.start_time`), repeated solves on a +cached solver eventually exhaust `max_iter` spuriously — the counters are reset +here before each solve so every call gets its intended per-solve iteration and +wall-clock budget. This mirrors the reset in `_solve!` (training.jl) and does +not change any numerics of an individual solve. """ function solve!(prob::DeterministicEquivalentProblem, cache::MadNLPCache; warmstart::Bool = true, @@ -322,6 +514,10 @@ function solve!(prob::DeterministicEquivalentProblem, cache::MadNLPCache; # Warm-start primal from previous solution copyto!(NLPModels.get_x0(prob.model), cache.last_result.solution) end + # Reset per-solve iteration budget (cnt.k is cumulative in MadNLP). + cache.solver.cnt.k = 0 # reset iteration counter + cache.solver.cnt.acceptable_cnt = 0 # reset acceptable-step counter + cache.solver.cnt.start_time = time() # reset wall-clock timer res = MadNLP.solve!(cache.solver; solver_kwargs...) cache.last_result = res return res @@ -332,17 +528,43 @@ end # -------------------------- """ - target_multipliers(prob, result) -> λ + target_multipliers(prob::DeterministicEquivalentProblem, result) -> λ + +Return the dual multipliers associated with target constraints. -Return the dual multipliers associated with the target constraints (∇_{x̂} Q). +# Arguments + +- `prob::DeterministicEquivalentProblem`: Problem that defines the multiplier + slice. +- `result`: MadNLP result containing `multipliers`. + +# Returns + +- `λ`: Multipliers in `result.multipliers[prob.target_con_range]`. + +# Notes + +With target constraints written as ``\\hat{x} - x - \\delta = 0``, these +multipliers are the envelope-theorem derivatives with respect to the target +trajectory. """ target_multipliers(prob::DeterministicEquivalentProblem, result) = result.multipliers[prob.target_con_range] """ - solution_components(prob, result) -> (x, u, δ) + solution_components(prob::DeterministicEquivalentProblem, result) -> (x, u, δ) Split the flat solution vector into state, control, and slack components. + +# Arguments + +- `prob::DeterministicEquivalentProblem`: Problem that defines component sizes. +- `result`: MadNLP result containing `solution`. + +# Returns + +- `(x, u, δ)`: Flat slices of the primal solution for states, controls, and + target slacks. """ function solution_components(prob::DeterministicEquivalentProblem, result) n_x = prob.horizon * prob.nx diff --git a/src/embedded_deterministic_equivalent.jl b/src/embedded_deterministic_equivalent.jl new file mode 100644 index 0000000..4975955 --- /dev/null +++ b/src/embedded_deterministic_equivalent.jl @@ -0,0 +1,580 @@ +# embedded_deterministic_equivalent.jl +# +# Embedded-NN deterministic equivalent: the policy π_θ is inside the NLP via +# VectorNonlinearOracle. At convergence the duals λ_t are closed-loop (joint +# NLP) and the gradient ∇_θ Q = Σ_t λ_t · ∇_θ π_θ(w_t, x*_{t-1}) follows +# from the envelope theorem — structurally identical to the open-loop formula +# but with realized states from the coupled solve. +# +# The oracle constraint is: +# π_θ(w_t, x_{t-1}) − x_t − δ_t = 0 ∀t = 1…T +# +# One oracle for all T stages guarantees sequential LSTM evaluation with +# Flux.reset! at the top of each callback invocation. Flux.reset! on the +# threaded policies is a REAL reset (it restores Flux.initialstates), and each +# stage's policy forward advances the recurrent state exactly once, so within +# every callback the policy sees the stage sequence t = 1…T from a fresh +# initial state. Audit of per-stage advancement: oracle_f! calls the policy +# once per stage; oracle_jac!/oracle_vjp! call it inside Zygote.pullback for +# t > 1 (the pullback CONSTRUCTION runs the forward exactly once; calling the +# returned back(·) does not re-run it) and as a bare call for t = 1 — one +# forward, hence one state advance, per stage in all three callbacks. +# +# Jacobian exactness caveat: the oracle callbacks (oracle_jac!, oracle_vjp!) +# compute only the DIRECT partial ∂π_t/∂x_{t-1} via a per-stage Zygote pullback. +# For a recurrent policy whose recurrent layers see x_{t-1}, stage t's output +# also depends on x_{1..t-2} through the hidden state; those cross-stage entries +# are absent from both the sparsity pattern and the pullbacks, so the oracle +# Jacobian is exact for feedforward (stateless-in-x) policies and a structural +# approximation for such recurrent ones. When the recurrent encoder reads only +# the uncertainty w_t (as in StateConditionedPolicy and HydroReachablePolicy, +# where the combiner over [h_t; x_{t-1}] is feedforward in x), the hidden state +# does not depend on x and the direct partial IS the full derivative. This +# exactness claim SURVIVES recurrent-state threading: with the encoder reading +# only w_t, the threaded hidden state depends only on the inflow history +# w_{1..t}, never on x, so threading changes the VALUE of h_t but adds no +# ∂h_t/∂x dependence — ∂π_t/∂x_{t-1} remains the full derivative. + +""" + EmbeddedDeterministicEquivalentProblem + +Container for a deterministic-equivalent NLP whose target constraints are +computed by an embedded Flux policy. + +# Fields + +- `core`: ExaModels core used to build variables, parameters, objectives, and + constraints. +- `model`: ExaModels model passed to MadNLP. +- `x`, `u`, `δ`: Flat state, control, and target-slack variables. +- `p_x0`, `p_w`: Initial-state and uncertainty parameters. +- `policy`: Flux policy evaluated by the nonlinear oracle. +- `nx`, `nu`, `nw`, `horizon`: State, control, uncertainty, and time dimensions. +- `target_con_range`: Range of oracle-constraint multipliers in solver results. +- `_w_buf`, `_x0_buf`: Mutable host buffers captured by oracle callbacks. + +# Notes + +This problem is analogous to `DeterministicEquivalentProblem`, but the explicit +target parameter is replaced by a `VectorNonlinearOracle` enforcing +``\\pi_\\theta(w_t, x_{t-1}) - x_t - \\delta_t = 0``. The oracle closures capture +`policy` by reference, so changing Flux parameters between solves changes the +NLP callbacks without rebuilding the ExaModel. +""" +struct EmbeddedDeterministicEquivalentProblem{P} + core + model + x + u + δ + p_x0 + p_w + policy::P + nx::Int + nu::Int + nw::Int + horizon::Int + target_con_range::UnitRange{Int} + # mutable buffers captured by oracle closures + _w_buf::Vector{Float64} + _x0_buf::Vector{Float64} +end + +""" + set_x0!(prob::EmbeddedDeterministicEquivalentProblem, x0::AbstractVector) + +Update the initial state used by the embedded problem and oracle callbacks. + +# Arguments + +- `prob::EmbeddedDeterministicEquivalentProblem`: Embedded problem to update. +- `x0::AbstractVector`: Initial state with length `prob.nx`. + +# Returns + +- `prob`: The updated problem. + +# Throws + +Throws an error if `length(x0) != prob.nx`. + +# Notes + +The value is written both to the ExaModels parameter and to the oracle closure +buffer, ensuring the policy callback sees the same initial state as the NLP. +""" +function set_x0!(prob::EmbeddedDeterministicEquivalentProblem, x0::AbstractVector) + length(x0) == prob.nx || error("x0 length must be nx=$(prob.nx), got $(length(x0))") + ExaModels.set_parameter!(prob.core, prob.p_x0, x0) + copyto!(prob._x0_buf, Float64.(x0)) + return prob +end + +""" + set_uncertainty!(prob::EmbeddedDeterministicEquivalentProblem, w::AbstractVector) + +Update the disturbance trajectory used by the embedded problem and oracle +callbacks. + +# Arguments + +- `prob::EmbeddedDeterministicEquivalentProblem`: Embedded problem to update. +- `w::AbstractVector`: Disturbance trajectory with length `(T - 1) * nw` or + `T * nw`. + +# Returns + +- `prob`: The updated problem. + +# Throws + +Throws an error if `w` has any length other than `(T - 1) * nw` or `T * nw`. + +# Notes + +The first `(T - 1) * nw` entries are passed to the ExaModels dynamics +parameter. The full length-`T * nw` trajectory is retained in the oracle buffer +when provided, because the policy callback may evaluate a final-stage +disturbance. +""" +function set_uncertainty!(prob::EmbeddedDeterministicEquivalentProblem, w::AbstractVector) + expected = (prob.horizon - 1) * prob.nw + full_len = prob.horizon * prob.nw + n = length(w) + if n == expected + ExaModels.set_parameter!(prob.core, prob.p_w, w) + copyto!(view(prob._w_buf, 1:expected), Float64.(w)) + elseif n == full_len + ExaModels.set_parameter!(prob.core, prob.p_w, view(w, 1:expected)) + copyto!(prob._w_buf, Float64.(w)) + else + error("w length must be (T-1)*nw=$expected or T*nw=$full_len, got $n") + end + return prob +end + +""" + set_targets!(::EmbeddedDeterministicEquivalentProblem, ::AbstractVector) -> nothing + +Ignore explicit targets for embedded deterministic-equivalent problems. + +# Arguments + +- `::EmbeddedDeterministicEquivalentProblem`: Embedded problem whose targets are + generated by the policy oracle. +- `::AbstractVector`: Ignored target vector. + +# Returns + +- `nothing`. + +# Notes + +Embedded problems compute targets inline through the nonlinear oracle instead of +storing them in an NLP parameter. +""" +function set_targets!(::EmbeddedDeterministicEquivalentProblem, ::AbstractVector) + return nothing +end + +""" + invalidate_policy_cache!(embedded_de) + +Invalidate policy-dependent caches for an embedded deterministic-equivalent +problem. + +# Arguments + +- `embedded_de`: Embedded deterministic-equivalent problem. + +# Returns + +- `embedded_de`. + +# Notes + +The generic embedded problem evaluates the policy directly in each oracle +callback and has no cache to invalidate. Specialized embedded problem types may +extend this hook when their oracle stores policy-dependent intermediates across +solver calls. +""" +function invalidate_policy_cache!(embedded_de) + return embedded_de +end + +""" + build_embedded_deterministic_equivalent(policy; kwargs...) + +Build a deterministic-equivalent NLP with a Flux policy embedded as a nonlinear +oracle. + +# Arguments + +- `policy`: Flux model mapping each stage input to an `nx`-vector target. + +# Keywords + +- `horizon::Int`: Number of stages. States are indexed over `1:horizon`; + controls and uncertainties over `1:(horizon - 1)`. +- `nx::Int`: State dimension and policy output dimension. +- `nu::Int = nx`: Control dimension. +- `nw::Int = nx`: Uncertainty dimension and first part of the policy input. +- `backend = nothing`: ExaModels backend, such as `nothing` for CPU or a CUDA + backend for GPU execution. +- `float_type::Type{<:AbstractFloat} = Float64`: Scalar type used by the model. +- `x_bounds::Tuple{<:Real,<:Real} = (-Inf, Inf)`: Lower and upper bounds applied + to every state variable. +- `u_bounds = (-Inf, Inf)`: Control bounds, either a scalar `(lb, ub)` tuple or + a tuple of length-`nu` lower and upper bound vectors. +- `slack_penalty::Real = 1.0`: Nonnegative target-slack penalty weight ``ρ``. +- `dynamics_eq::Function = default_dynamics_eq`: Function + `(t, i, x, u, w, nx, nu, nw) -> residual` defining one scalar dynamics + equality. +- `stage_cost::Function = default_stage_cost`: Function + `(t, i, x, u, w, nx, nu, nw) -> term` defining one scalar objective term. + +# Returns + +- `EmbeddedDeterministicEquivalentProblem`: Problem supporting `set_x0!`, + `set_uncertainty!`, `target_multipliers`, and `solution_components`. + +# Throws + +Throws an error if dimensions are invalid, if vector control bounds have the +wrong length, or if the default dynamics/cost are used with dimensions other +than `nu == nx` and `nw == nx`. + +# Notes + +The oracle enforces +``\\pi_\\theta(w_t, x_{t-1}) - x_t - \\delta_t = 0`` and is added last so its +multipliers form a contiguous trailing slice of `result.multipliers`. This +matches the open-loop deterministic-equivalent convention while allowing the +policy to depend on realized previous states. + +The oracle Jacobian and vector-Jacobian callbacks differentiate each stage +independently, providing only the direct partial ``\\partial \\pi_t / +\\partial x_{t-1}``. If the policy's recurrent layers consume ``x_{t-1}``, +stage ``t``'s output also depends on ``x_{1..t-2}`` through the hidden state, +and those cross-stage Jacobian entries are omitted — the reported Jacobian is +then a structural approximation. The Jacobian is exact whenever the recurrent +part of the policy reads only ``w_t`` and the state enters through a +feedforward head (the [`StateConditionedPolicy`](@ref) architecture), because +then the hidden state carries no dependence on ``x``. This holds unchanged +with recurrent-state threading: the threaded hidden state is a function of +``w_{1..t}`` only, so it changes the value of ``h_t`` but introduces no +``\\partial h_t / \\partial x`` term. + +Every callback resets the policy's recurrent state at its top and evaluates +the stages in order, advancing the state exactly once per stage (for +``t > 1`` the forward runs during `Zygote.pullback` construction; the +returned pullback does not re-run it). +""" +function build_embedded_deterministic_equivalent( + policy; + horizon::Int, + nx::Int, + nu::Int = nx, + nw::Int = nx, + backend = nothing, + float_type::Type{<:AbstractFloat} = Float64, + x_bounds::Tuple{<:Real,<:Real} = (-Inf, Inf), + u_bounds = (-Inf, Inf), + slack_penalty::Real = 1.0, + dynamics_eq::Function = default_dynamics_eq, + stage_cost::Function = default_stage_cost, +) + horizon ≥ 2 || error("horizon must be ≥ 2 (got $horizon)") + nx ≥ 1 || error("nx must be ≥ 1 (got $nx)") + nu ≥ 1 || error("nu must be ≥ 1 (got $nu)") + nw ≥ 1 || error("nw must be ≥ 1 (got $nw)") + + if (dynamics_eq === default_dynamics_eq || stage_cost === default_stage_cost) && (nu != nx || nw != nx) + error("Default dynamics/cost assume nu == nx and nw == nx.") + end + + T = horizon + n_x = T * nx + n_u = (T - 1) * nu + + core = ExaModels.ExaCore(float_type; backend = backend) + + function _u_bound(b, side) + v = b[side] + v isa AbstractVector || return float_type(v) + length(v) == nu || error("u_bounds[$side] length must be nu=$nu") + return float_type.(repeat(v, T - 1)) + end + lvar_u = _u_bound(u_bounds, 1) + uvar_u = _u_bound(u_bounds, 2) + + x = ExaModels.variable(core, n_x; + lvar = float_type(x_bounds[1]), + uvar = float_type(x_bounds[2]), + ) + u = ExaModels.variable(core, n_u; + lvar = lvar_u, + uvar = uvar_u, + ) + δ = ExaModels.variable(core, n_x) + + p_x0 = ExaModels.parameter(core, zeros(float_type, nx)) + p_w = ExaModels.parameter(core, zeros(float_type, (T - 1) * nw)) + + ExaModels.objective(core, + stage_cost(t, i, x, u, p_w, nx, nu, nw) + for t in 1:(T - 1), i in 1:nx + ) + ρ = float_type(slack_penalty) + ExaModels.objective(core, + (ρ / 2) * δ[x_index(nx, t, i)]^2 + for t in 1:T, i in 1:nx + ) + + ExaModels.constraint(core, + x[x_index(nx, 1, i)] - p_x0[i] + for i in 1:nx + ) + ExaModels.constraint(core, + dynamics_eq(t, i, x, u, p_w, nx, nu, nw) + for t in 1:(T - 1), i in 1:nx + ) + + n_con_before_oracle = nx + (T - 1) * nx + + # ── Oracle buffers (mutated by set_x0! / set_uncertainty!) ─────────── + w_buf = zeros(Float64, T * nw) + x0_buf = zeros(Float64, nx) + + nvar_total = n_x + n_u + n_x # x, u, δ + x_start = 1 + δ_start = n_x + n_u + 1 + + # ── Pre-allocated oracle buffers ──────────────────────────────────── + _x_prev = zeros(Float32, nx) + _w_t = zeros(Float32, nw) + _input = zeros(Float32, nw + nx) + _J = zeros(Float32, nx, nx) + _e = zeros(Float32, nx) + _λ_t = zeros(Float32, nx) + + function _fill_x_prev!(t, xv) + for i in 1:nx + _x_prev[i] = (t == 1) ? + Float32(x0_buf[i]) : + Float32(xv[x_start + (t-2)*nx + i - 1]) + end + return _x_prev + end + + function _fill_w_t!(t) + for j in 1:nw + _w_t[j] = Float32(w_buf[(t-1)*nw + j]) + end + return _w_t + end + + function _fill_input!(t, xv) + _fill_w_t!(t) + _fill_x_prev!(t, xv) + copyto!(view(_input, 1:nw), _w_t) + copyto!(view(_input, nw+1:nw+nx), _x_prev) + return _input + end + + # ── Oracle callbacks ───────────────────────────────────────────────── + + function oracle_f!(c, xv) + # Real reset: the stage loop below starts from the initial recurrent + # state and each policy call advances it exactly once. + Flux.reset!(policy) + for t in 1:T + _fill_input!(t, xv) + nn_out = policy(_input) + for i in 1:nx + row = (t - 1) * nx + i + xi = x_start + (t-1)*nx + i - 1 + di = δ_start + (t-1)*nx + i - 1 + c[row] = Float64(nn_out[i]) - xv[xi] - xv[di] + end + end + return nothing + end + + # NOTE: this Jacobian holds only the per-stage direct partial ∂π_t/∂x_{t-1}. + # Cross-stage terms through a recurrent hidden state that depends on x are + # not represented (see file-top comment); exact when the recurrent encoder + # reads only w_t, as in StateConditionedPolicy / HydroReachablePolicy. + function oracle_jac!(vals, xv) + # Real reset; each stage advances the recurrent state exactly once: + # for t > 1 the forward runs during Zygote.pullback construction, and + # calling back(·) repeatedly does NOT re-run it; t = 1 is a bare call. + Flux.reset!(policy) + k = 0 + for t in 1:T + _fill_x_prev!(t, xv) + _fill_w_t!(t) + + nn_jac_xprev = if t > 1 + _, back = Zygote.pullback(xp -> policy(vcat(_w_t, xp)), _x_prev) + fill!(_J, 0f0) + for row in 1:nx + fill!(_e, 0f0) + _e[row] = 1.0f0 + col_grad = back(_e)[1] + if col_grad !== nothing + _J[row, :] .= col_grad + end + end + _J + else + # t = 1: no x-Jacobian block, but the forward must still run + # once so the recurrent state advances to stage 2. + policy(vcat(_w_t, _x_prev)) + nothing + end + + for i in 1:nx + k += 1; vals[k] = -1.0 + k += 1; vals[k] = -1.0 + if t > 1 + for j in 1:nx + k += 1; vals[k] = Float64(nn_jac_xprev[i, j]) + end + end + end + end + return nothing + end + + function oracle_vjp!(Jtv, xv, λ) + fill!(Jtv, 0.0) + # Real reset; same one-advance-per-stage discipline as oracle_jac!. + Flux.reset!(policy) + for t in 1:T + _fill_x_prev!(t, xv) + _fill_w_t!(t) + + for i in 1:nx + _λ_t[i] = Float32(λ[(t-1)*nx + i]) + xi = x_start + (t-1)*nx + i - 1 + di = δ_start + (t-1)*nx + i - 1 + Jtv[xi] -= λ[(t-1)*nx + i] + Jtv[di] -= λ[(t-1)*nx + i] + end + + if t > 1 + _, back = Zygote.pullback(xp -> policy(vcat(_w_t, xp)), _x_prev) + dinput = back(_λ_t)[1] + if dinput !== nothing + for j in 1:nx + xj = x_start + (t-2)*nx + j - 1 + Jtv[xj] += Float64(dinput[j]) + end + end + else + # t = 1: no x_prev contribution, but run the forward once so + # the recurrent state advances to stage 2. + policy(vcat(_w_t, _x_prev)) + end + end + return nothing + end + + # ── Sparsity pattern ───────────────────────────────────────────────── + jac_r = Int[] + jac_c = Int[] + for t in 1:T + for i in 1:nx + row = (t - 1) * nx + i + xi = x_start + (t-1)*nx + i - 1 + di = δ_start + (t-1)*nx + i - 1 + push!(jac_r, row); push!(jac_c, xi) # ∂g/∂x_{t,i} + push!(jac_r, row); push!(jac_c, di) # ∂g/∂δ_{t,i} + if t > 1 + for j in 1:nx + xj = x_start + (t-2)*nx + j - 1 + push!(jac_r, row); push!(jac_c, xj) # ∂g/∂x_{t-1,j} + end + end + end + end + + oracle = ExaModels.VectorNonlinearOracle( + nvar = nvar_total, + ncon = n_x, + nnzj = length(jac_r), + jac_rows = jac_r, + jac_cols = jac_c, + lcon = zeros(n_x), + ucon = zeros(n_x), + f! = oracle_f!, + jac! = oracle_jac!, + vjp! = oracle_vjp!, + adapt = Val(true), + ) + ExaModels.constraint(core, oracle) + + model = ExaModels.ExaModel(core) + + target_start = n_con_before_oracle + 1 + target_range = target_start:(target_start + n_x - 1) + + return EmbeddedDeterministicEquivalentProblem( + core, model, x, u, δ, + p_x0, p_w, + policy, + nx, nu, nw, T, + target_range, + w_buf, x0_buf, + ) +end + +""" + target_multipliers(prob::EmbeddedDeterministicEquivalentProblem, result) -> λ + +Return the dual multipliers associated with the embedded oracle constraints. + +# Arguments + +- `prob::EmbeddedDeterministicEquivalentProblem`: Problem that defines the + multiplier slice. +- `result`: MadNLP result containing `multipliers`. + +# Returns + +- `λ`: Multipliers in `result.multipliers[prob.target_con_range]`. + +# Notes + +The multipliers correspond to the constraints +``\\pi_\\theta(w_t, x_{t-1}) - x_t - \\delta_t = 0``. +""" +target_multipliers(prob::EmbeddedDeterministicEquivalentProblem, result) = + result.multipliers[prob.target_con_range] + +""" + solution_components(prob::EmbeddedDeterministicEquivalentProblem, result) -> (x, u, δ) + +Split the flat solution vector into state, control, and slack components. + +# Arguments + +- `prob::EmbeddedDeterministicEquivalentProblem`: Problem that defines component + sizes. +- `result`: MadNLP result containing `solution`. + +# Returns + +- `(x, u, δ)`: Flat slices of the primal solution for states, controls, and + target slacks. +""" +function solution_components(prob::EmbeddedDeterministicEquivalentProblem, result) + n_x = prob.horizon * prob.nx + n_u = (prob.horizon - 1) * prob.nu + sol = result.solution + x_sol = sol[1:n_x] + u_sol = sol[(n_x + 1):(n_x + n_u)] + δ_sol = sol[(n_x + n_u + 1):(n_x + n_u + n_x)] + return (x_sol, u_sol, δ_sol) +end diff --git a/src/policy.jl b/src/policy.jl index 8a3a6e8..2ab2db0 100644 --- a/src/policy.jl +++ b/src/policy.jl @@ -11,8 +11,17 @@ """ MLPPolicy(model, output_dim) -Stateless MLP policy: one call with `vcat(x0, w_flat)` returns the full target -trajectory `x̂` as a flat vector of length `T*nx`. +Wrap a stateless Flux model as a full-horizon target policy. + +The wrapped model is called once per scenario with `vcat(x0, w_flat)` and +returns the full target trajectory as a flat vector of length `output_dim`. + +# Arguments +- `model`: Flux-compatible callable. +- `output_dim::Int`: number of target components retained from `vec(model(input))`. + +# Returns +- `MLPPolicy`: a Flux layer wrapper around `model`. """ struct MLPPolicy{M} model::M @@ -21,6 +30,17 @@ end Flux.@layer MLPPolicy +""" + (policy::MLPPolicy)(input) -> AbstractVector + +Evaluate a stateless full-horizon policy. + +# Arguments +- `input`: concatenated initial state and flat uncertainty trajectory. + +# Returns +- The first `policy.output_dim` entries of `vec(policy.model(input))`. +""" function (π::MLPPolicy)(input) y = π.model(input) return vec(y)[1:π.output_dim] @@ -28,6 +48,19 @@ end """ MLPPolicy(input_dim, output_dim; hidden=(64,64), act=tanh) + +Construct a feed-forward [`MLPPolicy`](@ref). + +# Arguments +- `input_dim::Int`: length of the concatenated scenario input. +- `output_dim::Int`: length of the flattened target trajectory. + +# Keywords +- `hidden`: hidden-layer widths. +- `act`: hidden-layer activation. + +# Returns +- `MLPPolicy`: stateless full-horizon policy. """ function MLPPolicy(input_dim::Int, output_dim::Int; hidden = (64, 64), @@ -43,50 +76,531 @@ function MLPPolicy(input_dim::Int, output_dim::Int; return MLPPolicy(Flux.Chain(layers...), output_dim) end -# ── StateConditionedPolicy ──────────────────────────────────────────────────── +# ── ContextualPolicy ────────────────────────────────────────────────────────── + +""" + ContextualPolicy(policy, context) + +Wrap a stage policy so each call receives known exogenous context before the +usual policy input. The wrapped policy is called as +`policy(vcat(context_at(context, t), input))`, with `t` advanced once per call +and reset by `Flux.reset!`. + +This keeps training and rollout loops unchanged: they still pass `[w_t; x_prev]` +to the policy, while the wrapper prepends known stage features such as seasonal +phase or forecast covariates. Only the inner policy is trainable. +""" +mutable struct ContextualPolicy{P,C} + policy::P + context::C + t::Int +end + +ContextualPolicy(policy, context) = ContextualPolicy(policy, context, 0) + +Flux.@layer ContextualPolicy trainable=(policy,) + +""" + context_at(context, t) +Return the context vector for one-based stage `t`. """ - StateConditionedPolicy{E,C} +function context_at(context::AbstractMatrix, t::Integer) + 1 <= t <= size(context, 2) || + throw(BoundsError(context, (:, t))) + return view(context, :, t) +end -Stateful LSTM policy for sequential rollout: +context_at(context::Function, t::Integer) = context(t) - x̂_t = policy(vcat(w_t, x̂_{t-1})) +function (m::ContextualPolicy)(input) + m.t += 1 + return m.policy(vcat(context_at(m.context, m.t), input)) +end -- `encoder`: LSTM chain operating on the uncertainty slice `w_t` -- `combiner`: Dense layer combining encoder output with previous state +function Flux.reset!(m::ContextualPolicy) + m.t = 0 + Flux.reset!(m.policy) + return nothing +end -Call `Flux.reset!(policy)` before each episode. +""" + stage_phase_context(T; period, include_progress=true) -# Flux 0.16 note -LSTM requires ≥2D input. The forward pass reshapes the 1D `w_t` slice to -`(n_uncertainty, 1)` before encoding and squeezes back with `vec`. +Build a `d x T` context matrix with `sin(2*pi*t/period)`, +`cos(2*pi*t/period)`, and optionally normalized horizon progress `t/T`. +The sine/cosine pair preserves cyclic adjacency between the last and first +seasonal positions while using only two bounded input features. """ -struct StateConditionedPolicy{E,C} - encoder::E - combiner::C - n_uncertainty::Int - n_state::Int +function stage_phase_context(T::Integer; period::Integer, include_progress::Bool=true) + T >= 1 || throw(ArgumentError("T must be positive")) + period >= 1 || throw(ArgumentError("period must be positive")) + nrows = include_progress ? 3 : 2 + ctx = Matrix{Float32}(undef, nrows, T) + for t in 1:T + θ = 2f0 * Float32(pi) * Float32(t) / Float32(period) + ctx[1, t] = sin(θ) + ctx[2, t] = cos(θ) + if include_progress + ctx[3, t] = Float32(t) / Float32(T) + end + end + return ctx +end + +""" + vcat_contexts(a, b, ...) + +Vertically concatenate context matrices after checking that they cover the +same number of stages. +""" +function vcat_contexts(contexts::AbstractMatrix...) + isempty(contexts) && return Matrix{Float32}(undef, 0, 0) + T = size(first(contexts), 2) + all(size(c, 2) == T for c in contexts) || + throw(ArgumentError("all contexts must have the same number of columns")) + return vcat(contexts...) +end + +raw""" + _dense_policy_head(input_dim, output_dim, hidden; activation=tanh) + +Build the nonrecurrent target head used by state-conditioned policies. + +The head maps the concatenated features `[encoded_uncertainty; previous_state]` +to the normalized or unbounded target vector. When `hidden` is empty, this is the +historical single `Dense(input_dim => output_dim, activation)` head. When +`hidden = [h₁, …, h_L]`, the returned chain is + +```math +f(z) = +\sigma\left(W_{L+1} + \sigma\left(W_L \cdots \sigma(W_1 z + b_1) \cdots + b_L\right) + + b_{L+1}\right). +``` + +The output layer intentionally uses the same `activation`. This is different +from a generic MLP helper with a linear output: bounded policies need the final +head output to stay in `[0, 1]` when `activation=sigmoid`, before affine scaling +to physical target bounds. + +# Arguments +- `input_dim::Int`: dimension of `[encoded_uncertainty; previous_state]`. +- `output_dim::Int`: number of target components produced by the policy. +- `hidden::AbstractVector{Int}`: hidden widths of the feed-forward target head. +- `activation`: activation applied at every head layer, including the output. + +# Returns +- `Flux.Dense` if `hidden` is empty, otherwise `Flux.Chain` of dense layers. + +# Examples +```julia +head = DecisionRulesExa._dense_policy_head(135, 11, [128, 128]; activation=sigmoid) +``` + +See also: [`StateConditionedPolicy`](@ref), [`bounded_state_policy`](@ref) +""" +function _dense_policy_head( + input_dim::Int, + output_dim::Int, + hidden::AbstractVector{Int}; + activation = tanh, +) + isempty(hidden) && return Flux.Dense(input_dim => output_dim, activation) + layers = Any[Flux.Dense(input_dim => hidden[1], activation)] + for i in 1:(length(hidden) - 1) + push!(layers, Flux.Dense(hidden[i] => hidden[i + 1], activation)) + end + push!(layers, Flux.Dense(hidden[end] => output_dim, activation)) + return Flux.Chain(layers...) +end + +# ── Recurrent-state threading helpers (Flux ≥ 0.16 stateless cells) ────────── +# +# In Flux 0.16 recurrent layers are stateless: `(l::LSTM)(x)` restarts from +# `Flux.initialstates(l)` on EVERY call and `Flux.reset!` on Flux layers is a +# deprecated no-op. A policy that needs cross-stage memory must therefore carry +# the recurrent state itself and advance it with one stateful cell call per +# stage. The helpers below mirror DecisionRules.jl's `_as_cell`, +# `_init_recurrent_state`, `_step_encoder`, and `_state_eltype` +# (src/dense_multilayer_nn.jl) so both packages thread recurrent encoders with +# identical semantics. Unlike DecisionRules.jl, which stores BARE cells, EXA +# encoders keep the `Flux.LSTM` wrapper layers (preserving the weight +# structure of existing checkpoints); `_as_cell` unwraps to the underlying +# cell for the stateful `(x, state) -> (output, new_state)` call. + +""" + _as_cell(layer) + +Return the underlying recurrent cell of `layer`. `Flux.LSTM`/`GRU`/`RNN` wrap a +cell (`LSTMCell`/`GRUCell`/`RNNCell`) in a `.cell` field; if `layer` has no such +field it is already a cell and is returned unchanged. +""" +# Unwrap the .cell field if present (LSTM → LSTMCell); return unchanged otherwise. +_as_cell(layer) = hasfield(typeof(layer), :cell) ? layer.cell : layer + +""" + _init_recurrent_state(encoder) + +Return the initial recurrent state for `encoder`: `Flux.initialstates` of the +underlying cell for a single layer, or a tuple of per-layer initial states for +a `Chain`. + +# Notes +`Flux.initialstates` builds zero states with `zeros_like` on the cell weights, +so the returned state inherits the encoder's device and element type — call +[`Flux.reset!`](@ref) after moving a policy between devices to re-derive the +state on the new device. +""" +# Single layer: initial state of the underlying cell (zeros for LSTM h/c). +_init_recurrent_state(layer) = Flux.initialstates(_as_cell(layer)) +# Chain: one initial state per layer, returned as a tuple. +_init_recurrent_state(chain::Flux.Chain) = map(_init_recurrent_state, chain.layers) + +""" + _step_encoder(encoder, x, state) -> (output, new_state) + +Advance `encoder` by one step on input `x` from recurrent `state`, returning +the output and the updated state. For a `Chain`, each layer's output feeds the +next layer and each layer's state is threaded independently. +""" +# Single layer: one stateful cell call returns (output, new_state). +_step_encoder(layer, x, state) = _as_cell(layer)(x, state) +function _step_encoder(chain::Flux.Chain, x, states::Tuple) + # Delegate to the recursive tuple-based implementation. + return _step_encoder_layers(chain.layers, x, states) +end + +""" + _step_encoder_layers(layers, x, states) -> (output, new_states) + +Recursively advance a tuple of recurrent layers by one time step. + +Each layer receives the output of the previous layer as input and its own +independent recurrent state. The base case (`layers == ()`) returns the input +unchanged with an empty state tuple. + +# Arguments +- `layers::Tuple`: remaining recurrent layers to evaluate. +- `x`: current input (or output of the prior layer). +- `states::Tuple`: per-layer recurrent states, same length as `layers`. + +# Returns +- `output`: output of the last layer in `layers`. +- `new_states::Tuple`: updated recurrent states, one per layer. +""" +_step_encoder_layers(::Tuple{}, x, ::Tuple{}) = x, () +function _step_encoder_layers(layers::Tuple, x, states::Tuple) + # Advance the first layer with its own recurrent state. + out, new_state = _step_encoder(first(layers), x, first(states)) + + # Recurse on remaining layers, feeding this layer's output as input. + rest_out, rest_states = _step_encoder_layers(Base.tail(layers), out, Base.tail(states)) + + # Reassemble the full state tuple: this layer's state followed by the rest. + return rest_out, (new_state, rest_states...) end -Flux.@layer StateConditionedPolicy +""" + _state_eltype(state) -> Type + +Return the scalar element type of a recurrent state. + +For nested tuple states (e.g. LSTM's `(h, c)` or a `Chain`'s tuple of per-layer +states) this recurses into the first element until it reaches an +`AbstractVector`, then returns `eltype(v)`. The result is used to cast inputs +to the encoder's precision before each step. +""" +_state_eltype(state::Tuple) = _state_eltype(first(state)) +_state_eltype(v::AbstractArray) = eltype(v) # AbstractArray (not just Vector) so batched matrix states work + +""" + StateConditionedPolicy{E,C,S} + +Flux-compatible state-conditioned policy for sequential target rollout. + +At each stage the policy is called as + +```julia +xhat_t = policy(vcat(w_t, x_prev)) +``` + +where the recurrent encoder reads only `w_t` and the combiner reads +`[encoded_uncertainty; x_prev]`. +Flux's recurrent cells are stateless (Flux ≥ 0.16): each call returns +`(output, new_state)` instead of mutating internal state, and calling the +`LSTM` wrapper directly would restart from `initialstates` on every call. +`StateConditionedPolicy` therefore carries the encoder's recurrent state itself +in `state`, threading it through one cell call per stage — the same semantics +as DecisionRules.jl's `StateConditionedPolicy`. Call `Flux.reset!(policy)` to +restore it to `Flux.initialstates` at the start of a scenario. + +# Fields +- `encoder`: recurrent uncertainty encoder (`Chain` of `Flux.LSTM`-style layers). +- `combiner`: nonrecurrent target head. +- `state`: current recurrent state ``s_t``, carried across calls (not trainable). +- `n_uncertainty::Int`: number of uncertainty features at each stage. +- `n_state::Int`: number of previous-state features. +- `output_lower`: optional lower bounds for affine output scaling. +- `output_scale`: optional `upper - lower` scale for affine output scaling. + +# Notes +Call `Flux.reset!(policy)` before each scenario — the reset is REAL (it +restores the initial recurrent state), unlike the deprecated Flux-layer +`reset!` no-op. Within a differentiated rollout the threaded state is treated +as data: gradients flow into encoder/combiner parameters through each stage's +forward pass, and the state stored between calls is refreshed by mutation +(mirroring DecisionRules.jl's training semantics). +""" +mutable struct StateConditionedPolicy{E,C,S,L,U} + encoder::E # Recurrent uncertainty encoder (Chain of LSTM-style layers) + combiner::C # Nonrecurrent target head + state::S # Encoder recurrent state, carried across calls + n_uncertainty::Int # Number of uncertainty features per stage + n_state::Int # Number of previous-state features + output_lower::L # Optional affine output lower bounds + output_scale::U # Optional affine output scale (upper - lower) +end + +Flux.@layer StateConditionedPolicy trainable=(encoder, combiner) + +""" + (policy::StateConditionedPolicy)(input) -> AbstractVector + +Evaluate one stage of a state-conditioned policy, threading recurrent state. + +The input is split into the uncertainty portion ``w_t`` and the previous state +``x_{t-1}``, and the forward pass computes + +```math +h_t, s_t = \\text{encoder}(w_t, s_{t-1}), \\qquad +\\hat{x}_t = f_{\\text{combine}}([h_t;\\; x_{t-1}]), +``` + +where ``s_t`` is the updated recurrent state (stored in `policy.state` for the +next call). + +# Arguments +- `input`: concatenated vector `[w_t; x_prev]`. + +# Returns +- Raw combiner output, or affine-scaled output when `output_bounds` were + supplied at construction. +""" function (m::StateConditionedPolicy)(input) - w = reshape(input[1:m.n_uncertainty], :, 1) # (n_unc, 1) for LSTM + # Split the concatenated input into uncertainty w_t and previous state x_{t-1}. + w = input[1:m.n_uncertainty] s = input[m.n_uncertainty+1:end] - h = vec(m.encoder(w)) # (hidden,) - return m.combiner(vcat(h, s)) + + # Cast the uncertainty to the encoder precision (taken from the recurrent + # state), matching DecisionRules.jl's forward pass exactly. + T = _state_eltype(m.state) + + # Advance the recurrent encoder by one step: h_t, s_t = encoder(w_t, s_{t-1}). + h, new_state = _step_encoder(m.encoder, T.(w), m.state) + + # Persist the new recurrent state so the next call starts from s_t. + m.state = new_state + + y = m.combiner(vcat(h, s)) + if m.output_lower === nothing + return y + end + lower = _adapt_policy_bound(m.output_lower, y) + scale = _adapt_policy_bound(m.output_scale, y) + return lower .+ scale .* y end -Flux.reset!(m::StateConditionedPolicy) = Flux.reset!(m.encoder) +""" + Flux.reset!(policy::StateConditionedPolicy) -> Nothing + +Reset the encoder's recurrent state to `Flux.initialstates`, e.g. at the start +of a scenario rollout. +# Notes +The state is re-derived from the (possibly device-moved) encoder weights on +every reset, so calling `Flux.reset!` after `gpu(policy)`/`cpu(policy)` places +the state on the correct device with the correct element type. """ +function Flux.reset!(m::StateConditionedPolicy) + # Reinitialize s_0 to the cell defaults (zeros for LSTM h/c). + m.state = _init_recurrent_state(m.encoder) + return nothing +end + +""" + _adapt_policy_bound(x, ref) + +Move a policy bound vector to the same storage family and element type as +`ref`. + +# Arguments +- `x::AbstractVector`: bound vector stored on the policy. +- `ref::AbstractVector`: output vector whose element type and device should be + matched. + +# Returns +- `x` itself when the concrete vector type already matches `ref`; otherwise a + copied vector compatible with `ref`. +""" +function _adapt_policy_bound(x::AbstractVector, ref::AbstractVector) + typeof(x) === typeof(ref) && return x + y = similar(ref, length(x)) + copyto!(y, convert.(eltype(ref), x)) + return y +end + +""" + _load_encoder_state!(encoder, enc_state) -> encoder + +Load a checkpoint `encoder` state into a recurrent encoder, accepting BOTH +weight structures in use across the two packages: + +1. EXA structure — `Chain` of `Flux.LSTM` wrapper layers, so each layer state + is `(cell = (Wi, Wh, bias),)`. Loaded by the stock `Flux.loadmodel!`. +2. DecisionRules.jl (MAIN) structure — `Chain` of BARE `LSTMCell`s (MAIN's + `_as_cell` strips the wrapper at construction), so each layer state is + `(Wi, Wh, bias)` directly. `Flux.loadmodel!` matches children by key, so + loading a bare-cell layer state into an `LSTM` wrapper (children `(cell,)`) + throws; this helper falls back to cell-by-cell injection, loading each + layer state into `_as_cell(layer)` — the mathematically identical weight + assignment (the wrapper's `cell` has exactly the fields `(Wi, Wh, bias)` + MAIN saved). + +# Arguments +- `encoder`: destination encoder (typically a `Chain` of `Flux.LSTM` layers). +- `enc_state`: the checkpoint's encoder state (from `Flux.state`). + +# Returns +- `encoder`, mutated in place. + +# Throws +- Rethrows the stock `Flux.loadmodel!` error when the fallback does not apply + (non-`Chain` encoder, missing `layers`, or depth mismatch). +""" +function _load_encoder_state!(encoder, enc_state) + try + # Stock path: same weight structure (EXA wrapper layers). + Flux.loadmodel!(encoder, enc_state) + return encoder + catch err + # Fallback applies only to Chain encoders with a per-layer state list. + (encoder isa Flux.Chain && hasproperty(enc_state, :layers)) || rethrow(err) + layer_states = getproperty(enc_state, :layers) + length(layer_states) == length(encoder.layers) || rethrow(err) + for (layer, lstate) in zip(encoder.layers, layer_states) + # Wrapper-style layer state loads into the wrapper; bare-cell + # (MAIN) layer state loads into the unwrapped cell. + dest = hasproperty(lstate, :cell) ? layer : _as_cell(layer) + Flux.loadmodel!(dest, lstate) + end + return encoder + end +end + +""" + load_stateconditioned_policy!(policy, state) + +Load a Flux checkpoint into a [`StateConditionedPolicy`](@ref). + +# Arguments +- `policy::StateConditionedPolicy`: policy to update in place. +- `state`: checkpoint object accepted by `Flux.loadmodel!`. + +# Returns +- `policy`. + +# Notes +- Checkpoints saved before output bounds were added contain only the trainable + encoder and combiner state. In that case, this method restores those + trainable components and keeps the current policy's case-defined output + bounds. +- Checkpoints trained BEFORE recurrent-state threading (memoryless-encoder + era) have the SAME weight structure and load unchanged — only the runtime + semantics differ (the encoder now carries memory across stages). +- DecisionRules.jl (MAIN) checkpoints, whose encoders are `Chain`s of bare + `LSTMCell`s, load through the documented cell-by-cell fallback in + [`_load_encoder_state!`](@ref). +- The loaded policy's recurrent state is reset afterwards so the next rollout + starts from `Flux.initialstates` of the loaded weights. +""" +function load_stateconditioned_policy!(policy::StateConditionedPolicy, state) + try + Flux.loadmodel!(policy, state) + Flux.reset!(policy) + return policy + catch err + hasproperty(state, :encoder) && hasproperty(state, :combiner) || rethrow(err) + @warn "Full StateConditionedPolicy checkpoint load failed; loading encoder/combiner only and keeping current output bounds" exception=(err, catch_backtrace()) + _load_encoder_state!(policy.encoder, getproperty(state, :encoder)) + Flux.loadmodel!(policy.combiner, getproperty(state, :combiner)) + Flux.reset!(policy) + return policy + end +end + +function load_stateconditioned_policy!(policy::ContextualPolicy, state) + inner_state = hasproperty(state, :policy) ? getproperty(state, :policy) : state + load_stateconditioned_policy!(policy.policy, inner_state) + Flux.reset!(policy) + return policy +end + +raw""" StateConditionedPolicy(n_uncertainty, n_state, n_out, layers; - activation=tanh, encoder_type=Flux.LSTM) + activation=tanh, encoder_type=Flux.LSTM, + output_bounds=nothing, combiner_layers=Int[]) + +Construct a state-conditioned sequential target policy. + +The policy separates memory from state conditioning: + +```math +h_t = E_\theta(w_t, h_{t-1}), \qquad +\hat{x}_t = H_\theta([h_t;\, x_{t-1}]). +``` + +The recurrent encoder `Eθ` sees only the stage uncertainty. The previous state +enters only through the feed-forward head `Hθ`, so increasing +`combiner_layers` makes the state-to-target map nonlinear without introducing +recurrence over the state input. -Construct a `StateConditionedPolicy`. +# Arguments +- `n_uncertainty::Int`: number of uncertainty features in each stage input. +- `n_state::Int`: number of previous-state features appended after uncertainty. +- `n_out::Int`: output dimension, usually the state-target dimension. +- `layers::AbstractVector{Int}`: recurrent encoder hidden sizes. -- `layers` : hidden sizes for the LSTM encoder, e.g. `[64, 64]` -- `n_out` : output dimension (= nx = state dimension) +# Keywords +- `activation`: head activation. Use `sigmoid` with `output_bounds` when targets + must remain inside bounds. +- `encoder_type`: recurrent layer constructor, typically `Flux.LSTM`. +- `output_bounds`: optional `(lower, upper)` vectors. If provided, the raw head + output `y` is interpreted as normalized and mapped to + `lower + (upper - lower) .* y`. +- `combiner_layers`: hidden widths for the nonrecurrent target head. `Int[]` + preserves the original single Dense head. + +# Returns +- `StateConditionedPolicy` with trainable `encoder` and `combiner`. + +# Notes +The recurrent encoder receives only uncertainty. The previous state enters +through the feed-forward combiner, so `combiner_layers` increases +state-to-target expressiveness without making the state input recurrent. + +# Examples +```julia +policy = StateConditionedPolicy( + 11, 11, 11, [128, 128]; + activation = sigmoid, + output_bounds = (zeros(Float32, 11), ones(Float32, 11)), + combiner_layers = [128, 128], +) +``` + +See also: [`bounded_state_policy`](@ref) """ function StateConditionedPolicy( n_uncertainty::Int, @@ -95,11 +609,264 @@ function StateConditionedPolicy( layers::AbstractVector{Int}; activation = tanh, encoder_type = Flux.LSTM, + output_bounds = nothing, + combiner_layers = Int[], ) enc_sizes = vcat(n_uncertainty, layers) enc_layers = [encoder_type(enc_sizes[i] => enc_sizes[i+1]) for i in 1:length(layers)] encoder = Flux.Chain(enc_layers...) - combiner = Flux.Dense(layers[end] + n_state => n_out, activation) - return StateConditionedPolicy(encoder, combiner, n_uncertainty, n_state) + combiner = _dense_policy_head( + layers[end] + n_state, + n_out, + collect(Int, combiner_layers); + activation = activation, + ) + if output_bounds === nothing + # Initialize the recurrent state to Flux.initialstates for the encoder. + return StateConditionedPolicy( + encoder, combiner, _init_recurrent_state(encoder), + n_uncertainty, n_state, nothing, nothing, + ) + end + lower, upper = output_bounds + length(lower) == n_out || throw(ArgumentError("output lower bound length must be n_out=$n_out")) + length(upper) == n_out || throw(ArgumentError("output upper bound length must be n_out=$n_out")) + scale = upper .- lower + any(<(zero(eltype(scale))), scale) && + throw(ArgumentError("output upper bounds must be >= lower bounds")) + return StateConditionedPolicy( + encoder, combiner, _init_recurrent_state(encoder), + n_uncertainty, n_state, + collect(lower), collect(scale), + ) +end + +# ── Bounded state-target helpers ────────────────────────────────────────────── + +""" + ConstantStatePolicy(output_template, n_uncertainty, n_state) + +Represent a policy with no trainable target dimensions. + +The policy always returns `output_template`, adapted to the input device. + +# Arguments +- `output_template`: fixed full target vector. +- `n_uncertainty::Int`: number of uncertainty features expected in the input. +- `n_state::Int`: number of state features expected in the input. + +# Returns +- `ConstantStatePolicy`: Flux layer with no trainable parameters. +""" +struct ConstantStatePolicy{O} + output_template::O + n_uncertainty::Int + n_state::Int +end + +Flux.@layer ConstantStatePolicy trainable=() + +""" + (policy::ConstantStatePolicy)(input) -> AbstractVector + +Return the fixed target template, adapted to the input storage family. + +# Arguments +- `input`: vector used only as an adaptation reference. + +# Returns +- The fixed target vector. +""" +(m::ConstantStatePolicy)(input) = _adapt_policy_bound(m.output_template, input) + +""" + Flux.reset!(policy::ConstantStatePolicy) -> Nothing + +No-op reset method for constant policies. +""" +Flux.reset!(::ConstantStatePolicy) = nothing + +""" + FixedOutputPolicy(policy, output_template, output_expansion) + +Expand active target dimensions into a full target vector. + +The wrapped policy predicts only active dimensions. `output_template` stores +constants for inactive dimensions and zeros for active dimensions; +`output_expansion` maps active outputs into the full state vector without +mutation. + +# Arguments +- `policy`: Flux-compatible policy for active dimensions. +- `output_template`: full target vector with inactive constants. +- `output_expansion`: matrix mapping active outputs into full target space. + +# Returns +- `FixedOutputPolicy`: Flux layer wrapper around `policy`. +""" +struct FixedOutputPolicy{P,O,E} + policy::P + output_template::O + output_expansion::E +end + +Flux.@layer FixedOutputPolicy trainable=(policy,) + +""" + (policy::FixedOutputPolicy)(input) -> AbstractVector + +Evaluate the active-dimension policy and expand it into the full target vector. + +# Arguments +- `input`: stage input forwarded to the wrapped policy. + +# Returns +- Full target vector with active outputs inserted and inactive dimensions fixed. +""" +function (m::FixedOutputPolicy)(input) + y = m.policy(input) + return m.output_template .+ m.output_expansion * y +end + +""" + Flux.reset!(policy::FixedOutputPolicy) + +Reset the wrapped active-dimension policy. + +# Returns +- The result of `Flux.reset!(policy.policy)`. +""" +Flux.reset!(m::FixedOutputPolicy) = Flux.reset!(m.policy) + +""" + load_stateconditioned_policy!(policy::FixedOutputPolicy, state) + +Load checkpoint state into the wrapped active-dimension policy. + +# Arguments +- `policy::FixedOutputPolicy`: wrapper whose inner policy is updated. +- `state`: checkpoint object accepted by the inner policy loader. + +# Returns +- The result of `load_stateconditioned_policy!(policy.policy, state)`. +""" +load_stateconditioned_policy!(policy::FixedOutputPolicy, state) = + load_stateconditioned_policy!(policy.policy, state) + +raw""" + bounded_state_policy(n_uncertainty, lower, upper, layers; kwargs...) + +Build a state-conditioned policy whose full output is guaranteed to lie in +`[lower, upper]`, while avoiding trainable outputs for inactive dimensions. + +The returned policy has the same rollout semantics as +[`StateConditionedPolicy`](@ref): + +```math +\hat{x}_t = +\ell + (u - \ell) \odot H_\theta([E_\theta(w_t);\, x_{t-1}]), +``` + +where `Hθ` is a sigmoid head by default. Dimensions with `upper == lower` are +treated as constants unless `active_mask` overrides that choice. + +By default, a dimension is active when `upper > lower`. Fixed dimensions are +returned as constants, so pure pass-through or no-storage state components do +not create meaningless target parameters. Pass `active_mask` to override this +selection for case-specific target relevance. + +Set `combiner_layers` to add hidden layers after `[encoded_uncertainty; state]` +and before the bounded target output. This keeps recurrence confined to the +uncertainty encoder while making the state-to-target map nonlinear. + +# Arguments +- `n_uncertainty::Int`: number of uncertainty features in each stage input. +- `lower::AbstractVector`: lower bound for each full target dimension. +- `upper::AbstractVector`: upper bound for each full target dimension. +- `layers::AbstractVector{Int}`: recurrent uncertainty-encoder hidden sizes. + +# Keywords +- `activation`: head activation, defaulting to `sigmoid`. +- `encoder_type`: recurrent layer constructor. +- `active_mask`: optional Boolean mask selecting trainable output dimensions. +- `fixed_values`: values used for inactive target dimensions. +- `combiner_layers`: hidden widths for the nonrecurrent target head. + +# Returns +- `StateConditionedPolicy` when all dimensions are active. +- `ConstantStatePolicy` when no dimensions are active. +- `FixedOutputPolicy` when only a subset is active. + +# Throws +- `ArgumentError` if bound lengths differ, `active_mask` has the wrong length, + or any upper bound is smaller than its lower bound. + +# Examples +```julia +policy = bounded_state_policy( + 11, + min_volume, + max_volume, + [128, 128]; + combiner_layers = [256, 256], +) +``` +""" +function bounded_state_policy( + n_uncertainty::Int, + lower::AbstractVector, + upper::AbstractVector, + layers::AbstractVector{Int}; + activation = sigmoid, + encoder_type = Flux.LSTM, + active_mask = nothing, + fixed_values = lower, + combiner_layers = Int[], +) + length(lower) == length(upper) || + throw(ArgumentError("lower and upper bound vectors must have the same length")) + n_state = length(lower) + length(fixed_values) == n_state || + throw(ArgumentError("fixed_values length must match state dimension $n_state")) + + scale = upper .- lower + any(<(zero(eltype(scale))), scale) && + throw(ArgumentError("upper bounds must be >= lower bounds")) + + active = if active_mask === nothing + collect(scale .> zero(eltype(scale))) + else + length(active_mask) == n_state || + throw(ArgumentError("active_mask length must match state dimension $n_state")) + collect(Bool.(active_mask)) + end + + if all(active) + return StateConditionedPolicy( + n_uncertainty, n_state, n_state, layers; + activation = activation, + encoder_type = encoder_type, + output_bounds = (lower, upper), + combiner_layers = combiner_layers, + ) + elseif !any(active) + return ConstantStatePolicy(collect(fixed_values), n_uncertainty, n_state) + end + + idx = findall(active) + active_policy = StateConditionedPolicy( + n_uncertainty, n_state, length(idx), layers; + activation = activation, + encoder_type = encoder_type, + output_bounds = (lower[idx], upper[idx]), + combiner_layers = combiner_layers, + ) + template = collect(fixed_values) + template[idx] .= zero(eltype(template)) + expansion = zeros(eltype(template), n_state, length(idx)) + for (j, i) in enumerate(idx) + expansion[i, j] = one(eltype(template)) + end + return FixedOutputPolicy(active_policy, template, expansion) end diff --git a/src/rollout.jl b/src/rollout.jl index f998d5b..3c8dfcd 100644 --- a/src/rollout.jl +++ b/src/rollout.jl @@ -7,35 +7,287 @@ # semantics instead: at each stage, solve one stage, extract the realized next # state, and feed that state into the next policy call. +""" + _target_violation_share(objective::Real, objective_no_target_penalty::Real) -> Float64 + +Compute the fraction of a stage objective attributable to the target-tracking +penalty. + +# Arguments +- `objective::Real`: total stage objective (operational cost + target penalty). +- `objective_no_target_penalty::Real`: stage objective with target penalty + stripped out. + +# Returns +- `Float64`: fraction in ``[0, 1]``, or `NaN` if the ratio is ill-defined. + +# Notes +If the total objective includes both operational cost and a quadratic penalty +``\\lambda \\|x_t - \\hat{x}_t\\|^2``, this function returns + +```math +\\frac{\\text{objective} - \\text{objective\\_no\\_target\\_penalty}}{\\text{objective}}. +``` + +The return value is `NaN` when the objective is non-finite, the penalty is +non-finite, or the objective magnitude is below ``10^{-12}``. +""" function _target_violation_share(objective::Real, objective_no_target_penalty::Real) + # The penalty is the difference between the full and penalty-free objectives. penalty = objective - objective_no_target_penalty + # Guard against non-finite or near-zero denominators that would give NaN/Inf. (isfinite(objective) && isfinite(penalty) && abs(objective) > 1e-12) || return NaN + # Return the penalty's share of the total objective. return penalty / objective end -_cpu_vec(x) = vec(collect(Array(x))) +""" + _to_vec(x) -> AbstractVector + +Flatten `x` into a contiguous one-dimensional vector. +# Arguments +- `x`: any array-like object (matrix, vector, or view). + +# Returns +- `AbstractVector`: a one-dimensional vector with the same elements as `x`. + +# Notes +`SubArray` inputs are materialized with `collect` because downstream solvers +and array operations such as `copyto!` and `vcat` require contiguous storage. +All other array types are reshaped via `vec`. """ - rollout_tsddr(model, initial_state, stage_problem, w_flat; kwargs...) - -Evaluate `model` by solving `stage_problem` sequentially over a materialized -scenario `w_flat`. Unlike deterministic-equivalent evaluation, the optimizer -only receives one uncertainty slice at a time. - -Required callbacks: -- `set_stage_parameters!(stage_problem, state_in, w_t, target, stage)` updates the - one-stage problem before each solve. -- `realized_state(stage_problem, result)` returns the next state realized by the - solved stage problem. - -Optional callbacks: -- `objective_no_target_penalty(stage_problem, result)` returns the stage objective - with target-slack penalty removed. The default is `result.objective`. - -`policy_state = :realized` is the closed-loop deployment semantics. `:target` -keeps the policy recurrence on its own previous target, matching the target -generation used by deterministic-equivalent training while still solving stages -one by one. +_to_vec(x) = vec(x) # reshape in-place for contiguous arrays +_to_vec(x::SubArray) = collect(x) # materialize views to contiguous storage + +""" + _state_bound_vector(bound, ref::AbstractVector) -> Union{Nothing, AbstractVector} + +Convert a user-supplied state bound into a concrete vector whose element type +and device (CPU or GPU) match `ref`. + +# Arguments +- `bound`: the bound specification (`nothing`, a `Real` scalar, or an + `AbstractVector` / `SubArray`). +- `ref::AbstractVector`: reference vector whose length, element type, and + device placement determine the output format. + +# Returns +- `Nothing` if `bound === nothing`. +- `AbstractVector` matching `ref` in length, element type, and device. + +# Throws +- `ArgumentError` if a vector bound has the wrong length or `bound` is an + unsupported type. + +# Notes +Accepted bound forms are `nothing`, a scalar broadcast to all state entries, +or a vector of the same length as `ref`. `SubArray` bounds are materialized via +[`_to_vec`](@ref) before device adaptation so GPU kernels receive contiguous +storage. +""" +function _state_bound_vector(bound, ref::AbstractVector) + # Nothing means "no bound on this side" — propagate the sentinel. + bound === nothing && return nothing + if bound isa AbstractVector || bound isa SubArray + # Vector bounds must be element-wise, so lengths must agree. + length(bound) == length(ref) || + throw(ArgumentError("state bound length must match state length=$(length(ref)), got $(length(bound))")) + # Materialize, cast to ref's element type, and adapt to ref's device. + return _adapt_array(eltype(ref).(_to_vec(bound)), ref) + end + # Scalar bounds are broadcast into a constant vector matching ref's shape. + bound isa Real || + throw(ArgumentError("state bounds must be vectors, scalars, or nothing")) + # Allocate on the same device as ref using `similar`. + out = similar(ref, length(ref)) + # Fill every element with the scalar bound cast to ref's element type. + fill!(out, eltype(ref)(bound)) + return out +end + +""" + _project_state_to_bounds(state::AbstractVector, state_bounds) -> AbstractVector + +Clamp every element of `state` to lie within `[lower, upper]`. + +# Arguments +- `state::AbstractVector`: realized state vector to project. +- `state_bounds`: `nothing` (no projection), or a 2-element tuple/pair + `(lower, upper)` where each side is `nothing`, a scalar, or a vector. + +# Returns +- `AbstractVector`: projected state with the same element type as `state`. + +# Throws +- `ArgumentError` if `state_bounds` is not `nothing` and does not have + exactly two elements. + +# Notes +Given bounds ``l`` and ``u``, the projection is the element-wise clamp + +```math +\\operatorname{proj}(x)_i = \\min\\bigl(\\max(x_i,\\, l_i),\\, u_i\\bigr). +``` + +This repair is intended for solver-tolerance drift at stage interfaces, not as +a substitute for a recourse-feasible model. +""" +function _project_state_to_bounds(state::AbstractVector, state_bounds) + # No bounds means the state passes through unchanged. + state_bounds === nothing && return state + # Bounds must be a (lower, upper) pair. + length(state_bounds) == 2 || + throw(ArgumentError("state_bounds must be a pair/tuple (lower, upper)")) + # Convert each side into a concrete vector (or nothing) matching state. + lower = _state_bound_vector(state_bounds[1], state) + upper = _state_bound_vector(state_bounds[2], state) + # Apply element-wise clamping: first lower, then upper. + projected = state + lower !== nothing && (projected = max.(projected, lower)) # enforce lower bound + upper !== nothing && (projected = min.(projected, upper)) # enforce upper bound + return projected +end + +""" + _project_realized_state(state::AbstractVector, state_bounds, project_state) + -> AbstractVector + +Repair a realized state before it is fed into the next rollout stage. + +# Arguments +- `state::AbstractVector`: raw realized state from the stage solver. +- `state_bounds`: `nothing` or `(lower, upper)` passed to + [`_project_state_to_bounds`](@ref). +- `project_state`: `nothing`, or a callable `f(state) -> projected_state` + that enforces non-box feasibility constraints. + +# Returns +- `AbstractVector`: the doubly-projected state, cast to the element type + of the input `state`. + +# Notes +The function first applies box projection via +[`_project_state_to_bounds`](@ref), then applies `project_state` when a custom +projector is supplied. If `project_state === nothing`, only the box projection +is applied. +""" +function _project_realized_state(state::AbstractVector, state_bounds, project_state) + # First pass: box-clamp the raw realized state. + projected = _project_state_to_bounds(state, state_bounds) + # If no custom projector is provided, the box projection is sufficient. + project_state === nothing && return projected + # Second pass: apply the user's non-box projection and cast back to state's eltype. + return eltype(state).(_to_vec(project_state(projected))) +end + +""" + rollout_tsddr( + model, + initial_state::AbstractVector, + stage_problem, + w_flat::AbstractVector; + horizon::Int, + n_uncertainty::Int, + set_stage_parameters!::Function, + realized_state::Function, + objective_no_target_penalty::Function = (prob, result) -> result.objective, + madnlp_kwargs = NamedTuple(), + warmstart::Bool = true, + policy_state::Symbol = :realized, + solver_state = nothing, + reuse_solver::Bool = false, + state_bounds = nothing, + project_state = nothing, + retry_on_failure::Bool = true, + ) -> Union{Nothing, NamedTuple} + +Evaluate a target-setting decision rule `model` by solving `stage_problem` +sequentially over a materialized uncertainty scenario `w_flat`. + +Unlike the deterministic-equivalent training solve (which sees the full +horizon simultaneously), this rollout mirrors deployment semantics: at each +stage the solver receives only one uncertainty slice, solves, extracts the +realized next state, and feeds that state into the next policy call. + +The stage-wise recursion is + +```math +x_0 = x_{\\text{init}}, \\quad +\\hat{x}_t = \\pi_\\theta(w_t,\\, x_{t-1}), \\quad +x_t = \\operatorname{solve}_t(x_{t-1},\\, w_t,\\, \\hat{x}_t), +``` + +where ``\\pi_\\theta`` is the learned policy (`model`), +``\\operatorname{solve}_t`` solves the single-stage optimization problem, and +``x_t`` is the realized state forwarded to stage ``t+1``. + +# Arguments +- `model`: the target-setting policy ``\\pi_\\theta``. Called as + `model(vcat(w_t, x_{t-1}))` to produce ``\\hat{x}_t``. +- `initial_state::AbstractVector`: initial state ``x_0``. +- `stage_problem`: stage optimization problem (must expose `.model`). +- `w_flat::AbstractVector`: flat uncertainty vector of length + `horizon * n_uncertainty`, sliced into per-stage windows. + +# Keywords +- `horizon::Int`: number of stages ``T``. +- `n_uncertainty::Int`: dimension of each per-stage uncertainty slice. +- `set_stage_parameters!::Function`: callback + `(stage_problem, state, w_t, target, stage) -> nothing` that writes the + current state, uncertainty, and target into the stage problem before each + solve. +- `realized_state::Function`: callback `(stage_problem, result) -> x_t` + that reads the realized next state from the solver result. +- `objective_no_target_penalty::Function`: callback + `(stage_problem, result) -> Float64` returning the stage objective with + the target-tracking penalty removed. Defaults to `result.objective`. +- `madnlp_kwargs`: keyword arguments forwarded to the MadNLP solver + constructor. +- `warmstart::Bool`: whether to warm-start the solver from the previous + stage's dual solution. +- `policy_state::Symbol`: `:realized` feeds the closed-loop realized state + ``x_t`` back to the policy; `:target` feeds the policy's own previous + target ``\\hat{x}_t`` instead, matching deterministic-equivalent training + semantics. +- `solver_state`: optional pre-built solver object to reuse across stages. +- `reuse_solver::Bool`: if `true`, a single solver object is reused (and + warm-started) across all stages. +- `state_bounds`: `nothing` or `(lower, upper)` pair to clamp realized + states via [`_project_state_to_bounds`](@ref). +- `project_state`: `nothing` or a callable `f(state) -> state` for non-box + feasibility repairs via [`_project_realized_state`](@ref). +- `retry_on_failure::Bool`: if `true`, failed or non-finite solves are + retried once with a cold-start solver. + +# Returns +- `nothing` if any stage solve fails after retry. +- A `NamedTuple` with fields: + - `objective::Float64`: cumulative objective over the horizon. + - `objective_no_target_penalty::Float64`: cumulative objective without + target penalties. + - `target_violation_share::Float64`: fraction of objective from target + penalties (see [`_target_violation_share`](@ref)). + - `final_state::AbstractVector`: realized state after the last stage. + - `state_trajectory::Vector`: realized states ``[x_0, x_1, \\ldots, x_T]``. + - `target_trajectory::Vector`: policy targets + ``[\\hat{x}_1, \\ldots, \\hat{x}_T]``. + +# Throws +- `ArgumentError` if `horizon < 1`, `n_uncertainty < 1`, `w_flat` has the + wrong length, or `policy_state` is not `:realized` or `:target`. + +# Examples +```julia +result = rollout_tsddr( + model, x0, stage_problem, w_flat; + horizon = 96, + n_uncertainty = 5, + set_stage_parameters! = my_set_params!, + realized_state = my_realized_state, +) +result !== nothing && @show result.objective +``` """ function rollout_tsddr( model, @@ -52,45 +304,76 @@ function rollout_tsddr( policy_state::Symbol = :realized, solver_state = nothing, reuse_solver::Bool = false, + state_bounds = nothing, + project_state = nothing, + retry_on_failure::Bool = true, ) + # --- Input validation --------------------------------------------------- horizon >= 1 || throw(ArgumentError("horizon must be >= 1")) n_uncertainty >= 1 || throw(ArgumentError("n_uncertainty must be >= 1")) + # w_flat must contain exactly horizon slices of n_uncertainty each. length(w_flat) == horizon * n_uncertainty || throw(ArgumentError("w_flat length must be horizon*n_uncertainty=$(horizon * n_uncertainty), got $(length(w_flat))")) + # Only two feedback modes are supported. policy_state in (:realized, :target) || throw(ArgumentError("policy_state must be :realized or :target, got :$policy_state")) - F = eltype(initial_state) - state = solver_state + # --- Infer numeric types and allocate trajectory storage --------------- + F = eltype(initial_state) # element type (e.g. Float32) + nx = length(initial_state) # state dimension + state = solver_state # optional pre-built solver + w_flat = _adapt_array(F.(w_flat), initial_state) # move w_flat to same device as initial_state + # Reset any recurrent state in the policy network (e.g. LSTM hidden state). Flux.reset!(model) - realized_prev = F.(_cpu_vec(initial_state)) + # x_0: the realized state entering stage 1. + realized_prev = F.(_to_vec(initial_state)) + # Target recurrence state (used when policy_state == :target). target_prev = copy(realized_prev) - state_trajectory = Vector{Vector{F}}(undef, horizon + 1) - target_trajectory = Vector{Vector{F}}(undef, horizon) - state_trajectory[1] = copy(realized_prev) + # Pre-allocate trajectory arrays: states have T+1 entries, targets have T. + state_trajectory = Vector{AbstractVector{F}}(undef, horizon + 1) + target_trajectory = Vector{AbstractVector{F}}(undef, horizon) + state_trajectory[1] = copy(realized_prev) # store x_0 - objective = 0.0 - objective_no_penalty = 0.0 + # Pre-allocate Float64 buffers for the solver interface (solvers use Float64). + state_f64 = similar(initial_state, Float64, nx) # x_{t-1} in Float64 + w_f64 = similar(initial_state, Float64, n_uncertainty) # w_t in Float64 + target_f64 = similar(initial_state, Float64, nx) # xhat_t in Float64 + # Running sums of cumulative cost over the horizon. + objective = 0.0 # total objective (operational + target penalty) + objective_no_penalty = 0.0 # total objective without target penalty + + # --- Stage-wise forward pass ------------------------------------------- for stage in 1:horizon - lo = (stage - 1) * n_uncertainty + 1 - hi = stage * n_uncertainty - wt = F.(_cpu_vec(view(w_flat, lo:hi))) + # Slice out this stage's uncertainty window from the flat vector. + wt = view(w_flat, (stage-1)*n_uncertainty+1 : stage*n_uncertainty) + # Choose the state fed to the policy: realized (closed-loop) or target. policy_input_state = policy_state === :realized ? realized_prev : target_prev + # Evaluate the policy: pi_theta(w_t, x_{t-1}) -> xhat_t. target = model(vcat(wt, policy_input_state)) - target_trajectory[stage] = F.(_cpu_vec(target)) + # Flatten the target to a 1-D vector for downstream use. + target_vec = _to_vec(target) + # Store the target in the trajectory (cast to the state element type). + target_trajectory[stage] = F.(target_vec) + # Copy inputs into the Float64 solver buffers. + copyto!(state_f64, realized_prev) # x_{t-1} + copyto!(w_f64, wt) # w_t + copyto!(target_f64, target_vec) # xhat_t + # Write the current state, uncertainty, and target into the stage problem. set_stage_parameters!( stage_problem, - Float64.(realized_prev), - Float64.(wt), - Float64.(_cpu_vec(target)), + state_f64, + w_f64, + target_f64, stage, ) + # --- Solve the single-stage optimization problem ------------------- if reuse_solver || state !== nothing + # Reuse an existing solver; create one lazily on first call. state === nothing && (state = _make_solver(stage_problem.model, madnlp_kwargs)) result = _solve!( state, @@ -99,6 +382,7 @@ function rollout_tsddr( madnlp_kwargs = madnlp_kwargs, ) else + # Create a fresh solver for this stage (no cross-stage warm-start). stage_state = _make_solver(stage_problem.model, madnlp_kwargs) result = _solve!( stage_state, @@ -108,53 +392,226 @@ function rollout_tsddr( ) end + # --- Retry logic: cold-start fallback on solver failure ------------ + if retry_on_failure && (!solve_succeeded(result) || !isfinite(result.objective)) + # Build a fresh solver and retry without warm-start. + retry_state = _make_solver(stage_problem.model, madnlp_kwargs) + result = _solve!( + retry_state, + stage_problem.model; + warmstart = false, + madnlp_kwargs = madnlp_kwargs, + ) + end + + # Abort the rollout if the solve still failed after retry. solve_succeeded(result) || return nothing + # Abort on non-finite objective (e.g. MadNLP returning 0.0 for infeasible). isfinite(result.objective) || return nothing + # --- Extract penalty-free objective, with retry -------------------- no_penalty = objective_no_target_penalty(stage_problem, result) + if retry_on_failure && !isfinite(no_penalty) + # Non-finite penalty-free cost can indicate a solver glitch; retry. + retry_state = _make_solver(stage_problem.model, madnlp_kwargs) + result = _solve!( + retry_state, + stage_problem.model; + warmstart = false, + madnlp_kwargs = madnlp_kwargs, + ) + solve_succeeded(result) || return nothing + isfinite(result.objective) || return nothing + no_penalty = objective_no_target_penalty(stage_problem, result) + end + # Final guard: abort if the penalty-free cost is still non-finite. isfinite(no_penalty) || return nothing - objective += result.objective - objective_no_penalty += no_penalty - realized_prev = F.(_cpu_vec(realized_state(stage_problem, result))) - target_prev = F.(_cpu_vec(target)) + # --- Accumulate costs and advance the state ------------------------ + objective += result.objective # add stage cost to cumulative total + objective_no_penalty += no_penalty # add penalty-free stage cost + # Read the realized next state x_t from the solver solution. + raw_realized = F.(_to_vec(realized_state(stage_problem, result))) + # Project x_t to feasibility (box bounds + custom projector). + realized_prev = _project_realized_state(raw_realized, state_bounds, project_state) + # Update the target recurrence for :target mode. + target_prev = target_trajectory[stage] + # Record x_t in the state trajectory. state_trajectory[stage + 1] = copy(realized_prev) end + # --- Assemble and return the rollout summary --------------------------- return ( - objective = objective, - objective_no_target_penalty = objective_no_penalty, - target_violation_share = _target_violation_share(objective, objective_no_penalty), - final_state = realized_prev, - state_trajectory = state_trajectory, - target_trajectory = target_trajectory, + objective = objective, # sum of stage objectives + objective_no_target_penalty = objective_no_penalty, # sum minus target penalties + target_violation_share = _target_violation_share(objective, objective_no_penalty), # penalty fraction + final_state = realized_prev, # x_T + state_trajectory = state_trajectory, # [x_0, ..., x_T] + target_trajectory = target_trajectory, # [xhat_1, ..., xhat_T] ) end +""" + RolloutEvaluation + +Store configuration and mutable summaries for periodic rollout evaluation. + +# Fields +- `stage_problem`: the single-stage optimization problem template. +- `initial_state`: initial state ``x_0`` for every rollout. +- `scenarios::Vector`: pre-sampled uncertainty vectors, each of length + `horizon * n_uncertainty`. +- `horizon::Int`: number of stages ``T``. +- `n_uncertainty::Int`: per-stage uncertainty dimension. +- `set_stage_parameters!::Function`: callback to write stage data into the + problem (see [`rollout_tsddr`](@ref)). +- `realized_state::Function`: callback to extract ``x_t`` from a solve + result. +- `objective_no_target_penalty::Function`: callback to extract the + penalty-free stage cost. +- `madnlp_kwargs`: keyword arguments forwarded to MadNLP. +- `warmstart::Bool`: whether to warm-start across stages. +- `stride::Int`: evaluate every `stride` training iterations. +- `policy_state::Symbol`: `:realized` or `:target` (see + [`rollout_tsddr`](@ref)). +- `solver_state`: pre-built solver object (or `nothing`). +- `reuse_solver::Bool`: whether to reuse a single solver across stages. +- `state_bounds`: optional `(lower, upper)` feasibility bounds. +- `project_state`: optional non-box projection callback. +- `retry_on_failure::Bool`: retry failed solves with a cold start. +- `stage_problem_pool::Vector`: pool of stage problems for parallel + evaluation. +- `active_scenarios::Int`: number of scenarios to evaluate (at most + `length(scenarios)`). +- `last_objective::Float64`: mean objective across successful scenarios. +- `last_objective_no_target_penalty::Float64`: mean penalty-free objective. +- `last_violation_share::Float64`: mean target-violation share. +- `last_n_ok::Int`: number of scenarios that solved successfully. +- `last_scenario_data::Vector{Any}`: per-scenario `(index, result)` pairs + from the most recent evaluation. + +# Notes +The struct is callable as `evaluation(iter, model)`. At every `stride`-th +iteration, it runs [`rollout_tsddr`](@ref) on up to `active_scenarios` +scenarios and updates the mutable summary fields. When `stage_problem_pool` +contains more than one entry, scenarios are distributed across the pool with +`Threads.@spawn`. + +Thread-safety: the single `set_stage_parameters!`, `realized_state`, and +`objective_no_target_penalty` callbacks are shared across all spawned tasks +while each task receives its own stage problem from the pool. When +`stage_problem_pool` has more than one entry, these callbacks must therefore be +thread-safe and must write only into the stage problem they are handed — any +shared mutable buffer (e.g. a captured scratch array reused across calls) +races across tasks and silently corrupts results. +""" mutable struct RolloutEvaluation <: Function - stage_problem - initial_state - scenarios::Vector - horizon::Int - n_uncertainty::Int - set_stage_parameters!::Function - realized_state::Function - objective_no_target_penalty::Function - madnlp_kwargs - warmstart::Bool - stride::Int - policy_state::Symbol - solver_state - reuse_solver::Bool - stage_problem_pool::Vector # pool of stage problems for parallel evaluation - active_scenarios::Int # how many scenarios to evaluate (≤ length(scenarios)) - last_objective::Float64 - last_objective_no_target_penalty::Float64 - last_violation_share::Float64 - last_n_ok::Int - last_scenario_data::Vector{Any} + stage_problem # single-stage optimization problem template + initial_state # initial state x_0 for all rollouts + scenarios::Vector # pre-sampled uncertainty vectors + horizon::Int # number of decision stages T + n_uncertainty::Int # per-stage uncertainty dimension + set_stage_parameters!::Function # callback: write stage data into the problem + realized_state::Function # callback: extract realized x_t from result + objective_no_target_penalty::Function # callback: penalty-free stage cost + madnlp_kwargs # solver keyword arguments + warmstart::Bool # warm-start across stages + stride::Int # evaluate every stride-th iteration + policy_state::Symbol # :realized or :target feedback mode + solver_state # pre-built solver (or nothing) + reuse_solver::Bool # reuse single solver across stages + state_bounds # (lower, upper) feasibility bounds or nothing + project_state # non-box projection callback or nothing + retry_on_failure::Bool # retry failed solves with cold start + stage_problem_pool::Vector # pool of stage problems for parallel evaluation + active_scenarios::Int # how many scenarios to evaluate (leq length(scenarios)) + last_objective::Float64 # mean objective from last evaluation + last_objective_no_target_penalty::Float64 # mean penalty-free objective from last evaluation + last_violation_share::Float64 # mean target-violation share from last evaluation + last_n_ok::Int # number of successful scenarios in last evaluation + last_scenario_data::Vector{Any} # per-scenario (index, result) pairs from last eval end +""" + RolloutEvaluation( + stage_problem, + initial_state, + scenarios; + horizon::Int, + n_uncertainty::Int, + set_stage_parameters!::Function, + realized_state::Function, + objective_no_target_penalty::Function = (prob, result) -> result.objective, + madnlp_kwargs = NamedTuple(), + warmstart::Bool = true, + stride::Int = 1, + policy_state::Symbol = :realized, + reuse_solver::Bool = false, + state_bounds = nothing, + project_state = nothing, + retry_on_failure::Bool = true, + stage_problem_pool::Vector = [], + active_scenarios::Int = length(scenarios), + ) -> RolloutEvaluation + +Construct a [`RolloutEvaluation`](@ref) callback for periodic out-of-sample +policy evaluation during training. + +All mutable result fields (`last_objective`, `last_n_ok`, etc.) are +initialized to `NaN` / `0` / empty and are populated on the first call. + +# Arguments +- `stage_problem`: the single-stage optimization problem (must expose + `.model`). +- `initial_state`: initial state ``x_0``. +- `scenarios`: iterable of pre-sampled uncertainty vectors, each of length + `horizon * n_uncertainty`. + +# Keywords +- `horizon::Int`: number of stages ``T``. +- `n_uncertainty::Int`: per-stage uncertainty dimension. +- `set_stage_parameters!::Function`: stage-parameter callback. +- `realized_state::Function`: realized-state extraction callback. +- `objective_no_target_penalty::Function`: penalty-free cost callback. +- `madnlp_kwargs`: solver keyword arguments. +- `warmstart::Bool`: warm-start across stages within each rollout. +- `stride::Int`: evaluate every `stride`-th training iteration. +- `policy_state::Symbol`: `:realized` (closed-loop) or `:target`. +- `reuse_solver::Bool`: reuse a single solver across stages. +- `state_bounds`: `nothing` or `(lower, upper)` for box projection. +- `project_state`: `nothing` or custom non-box projector. +- `retry_on_failure::Bool`: retry failed solves with cold start. +- `stage_problem_pool::Vector`: pool of independent stage problems for + multi-threaded evaluation. An empty pool uses sequential evaluation. + With more than one pool entry, the shared `set_stage_parameters!`, + `realized_state`, and `objective_no_target_penalty` callbacks run + concurrently on different tasks: they must be thread-safe and write only + into the stage problem passed to them (no shared mutable buffers), + otherwise results race. +- `active_scenarios::Int`: cap on how many scenarios to evaluate (defaults + to all). + +# Returns +- `RolloutEvaluation`: callable training callback with empty result summaries. + +# Throws +- `ArgumentError` if `scenarios` is empty, `stride < 1`, or `policy_state` is + not `:realized` or `:target`. + +# Examples +```julia +eval_cb = RolloutEvaluation( + stage_problem, x0, test_scenarios; + horizon = 96, + n_uncertainty = 5, + set_stage_parameters! = my_set_params!, + realized_state = my_realized_state, + stride = 10, +) +# Use as a training callback: +eval_cb(iter, model) +``` +""" function RolloutEvaluation( stage_problem, initial_state, @@ -169,18 +626,24 @@ function RolloutEvaluation( stride::Int = 1, policy_state::Symbol = :realized, reuse_solver::Bool = false, + state_bounds = nothing, + project_state = nothing, + retry_on_failure::Bool = true, stage_problem_pool::Vector = [], active_scenarios::Int = length(scenarios), ) + # At least one scenario is required for meaningful evaluation. isempty(scenarios) && throw(ArgumentError("scenarios must be nonempty")) + # Stride must be positive; stride=1 evaluates every iteration. stride >= 1 || throw(ArgumentError("stride must be >= 1")) + # Validate the feedback mode. policy_state in (:realized, :target) || throw(ArgumentError("policy_state must be :realized or :target, got :$policy_state")) return RolloutEvaluation( stage_problem, initial_state, - collect(scenarios), + collect(scenarios), # materialize to a concrete Vector horizon, n_uncertainty, set_stage_parameters!, @@ -190,18 +653,42 @@ function RolloutEvaluation( warmstart, stride, policy_state, + # Pre-build the solver if reuse is requested; otherwise leave as nothing. reuse_solver ? _make_solver(stage_problem.model, madnlp_kwargs) : nothing, reuse_solver, - collect(stage_problem_pool), + state_bounds, + project_state, + retry_on_failure, + collect(stage_problem_pool), # materialize the pool to a concrete Vector active_scenarios, - NaN, - NaN, - NaN, - 0, - Any[], + NaN, # last_objective: not yet evaluated + NaN, # last_objective_no_target_penalty + NaN, # last_violation_share + 0, # last_n_ok: no successful scenarios yet + Any[], # last_scenario_data: empty until first eval ) end +""" + (evaluation::RolloutEvaluation)(iter, model) -> Nothing + +Evaluate `model` on rollout scenarios when `iter` is aligned with +`evaluation.stride`. + +# Arguments +- `evaluation::RolloutEvaluation`: callback state and rollout configuration. +- `iter`: current training iteration. +- `model`: policy model passed to [`rollout_tsddr`](@ref). + +# Returns +- `nothing`: summary fields on `evaluation` are updated in place. + +# Notes +If `iter % evaluation.stride != 0`, the method only clears stale per-scenario +data and returns. Otherwise it records mean objective, mean penalty-free +objective, mean target-violation share, the number of successful scenarios, and +per-scenario results. +""" function (evaluation::RolloutEvaluation)(iter, model) empty!(evaluation.last_scenario_data) iter % evaluation.stride == 0 || return nothing @@ -232,6 +719,9 @@ function (evaluation::RolloutEvaluation)(iter, model) policy_state = evaluation.policy_state, solver_state = evaluation.solver_state, reuse_solver = evaluation.reuse_solver, + state_bounds = evaluation.state_bounds, + project_state = evaluation.project_state, + retry_on_failure = evaluation.retry_on_failure, ) result === nothing && continue total += result.objective @@ -264,6 +754,9 @@ function (evaluation::RolloutEvaluation)(iter, model) warmstart = evaluation.warmstart, policy_state = evaluation.policy_state, reuse_solver = false, + state_bounds = evaluation.state_bounds, + project_state = evaluation.project_state, + retry_on_failure = evaluation.retry_on_failure, ) push!(tasks, t) end @@ -298,13 +791,30 @@ function (evaluation::RolloutEvaluation)(iter, model) end """ - critic_samples_from_evaluation(eval; objective_key) -> Vector{CriticSample} + critic_samples_from_evaluation( + eval_obj::RolloutEvaluation; + objective_key::Symbol = :objective, + ) -> Vector{CriticSample} Convert the last rollout evaluation results into `CriticSample`s for critic -training. Target multipliers are zero (rollout evaluation does not produce -duals), so these samples contribute only to the value loss term. By default the -critic target uses the full rollout objective; pass -`objective_key = :objective_no_target_penalty` to remove target-slack penalties. +training. + +# Arguments +- `eval_obj::RolloutEvaluation`: evaluation callback containing + `last_scenario_data` from a previous call. + +# Keywords +- `objective_key::Symbol`: field of each rollout result used as the scalar + critic target; commonly `:objective` or `:objective_no_target_penalty`. + +# Returns +- `Vector{CriticSample}`: one sample per successful rollout scenario from the + last evaluation. + +# Notes +Rollout evaluation does not produce dual multipliers, so generated samples use +zero target multipliers and contribute only to the value-loss term unless +combined with other samples. """ function critic_samples_from_evaluation( eval_obj::RolloutEvaluation; diff --git a/src/training.jl b/src/training.jl index 0407ef6..78d5e01 100644 --- a/src/training.jl +++ b/src/training.jl @@ -6,7 +6,7 @@ # 1. uncertainty_sampler() → flat w (length T × nw_per_stage) # 2. Policy rollout: x̂_t = policy(vcat(w_t, x̂_{t-1})) for t = 1..T # 3. ExaModels.set_parameter! for x0, uncertainty, targets → MadNLP.solve! -# 4. λ = result.multipliers[target_con_range] (∇_{x̂} Q, envelope theorem) +# 4. λ = target_multipliers(de, result) (∇_{x̂} Q, envelope theorem) # 5. Zygote: ∇_θ (1/n) Σ_s ⟨λ_s, x̂_s(θ)⟩ → Flux.update! # # The user passes parameter objects (p_x0, p_target, p_uncertainty) exactly as @@ -21,35 +21,265 @@ # ── Gradient materialization ────────────────────────────────────────────────── -_mat(x) = x -_mat(x::Zygote.OneElement) = collect(x) +""" + _mat(x) + _mat(x::Zygote.OneElement) + _mat(x::ChainRulesCore.Tangent) + _mat(x::ChainRulesCore.MutableTangent) + +Recursively materialize lazy Zygote / ChainRules tangent wrappers into plain +Julia values (arrays and named tuples). + +Zygote may return `OneElement` sparse arrays or `Tangent`/`MutableTangent` +wrappers instead of dense arrays or named tuples. `Flux.update!` expects +concrete data, so every tangent node must be materialized before the optimizer +step. + +# Arguments +- `x`: a gradient value — may be a plain array, a `Zygote.OneElement`, a + `ChainRulesCore.Tangent`, or a `ChainRulesCore.MutableTangent`. + +# Returns +- For plain values: returns `x` unchanged. +- For `OneElement`: returns `collect(x)`, a dense array. +- For `Tangent`/`MutableTangent`: returns a `NamedTuple` with recursively + materialized fields. +- For `Base.RefValue` (Zygote's wrapper for tangents of mutated mutable + structs, such as the state-threading policies): unwraps and recurses. +- For plain `NamedTuple`/`Tuple`: recurses so nested wrappers are stripped. +- For `NoTangent`/`ZeroTangent`: returns `nothing`. +""" +_mat(x) = x # plain value — no conversion needed +_mat(x::Zygote.OneElement) = collect(x) # sparse one-hot → dense array function _mat(x::ChainRulesCore.Tangent{<:Any}) - nt = ChainRulesCore.backing(x) - return NamedTuple{keys(nt)}(map(_mat, values(nt))) + nt = ChainRulesCore.backing(x) # extract underlying named tuple + return NamedTuple{keys(nt)}(map(_mat, values(nt))) # recursively materialize each field end function _mat(x::ChainRulesCore.MutableTangent{<:Any}) - nt = ChainRulesCore.backing(x) - return NamedTuple{keys(nt)}(map(_mat, values(nt))) + nt = ChainRulesCore.backing(x) # extract underlying named tuple + return NamedTuple{keys(nt)}(map(_mat, values(nt))) # recursively materialize each field +end +# Structural-zero tangents (non-differentiable fields) map to nothing so +# Flux.update! skips them. +_mat(::ChainRulesCore.NoTangent) = nothing +_mat(::ChainRulesCore.ZeroTangent) = nothing +# Zygote wraps tangents of MUTATED mutable structs (e.g. the state-threading +# policies, whose forward pass stores the new recurrent state via setfield!) in +# Base.RefValue and MutableTangent containers, potentially nested inside plain +# NamedTuples/Tuples. Recurse through those containers so every wrapper is +# stripped before the gradient reaches Flux.update!. +_mat(ref::Base.RefValue) = _mat(ref[]) # unwrap Ref and recurse +_mat(nt::NamedTuple{K}) where {K} = + NamedTuple{K}(map(_mat, values(nt))) # recurse plain named tuples +_mat(t::Tuple) = map(_mat, t) # recurse plain tuples + +""" + materialize_tangent(g) -> Union{Nothing, Any} + +Convert a Zygote gradient `g` into plain Julia arrays and named tuples that +`Flux.update!` can consume. Returns `nothing` when `g` is `nothing` (i.e., no +gradient was produced for that parameter). + +This is the public entry point; internally it delegates to [`_mat`](@ref). + +# Arguments +- `g`: raw gradient returned by `Zygote.gradient`; may be `nothing`. + +# Returns +- `nothing` if `g` is `nothing`. +- A materialized gradient (dense arrays / named tuples) otherwise. + +# Examples +```julia +gs = Zygote.gradient(model) do m + sum(m(x)) end -materialize_tangent(g) = isnothing(g) ? nothing : _mat(g) +grad = materialize_tangent(gs[1]) # NamedTuple or nothing +``` +""" +materialize_tangent(g) = isnothing(g) ? nothing : _mat(g) # guard against nothing gradients -_all_finite_gradient(x::AbstractArray) = all(isfinite, x) -_all_finite_gradient(x::Number) = isfinite(x) -_all_finite_gradient(x::Nothing) = true -_all_finite_gradient(x::NamedTuple) = all(_all_finite_gradient(v) for v in values(x)) -_all_finite_gradient(x::Tuple) = all(_all_finite_gradient(v) for v in x) -_all_finite_gradient(x) = true +""" + _all_finite_gradient(x) -> Bool + +Recursively check that every element of a (possibly nested) gradient structure +is finite (no `NaN` or `±Inf`). + +After BPTT through physics-based dynamics, accumulated Jacobian products can +overflow `Float32` range (> 3.4e38), producing `Inf` or `NaN` values that +would corrupt the Adam optimizer state. This guard prevents +`Flux.update!` from being called with non-finite gradients. + +# Arguments +- `x`: gradient value — may be an `AbstractArray`, `Number`, `Nothing`, + `NamedTuple`, `Tuple`, or any other type. + +# Returns +- `true` if every numeric leaf is finite (or the value is `nothing` / an + unrecognized type that carries no numeric data). +- `false` if any leaf contains `NaN` or `±Inf`. + +# Examples +```julia +_all_finite_gradient([1.0, 2.0]) # true +_all_finite_gradient([1.0, NaN]) # false +_all_finite_gradient((a=[1.0], b=Inf)) # false +_all_finite_gradient(nothing) # true +``` +""" +_all_finite_gradient(x::AbstractArray) = all(isfinite, x) # check every element +_all_finite_gradient(x::Number) = isfinite(x) # scalar check +_all_finite_gradient(x::Nothing) = true # nothing → vacuously finite +_all_finite_gradient(x::NamedTuple) = all(_all_finite_gradient(v) for v in values(x)) # recurse named tuple fields +_all_finite_gradient(x::Tuple) = all(_all_finite_gradient(v) for v in x) # recurse tuple elements +_all_finite_gradient(x) = true # fallback: assume finite for unknown types + +""" + _status_key(status) -> String + +Convert a MadNLP solver status enum value into a safe string key by replacing +non-alphanumeric characters with underscores. Used to build human-readable +diagnostic dictionaries keyed by solver outcome. + +# Arguments +- `status`: a MadNLP status enum (e.g., `MadNLP.SOLVE_SUCCEEDED`). + +# Returns +- A sanitized `String` suitable for use as a dictionary key. + +# Examples +```julia +_status_key(MadNLP.SOLVE_SUCCEEDED) # "SOLVE_SUCCEEDED" +``` +""" +_status_key(status) = replace(string(status), r"[^A-Za-z0-9_]" => "_") # sanitize status to dict-safe key + +""" + _inc_status!(counts::Dict{String, Int}, status) -> Dict{String, Int} + +Increment the counter for the given MadNLP solver `status` in `counts`. +Converts `status` to a string key via [`_status_key`](@ref) before +incrementing. + +# Arguments +- `counts::Dict{String, Int}`: mutable dictionary of status counts. +- `status`: a MadNLP solver status enum. + +# Returns +- The mutated `counts` dictionary. +""" +function _inc_status!(counts::Dict{String, Int}, status) + key = _status_key(status) # convert enum to string key + counts[key] = get(counts, key, 0) + 1 # increment (initialize to 0 if absent) + return counts +end + +""" + _inc_count!(counts::Dict{String, Int}, key::String) -> Dict{String, Int} + +Increment the counter for `key` in the diagnostics dictionary `counts`. +Used to track failure reasons (e.g., `"nonfinite_objective"`) and retry +outcomes during training batches. + +# Arguments +- `counts::Dict{String, Int}`: mutable dictionary of event counts. +- `key::String`: the event identifier to increment. + +# Returns +- The mutated `counts` dictionary. +""" +function _inc_count!(counts::Dict{String, Int}, key::String) + counts[key] = get(counts, key, 0) + 1 # increment (initialize to 0 if absent) + return counts +end + +""" + _adapt_array(x::AbstractVector, ref::AbstractVector) -> AbstractVector + +Move `x` onto the same device (CPU or GPU) as `ref`, allocating a new array +only when the concrete types differ. + +When training runs on GPU, solver outputs (multipliers, states) may be +`CuVector`s while sampled data may arrive as CPU `Vector`s (or vice versa). +This helper ensures type-homogeneous arithmetic by copying `x` into a +`similar` array derived from `ref`. + +# Arguments +- `x::AbstractVector`: the source data to adapt (may be CPU or GPU). +- `ref::AbstractVector`: a reference vector whose concrete type determines the + target device / storage backend. + +# Returns +- `x` itself when `typeof(x) === typeof(ref)` (zero-copy fast path). +- A new array on the same device as `ref`, with the element type of `x` and + the data of `x` copied in. + +# Examples +```julia +using CUDA +cpu_vec = [1.0f0, 2.0f0] +gpu_ref = CUDA.zeros(Float32, 3) +gpu_vec = _adapt_array(cpu_vec, gpu_ref) # CuVector{Float32} +``` +""" +function _adapt_array(x::AbstractVector, ref::AbstractVector) + typeof(x) === typeof(ref) && return x # same type → no copy needed + copyto!(similar(ref, eltype(x), length(x)), x) # allocate on ref's device, copy x into it +end # ── Solve-status check ──────────────────────────────────────────────────────── """ solve_succeeded(result) -> Bool + +Check whether a MadNLP solve result indicates a usable solution. + +MadNLP returns `0.0` objective for failed or infeasible solves, so checking +`isfinite(objective)` alone is not sufficient. This function inspects the +solver status directly. + +# Arguments +- `result`: a MadNLP result object with a `.status` field. + +# Returns +- `true` if `result.status` is `SOLVE_SUCCEEDED` or `SOLVED_TO_ACCEPTABLE_LEVEL`. +- `false` for all other statuses (e.g., `MAXIMUM_ITERATIONS_EXCEEDED`, + `INFEASIBLE_PROBLEM_DETECTED`). + +# Examples +```julia +result = MadNLP.solve!(solver) +if solve_succeeded(result) + @show result.objective +end +``` """ function solve_succeeded(result) - s = result.status - return s == MadNLP.SOLVE_SUCCEEDED || s == MadNLP.SOLVED_TO_ACCEPTABLE_LEVEL + s = result.status # extract MadNLP status enum + return s == MadNLP.SOLVE_SUCCEEDED || s == MadNLP.SOLVED_TO_ACCEPTABLE_LEVEL # accept both convergence levels end +""" + prepare_solve!(de, init_state, w_flat, xhat_flat) + +Hook called after standard parameter updates and before each NLP solve. + +# Arguments +- `de`: deterministic-equivalent problem. +- `init_state`: initial state used for the current sample. +- `w_flat`: flat uncertainty trajectory for the current sample. +- `xhat_flat`: flat target trajectory for the current sample. + +# Returns +- `nothing` by default. + +# Notes +Override this method for problem types that need additional parameter updates, +for example setting a reservoir parameter from `x0` and targets when the +reservoir is not a decision variable. +""" +prepare_solve!(de, init_state, w_flat, xhat_flat) = nothing + # ── Internal: one MadNLP solve with cascade-failure prevention ──────────────── # # After a failed solve the duals (y, zl, zu) are corrupted. Instead of cold- @@ -60,68 +290,256 @@ end # Per-solve iteration budget: MadNLP's cnt.k is CUMULATIVE across calls, so we # reset it before each solve to give each batch a fresh max_iter budget. +""" + _SolverState + +Mutable wrapper around a MadNLP solver that caches the last successful +primal-dual snapshot for warm-start cascade-failure prevention. + +After a failed solve, MadNLP's duals (`y`, `zl`, `zu`) are corrupted. +If the next call uses `reinitialize!()` (warm-start path), it keeps those +corrupted duals and the failure cascades. `_SolverState` stores the +last-good dual values so they can be restored after a failure, breaking +the cascade without paying the cost of a full cold start. + +# Fields +- `solver`: the `MadNLP.MadNLPSolver` instance. +- `last_good_x`: primal snapshot from the last successful solve (CPU or GPU + array), or `nothing` before the first success. +- `last_good_y`: equality dual snapshot, or `nothing`. +- `last_good_zl_vals`: lower-bound dual values snapshot, or `nothing`. +- `last_good_zu_vals`: upper-bound dual values snapshot, or `nothing`. +- `has_fixed_vars::Bool`: `true` when the NLP has fixed variables (via + `MakeParameter`), which requires a fresh solver per solve to avoid stale + KKT factorization state. +""" mutable struct _SolverState - solver - last_good_x # primal snapshot (CPU or GPU array), or nothing - last_good_y # dual snapshot, or nothing - last_good_zl_vals - last_good_zu_vals + solver # MadNLP.MadNLPSolver instance + last_good_x # primal snapshot (CPU or GPU array), or nothing + last_good_y # dual snapshot, or nothing + last_good_zl_vals # lower-bound dual values snapshot, or nothing + last_good_zu_vals # upper-bound dual values snapshot, or nothing + has_fixed_vars::Bool # true when fixed variables exist in the NLP end +""" + _make_solver(nlp, madnlp_kwargs) -> _SolverState + +Construct a [`_SolverState`](@ref) wrapping a fresh `MadNLP.MadNLPSolver`. + +Detects whether the NLP has fixed variables by comparing the solver's internal +variable count against the NLP's variable count. When fixed variables exist +(via `ExaModels.MakeParameter`), the solver cannot be safely reused across +parameter changes, so `has_fixed_vars` is set to `true`. + +# Arguments +- `nlp`: an NLPModels-compatible problem (e.g., `ExaModel`). +- `madnlp_kwargs`: `NamedTuple` of keyword arguments forwarded to + `MadNLP.MadNLPSolver`. + +# Returns +- A fresh [`_SolverState`](@ref) with no cached primal-dual snapshot. + +# Examples +```julia +state = _make_solver(det_equivalent.model, (print_level=0, tol=1e-6)) +``` +""" function _make_solver(nlp, madnlp_kwargs) - solver = MadNLP.MadNLPSolver(nlp; madnlp_kwargs...) - return _SolverState(solver, nothing, nothing, nothing, nothing) + solver = MadNLP.MadNLPSolver(nlp; madnlp_kwargs...) # build MadNLP solver with user options + nvar_solver = length(solver.x.x) # internal (reduced) variable count + nvar_nlp = length(NLPModels.get_x0(nlp)) # NLP-level variable count + has_fixed = nvar_solver != nvar_nlp # mismatch → fixed variables present + return _SolverState(solver, nothing, nothing, nothing, nothing, has_fixed) # no cached duals yet end +""" + _solve!(state::_SolverState, nlp; warmstart::Bool, madnlp_kwargs) + +Solve `nlp` using the MadNLP solver cached in `state`, with cascade-failure +prevention via dual snapshot restore. + +The warm-start logic implements three paths: + +1. **Fixed variables** (`state.has_fixed_vars`): create a fresh solver each + call because MadNLP's KKT factorization becomes stale when `MakeParameter` + changes fixed-variable values between solves. + +2. **Warm start after success**: copy the last-good primal into `x0` and let + `reinitialize!()` keep the cached duals. + +3. **Warm start after failure**: restore the last-good dual snapshot + (`y`, `zl.values`, `zu.values`) and mark the solver as `SOLVE_SUCCEEDED` + so `reinitialize!()` keeps those restored duals rather than the corrupted + ones. If no good snapshot exists, fall back to `INITIAL` (cold start). + +MadNLP's `cnt.k` is cumulative and never reset internally, so we reset it +before each solve to give every call a fresh `max_iter` budget. + +# Arguments +- `state::_SolverState`: solver wrapper with optional cached primal-dual + snapshot. +- `nlp`: the NLPModels-compatible problem to solve. +- `warmstart::Bool`: `true` to reuse duals from prior solves, `false` to + cold-start. +- `madnlp_kwargs`: `NamedTuple` forwarded to `MadNLP.solve!`. + +# Returns +- A MadNLP result object with fields `.status`, `.objective`, + `.multipliers`, `.solution`. + +# Examples +```julia +state = _make_solver(nlp, (print_level=0,)) +result = _solve!(state, nlp; warmstart=true, madnlp_kwargs=(print_level=0,)) +``` +""" function _solve!(state::_SolverState, nlp; warmstart::Bool, madnlp_kwargs) - solver = state.solver + solver = state.solver # cached MadNLP solver instance - # Primal warm-start: seed NLPModel's x0 from last-good primal. + # MadNLP solver reuse with MakeParameter (fixed variables) causes INFEASIBLE + # on subsequent solves even with INITIAL status — stale KKT factorization state. + # Fix: create a fresh solver each time when fixed variables exist. + if state.has_fixed_vars + return MadNLP.madnlp(nlp; madnlp_kwargs...) # one-shot fresh solver + end + + # Normal path (no fixed variables): full warm-start support. if warmstart && state.last_good_x !== nothing - copyto!(NLPModels.get_x0(nlp), state.last_good_x) + copyto!(NLPModels.get_x0(nlp), state.last_good_x) # seed primal with last-good solution end - prev_result = solver.status - prev_failed = (prev_result != MadNLP.INITIAL && - prev_result != MadNLP.SOLVE_SUCCEEDED && + prev_result = solver.status # check previous solve outcome + prev_failed = (prev_result != MadNLP.INITIAL && # any non-success, non-initial status + prev_result != MadNLP.SOLVE_SUCCEEDED && # means the duals may be corrupted prev_result != MadNLP.SOLVED_TO_ACCEPTABLE_LEVEL) if !warmstart - solver.status = MadNLP.INITIAL + solver.status = MadNLP.INITIAL # cold start: reset x, y, zl, zu elseif prev_failed && state.last_good_y !== nothing - solver.y .= state.last_good_y - solver.zl.values .= state.last_good_zl_vals - solver.zu.values .= state.last_good_zu_vals - solver.status = MadNLP.SOLVE_SUCCEEDED + solver.y .= state.last_good_y # restore last-good equality duals + solver.zl.values .= state.last_good_zl_vals # restore last-good lower-bound duals + solver.zu.values .= state.last_good_zu_vals # restore last-good upper-bound duals + solver.status = MadNLP.SOLVE_SUCCEEDED # trick reinitialize!() into warm path elseif prev_failed - solver.status = MadNLP.INITIAL + solver.status = MadNLP.INITIAL # no snapshot available → cold start end - # Reset per-solve iteration budget. - solver.cnt.k = 0 - solver.cnt.acceptable_cnt = 0 - solver.cnt.start_time = time() + # Reset per-solve iteration budget (cnt.k is cumulative in MadNLP). + solver.cnt.k = 0 # reset iteration counter + solver.cnt.acceptable_cnt = 0 # reset acceptable-step counter + solver.cnt.start_time = time() # reset wall-clock timer - res = MadNLP.solve!(solver; madnlp_kwargs...) + res = MadNLP.solve!(solver; madnlp_kwargs...) # run the solver if solve_succeeded(res) - state.last_good_x = copy(solver.x.x) - state.last_good_y = copy(solver.y) - state.last_good_zl_vals = copy(solver.zl.values) - state.last_good_zu_vals = copy(solver.zu.values) + state.last_good_x = copy(solver.x.x) # snapshot primal (GPU-safe copy) + state.last_good_y = copy(solver.y) # snapshot equality duals + state.last_good_zl_vals = copy(solver.zl.values) # snapshot lower-bound duals + state.last_good_zu_vals = copy(solver.zu.values) # snapshot upper-bound duals end return res end +""" + _solve_with_retry!(state::_SolverState, nlp; + warmstart::Bool, madnlp_kwargs, retry_on_failure::Bool) + -> (result, retried::Bool) + +Solve `nlp` via [`_solve!`](@ref), optionally retrying with a fresh cold-start +solver if the first attempt fails or returns a non-finite objective. + +The retry creates a brand-new [`_SolverState`](@ref) (discarding any corrupted +internal state) and solves with `warmstart=false`. This is more expensive than +the dual-restore path in `_solve!` but guarantees a clean factorization. + +# Arguments +- `state::_SolverState`: primary solver state (may have cached duals). +- `nlp`: the NLPModels-compatible problem. +- `warmstart::Bool`: whether the first attempt should warm-start. +- `madnlp_kwargs`: `NamedTuple` forwarded to `MadNLP.solve!`. +- `retry_on_failure::Bool`: if `true`, retry with a fresh solver on failure. + +# Returns +- `result`: the MadNLP result from whichever attempt succeeded (or the retry + result if both failed). +- `retried::Bool`: `true` if the retry path was taken. + +# Examples +```julia +result, retried = _solve_with_retry!( + state, nlp; + warmstart=true, madnlp_kwargs=(print_level=0,), retry_on_failure=true, +) +retried && @warn "solve required retry" +``` +""" +function _solve_with_retry!(state::_SolverState, nlp; warmstart::Bool, madnlp_kwargs, retry_on_failure::Bool) + result = _solve!(state, nlp; warmstart = warmstart, madnlp_kwargs = madnlp_kwargs) # primary attempt + retried = false # track whether retry was needed + if retry_on_failure && (!solve_succeeded(result) || !isfinite(result.objective)) + retry_state = _make_solver(nlp, madnlp_kwargs) # fresh solver, clean factorization + result = _solve!(retry_state, nlp; warmstart = false, madnlp_kwargs = madnlp_kwargs) # cold-start retry + retried = true + if solve_succeeded(result) + state.last_good_x = copy(retry_state.solver.x.x) + state.last_good_y = copy(retry_state.solver.y) + state.last_good_zl_vals = copy(retry_state.solver.zl.values) + state.last_good_zu_vals = copy(retry_state.solver.zu.values) + end + end + return result, retried +end + # ── simulate_tsddr ──────────────────────────────────────────────────────────── """ simulate_tsddr(model, initial_state, det_equivalent, p_x0, p_target, p_uncertainty, - uncertainty_sampler; madnlp_kwargs, warmstart) - -> (objective, lambda) or nothing + uncertainty_sampler; + madnlp_kwargs, warmstart) + -> NamedTuple{(:objective, :lambda)} or nothing + +Perform a single forward pass of the TS-DDR pipeline without a gradient +update: roll out the policy to produce target states, solve the +deterministic-equivalent NLP, and extract the envelope-theorem multipliers. + +The forward pass computes + +```math +\\hat{x}_t = \\pi_\\theta(w_t, \\hat{x}_{t-1}), \\quad t = 1, \\ldots, T, +``` + +then solves ``\\min_z Q(z; \\hat{x}, w, x_0)`` and returns the objective value +and the multipliers ``\\lambda = \\nabla_{\\hat{x}} Q`` from the target +equality constraints. -Single forward pass without a gradient update. +# Arguments +- `model`: Flux policy network (LSTM or MLP). +- `initial_state::AbstractVector`: initial state vector ``x_0``. +- `det_equivalent`: ExaModels NLP with `.core`, `.model`, `.horizon`, + `.target_con_range`. +- `p_x0`: ExaModels parameter handle for the initial state. +- `p_target`: ExaModels parameter handle for policy targets. +- `p_uncertainty`: ExaModels parameter handle for per-stage uncertainty. +- `uncertainty_sampler`: `() -> w_flat` returning a flat vector of length + ``T \\times n_w``. + +# Keywords +- `madnlp_kwargs`: `NamedTuple` forwarded to MadNLP (default `NamedTuple()`). +- `warmstart::Bool`: warm-start MadNLP (default `true`). + +# Returns +- A `NamedTuple` with fields `objective::Float64` and `lambda::Vector{F}`, + or `nothing` if the solve failed or the objective is non-finite. + +# Examples +```julia +result = simulate_tsddr(model, x0, de, p_x0, p_target, p_unc, sampler) +if result !== nothing + @show result.objective +end +``` """ function simulate_tsddr( model, @@ -134,60 +552,131 @@ function simulate_tsddr( madnlp_kwargs = NamedTuple(), warmstart::Bool = true, ) - T = det_equivalent.horizon - F = eltype(initial_state) - nx = length(initial_state) - core = det_equivalent.core - nlp = det_equivalent.model + T = det_equivalent.horizon # number of planning stages + F = eltype(initial_state) # element type (Float32 or Float64) + nx = length(initial_state) # state dimension + core = det_equivalent.core # ExaModels core (for set_parameter!) + nlp = det_equivalent.model # ExaModels NLP model (for MadNLP) - state = _make_solver(nlp, madnlp_kwargs) + state = _make_solver(nlp, madnlp_kwargs) # fresh solver — no warm-start cache - w_flat = uncertainty_sampler() - nw = length(w_flat) ÷ T + # Sample one uncertainty scenario and move to the correct device. + w_flat = uncertainty_sampler() # flat vector of length T * nw_per_stage + nw = length(w_flat) ÷ T # uncertainty dimension per stage + w_dev = _adapt_array(F.(w_flat), initial_state) # move to GPU if initial_state is on GPU - Flux.reset!(model) - xhat_stages = Vector{Vector{F}}(undef, T) - prev = F.(initial_state) + # Roll out the policy to produce target states (outside AD tape). + Flux.reset!(model) # reset LSTM hidden state + xhat_stages = Vector{AbstractVector{F}}(undef, T) # allocate per-stage target storage + prev = initial_state # first policy input is x0 for t in 1:T - wt = F.(w_flat[(t-1)*nw+1 : t*nw]) - xhat_stages[t] = model(vcat(wt, prev)) - prev = xhat_stages[t] + wt = view(w_dev, (t-1)*nw+1 : t*nw) # slice uncertainty for stage t + xhat_stages[t] = model(vcat(wt, prev)) # policy: [w_t; x̂_{t-1}] → x̂_t + prev = xhat_stages[t] # feed x̂_t to next stage end - xhat_flat = vcat(xhat_stages...) + xhat_flat = vcat(xhat_stages...) # flatten targets to a single vector + # Set NLP parameters: initial state, uncertainty, and policy targets. ExaModels.set_parameter!(core, p_x0, initial_state) ExaModels.set_parameter!(core, p_uncertainty, w_flat) - ExaModels.set_parameter!(core, p_target, Float64.(xhat_flat)) + ExaModels.set_parameter!(core, p_target, Float64.(xhat_flat)) # NLP uses Float64 + prepare_solve!(det_equivalent, initial_state, w_flat, xhat_flat) + # Solve the deterministic equivalent (cold start for one-shot simulation). result = _solve!(state, nlp; warmstart = false, madnlp_kwargs = madnlp_kwargs) + # Reject failed or non-finite solves. solve_succeeded(result) || return nothing isfinite(result.objective) || return nothing - λ = result.multipliers[det_equivalent.target_con_range] - return (objective = result.objective, lambda = F.(Array(λ))) + # Extract envelope-theorem multipliers λ = ∇_{x̂} Q. + λ = target_multipliers(det_equivalent, result) + return (objective = result.objective, lambda = F.(λ)) # cast λ to match initial_state eltype end +""" + _rollout_xhat_flat(model, initial_state, w_flat, T::Int, F) -> AbstractVector{F} + +Roll out the policy network over `T` stages and return the concatenated +target trajectory as a single flat vector. + +This is the differentiable inner loop used inside `Zygote.gradient` blocks. +Each stage evaluates + +```math +\\hat{x}_t = \\pi_\\theta([w_t; \\hat{x}_{t-1}]), \\quad t = 1, \\ldots, T, +``` + +and the returned vector is ``[\\hat{x}_1; \\hat{x}_2; \\ldots; \\hat{x}_T]``. + +# Arguments +- `model`: Flux policy (LSTM or MLP). +- `initial_state`: state vector ``x_0`` fed to the first policy call. +- `w_flat`: flat uncertainty vector of length ``T \\times n_w``. +- `T::Int`: number of planning stages. +- `F`: element type (e.g., `Float32`). + +# Returns +- A flat vector of length ``T \\times n_x`` containing all stage targets. +""" function _rollout_xhat_flat(model, initial_state, w_flat, T::Int, F) - nw = length(w_flat) ÷ T - nx = length(initial_state) - Flux.reset!(model) - buf = Zygote.Buffer(zeros(F, nx * T)) - prev = F.(initial_state) + nw = length(w_flat) ÷ T # uncertainty dimension per stage + Flux.reset!(model) # reset LSTM hidden state + prev = F.(initial_state) # cast initial state to element type F + # This runs INSIDE the actor's Zygote closure (critic term), so the flat + # trajectory cannot be built with raw setindex! (Zygote mutation error) nor + # with a shape-growing vcat loop variable (pullback accum mismatch: + # accum(1375, 11) at the first phase-2 gradient). Zygote.Buffer is the + # sanctioned mutation-safe accumulator for exactly this unroll pattern. + nx = length(prev) # state dimension + buf = Zygote.Buffer(prev, nx * T) # AD-safe writable buffer for t in 1:T - wt = F.(w_flat[(t-1)*nw+1 : t*nw]) - xt = model(vcat(wt, prev)) - for i in 1:nx - buf[(t-1)*nx + i] = xt[i] - end - prev = xt + wt = view(w_flat, (t-1)*nw+1 : t*nw) # slice uncertainty for stage t + xt = model(vcat(wt, prev)) # policy forward pass + buf[(t-1)*nx+1 : t*nx] = xt # write stage into buffer + prev = xt # feed target to next stage end - return copy(buf) + return copy(buf) # differentiable flat trajectory end -_has_critic(::NoCriticControlVariate) = false -_has_critic(::AbstractCriticControlVariate) = true +""" + _has_critic(control_variate::AbstractCriticControlVariate) -> Bool + +Return `true` if the control variate wraps an actual critic network, `false` +for the no-op [`NoCriticControlVariate`](@ref). + +# Arguments +- `control_variate`: an [`AbstractCriticControlVariate`](@ref) instance. + +# Returns +- `false` for `NoCriticControlVariate` (recovers the original dual-only update). +- `true` for any concrete critic (e.g., [`ScalarCriticControlVariate`](@ref)). +""" +_has_critic(::NoCriticControlVariate) = false # no-op sentinel → no critic +_has_critic(::AbstractCriticControlVariate) = true # any concrete critic → active + +""" + _validate_critic_training_args(; kwargs...) -> Bool + +Validate critic/control-variate keyword arguments passed to [`train_tsddr`](@ref). + +# Keywords +- `actor_gradient_mode`: must be `:control_variate` or `:surrogate`. +- `critic_cv_weight`: nonnegative control-variate weight. +- `dual_actor_weight`: nonnegative dual-gradient actor weight. +- `critic_actor_weight`: nonnegative critic actor weight. +- `critic_updates_per_batch`: nonnegative number of critic updates. +- `critic_buffer_size`: nonnegative replay-buffer capacity. +- `critic_rollout_samples_per_batch`: nonnegative integer or `nothing`. +- `num_cheap_critic_samples_per_batch`: nonnegative number of extra policy + rollouts. +# Returns +- `true` when all arguments are valid. + +# Throws +- `ErrorException` if any argument is outside its admissible set. +""" function _validate_critic_training_args(; actor_gradient_mode, critic_cv_weight, @@ -214,6 +703,25 @@ function _validate_critic_training_args(; return true end +""" + _resolve_critic_training_target(target, has_critic::Bool) + +Resolve a user-facing critic target configuration to a concrete +`AbstractCriticTrainingTarget`. + +# Arguments +- `target`: critic target object or symbolic alias. +- `has_critic::Bool`: whether critic training is active. + +# Returns +- `DeterministicEquivalentCriticTarget()` when no critic is active or the user + selected deterministic-equivalent critic targets. +- `target` unchanged when it is already an `AbstractCriticTrainingTarget`. + +# Throws +- `ErrorException` when rollout critic training is requested without a + concrete [`RolloutCriticTarget`](@ref) configuration. +""" function _resolve_critic_training_target(target, has_critic::Bool) has_critic || return DeterministicEquivalentCriticTarget() target isa AbstractCriticTrainingTarget && return target @@ -226,6 +734,30 @@ function _resolve_critic_training_target(target, has_critic::Bool) end end +""" + _critic_sample_from_rollout(model, initial_state, target, w_flat, lambda, F, solver_state) + +Build one [`CriticSample`](@ref) by rerunning a solved scenario through +stage-wise rollout. + +# Arguments +- `model`: Flux policy being trained. +- `initial_state`: initial state vector. +- `target::RolloutCriticTarget`: rollout critic-target configuration. +- `w_flat`: uncertainty trajectory from a deterministic-equivalent sample. +- `lambda`: target multipliers from the deterministic-equivalent solve. +- `F`: element type used for critic sample arrays. +- `solver_state`: optional reusable rollout solver state. + +# Returns +- `CriticSample` when rollout succeeds. +- `nothing` when rollout fails. + +# Notes +The rollout objective supplies the critic value target. The deterministic +equivalent multipliers are sliced to the rollout target length and used as the +critic gradient target. +""" function _critic_sample_from_rollout( model, initial_state, @@ -237,11 +769,15 @@ function _critic_sample_from_rollout( ) # Keep both rollout objective variants available; target.objective_value # below selects which one is used as the critic value target. + rollout_len = target.horizon * target.n_uncertainty + length(w_flat) >= rollout_len || + error("rollout critic uncertainty has length $(length(w_flat)); expected at least $rollout_len") + w_rollout = view(w_flat, 1:rollout_len) result = rollout_tsddr( model, initial_state, target.stage_problem, - w_flat; + w_rollout; horizon = target.horizon, n_uncertainty = target.n_uncertainty, set_stage_parameters! = target.set_stage_parameters!, @@ -252,15 +788,42 @@ function _critic_sample_from_rollout( policy_state = target.policy_state, solver_state = solver_state, reuse_solver = target.reuse_solver, + state_bounds = target.state_bounds, + project_state = target.project_state, + retry_on_failure = target.retry_on_failure, ) result === nothing && return nothing objective = target.objective_value === :objective ? result.objective : result.objective_no_target_penalty xhat_flat = F.(vcat(result.target_trajectory...)) - return CriticSample(F.(initial_state), F.(w_flat), xhat_flat, objective, F.(lambda)) + λ_rollout = view(lambda, 1:length(xhat_flat)) + return CriticSample(F.(initial_state), F.(w_rollout), xhat_flat, objective, F.(λ_rollout)) end +""" + _rollout_critic_samples(model, initial_state, target, de_samples, F, max_samples, solver_state) + -> Vector{CriticSample} + +Convert deterministic-equivalent training samples into rollout critic samples. + +# Arguments +- `model`: Flux policy being trained. +- `initial_state`: initial state vector. +- `target::RolloutCriticTarget`: rollout critic-target configuration. +- `de_samples`: deterministic-equivalent samples containing uncertainty and + target multipliers. +- `F`: element type used for critic sample arrays. +- `max_samples`: maximum number of solved scenarios to rerun, or `nothing`. +- `solver_state`: optional reusable rollout solver state. + +# Returns +- `Vector{CriticSample}` containing only successful rollout conversions. + +# Notes +When `max_samples` is smaller than `length(de_samples)`, samples are selected +without replacement using `randperm`. +""" function _rollout_critic_samples( model, initial_state, @@ -298,51 +861,69 @@ end train_tsddr(model, initial_state, det_equivalent, p_x0, p_target, p_uncertainty, uncertainty_sampler; - num_batches, num_train_per_batch, optimizer, - adjust_hyperparameters, record_loss, - madnlp_kwargs, warmstart, - problem_pool) -> model - -TS-DDR policy gradient training. Mirrors `train_multistage` from DecisionRules.jl. - -Arguments: -- `model` : Flux policy (LSTM or MLP) -- `initial_state` : initial state vector -- `det_equivalent` : any ExaModels NLP with fields `.core`, `.model`, - `.horizon`, `.target_con_range` -- `p_x0` : ExaModels parameter for the initial state -- `p_target` : ExaModels parameter for policy targets -- `p_uncertainty` : ExaModels parameter for per-stage uncertainty -- `uncertainty_sampler`: `() -> w_flat` — flat vector of length `T * nw_per_stage`. - For multi-unit problems (e.g., hydro reservoirs) the sampler - should draw one joint scenario index per stage to preserve - spatial correlation; see `sample_scenario` in examples. - -Keyword arguments (mirror `train_multistage`): -- `num_batches` : total gradient steps (default 100) -- `num_train_per_batch` : scenarios averaged per step (default 1) -- `optimizer` : Flux.Optimisers optimizer -- `adjust_hyperparameters` : `(iter, opt_state, n) -> n` -- `record_loss` : `(iter, model, loss, tag) -> Bool`; return `true` to stop -- `madnlp_kwargs` : NamedTuple forwarded to MadNLP -- `warmstart` : warm-start MadNLP between solves (default `true`) -- `problem_pool` : vector of `(de, p_x0, p_target, p_uncertainty)` tuples - for parallel GPU solves; each entry gets its own MadNLP solver - and samples are distributed round-robin across the pool -- `control_variate` : optional `ScalarCriticControlVariate`; default - `NoCriticControlVariate()` recovers the original update -- `critic_training_target` : `RolloutCriticTarget(...)` for rollout-objective - critic fitting, or `DeterministicEquivalentCriticTarget()` - / `:deterministic_equivalent` for DE ablations -- `critic_rollout_samples_per_batch`: number of solved batch scenarios to rerun - through stage-wise rollout for critic targets; - `nothing` uses all successful solved scenarios -- `actor_gradient_mode` : `:control_variate` or `:surrogate` -- `num_cheap_critic_samples_per_batch`: extra policy rollouts used only for - critic actor terms; these do not trigger NLP solves -- `external_critic_samples` : mutable vector; `record_loss` can push - `CriticSample`s (e.g. from `critic_samples_from_evaluation`) - to feed the critic replay buffer without extra solves + num_batches=100, + num_train_per_batch=1, + optimizer, + adjust_hyperparameters, + record_loss, + madnlp_kwargs=NamedTuple(), + warmstart=true, + problem_pool=nothing, + kwargs...) -> model + +Train a TS-DDR policy with open-loop deterministic-equivalent solves. + +The policy rolls out a target trajectory, the ExaModels problem projects that +trajectory onto the feasible set, and target multipliers provide the actor +gradient by the envelope theorem. + +# Arguments +- `model`: Flux policy. +- `initial_state::AbstractVector`: initial state vector. +- `det_equivalent`: ExaModels deterministic-equivalent problem. +- `p_x0`: ExaModels parameter for the initial state. +- `p_target`: ExaModels parameter for policy targets. +- `p_uncertainty`: ExaModels parameter for uncertainty. +- `uncertainty_sampler`: callable returning a flat uncertainty trajectory. + +# Keywords +- `num_batches::Int`: number of gradient steps. +- `num_train_per_batch::Int`: number of scenarios averaged per step. +- `optimizer`: Flux optimizer or optimizer chain. +- `adjust_hyperparameters`: callback `(iter, opt_state, n) -> n`. +- `record_loss`: callback `(iter, model, loss, tag) -> Bool`; return `true` + to stop training. +- `madnlp_kwargs`: keyword arguments forwarded to MadNLP. +- `warmstart::Bool`: warm-start MadNLP between solves. +- `retry_on_failure::Bool`: retry failed solves with a fresh solver state. +- `problem_pool`: optional vector of `(de, p_x0, p_target, p_uncertainty)` + tuples for independent solves. +- `control_variate`: optional critic control variate. +- `actor_gradient_mode::Symbol`: `:control_variate` or `:surrogate`. +- `critic_cv_weight`, `dual_actor_weight`, `critic_actor_weight`: actor loss + weights. +- `critic_updates_per_batch::Int`: critic optimizer steps per batch. +- `critic_buffer_size::Int`: replay-buffer capacity. +- `critic_batch_size`: critic minibatch size, or `nothing` for all samples. +- `critic_training_target`: rollout or deterministic-equivalent critic target. +- `critic_rollout_samples_per_batch`: number of solved samples rerun through + rollout for critic targets; `nothing` uses all successful solved samples. +- `num_cheap_critic_samples_per_batch::Int`: extra policy rollouts used only + for critic actor terms. +- `critic_optimizer`: Flux optimizer for the critic. +- `external_critic_samples`: optional mutable vector of externally produced + `CriticSample`s. +- `batch_diagnostics`: callback `(iter, stats) -> nothing`. +- `reuse_solver::Bool`: force solver reuse when fixed variables have constant + bounds across solves. + +# Returns +- `model`, updated in place. + +# Notes +For multi-unit stochastic processes, `uncertainty_sampler` should preserve +within-stage spatial correlation, for example by drawing one joint scenario +index per stage. """ function train_tsddr( model, @@ -365,6 +946,7 @@ function train_tsddr( end, madnlp_kwargs = NamedTuple(), warmstart::Bool = true, + retry_on_failure::Bool = true, problem_pool = nothing, control_variate::AbstractCriticControlVariate = NoCriticControlVariate(), actor_gradient_mode::Symbol = :control_variate, @@ -379,6 +961,10 @@ function train_tsddr( num_cheap_critic_samples_per_batch::Int = 0, critic_optimizer = Flux.Adam(1f-3), external_critic_samples = nothing, + batch_diagnostics = (iter, stats) -> nothing, + reuse_solver::Bool = false, + worker_devices = nothing, + worker_problem_builder = nothing, ) T = det_equivalent.horizon F = eltype(initial_state) @@ -401,15 +987,38 @@ function train_tsddr( ) # ── Build worker pool ──────────────────────────────────────────────────── - if problem_pool === nothing - _pool = [(det_equivalent, p_x0, p_target, p_uncertainty)] + # Two modes: + # - `worker_problem_builder === nothing` (default): the caller supplies a + # `problem_pool` of already-built DEs (single-device / CPU). + # - `worker_problem_builder = (wi) -> (de, p_x0, p_target, p_uncertainty)`: + # each worker builds its OWN DE INSIDE its task, after binding its GPU. + # Required for multi-GPU: a DE built in the main task and solved from a + # worker task deadlocks on the first cross-task solve (CUDSS/stream/event + # ownership); building in-task keeps DE, solver, stream and events in one + # task/device context. nworkers then comes from `worker_devices`. + _build_in_worker = worker_problem_builder !== nothing + if _build_in_worker + worker_devices !== nothing || + throw(ArgumentError("worker_problem_builder requires worker_devices")) + _pool = nothing + nworkers = length(worker_devices) else - _pool = problem_pool + _pool = problem_pool === nothing ? + [(det_equivalent, p_x0, p_target, p_uncertainty)] : problem_pool + nworkers = length(_pool) + if worker_devices !== nothing + length(worker_devices) == nworkers || + throw(ArgumentError("worker_devices has length $(length(worker_devices)) but there are $nworkers workers")) + end end - nworkers = length(_pool) + _worker_device(wi) = worker_devices === nothing ? nothing : worker_devices[wi] # Single-worker: create solver on main task (no threading needed) - single_state = nworkers == 1 ? _make_solver(_pool[1][1].model, madnlp_kwargs) : nothing + single_state = (nworkers == 1 && !_build_in_worker) ? + _make_solver(_pool[1][1].model, madnlp_kwargs) : nothing + if reuse_solver && single_state !== nothing + single_state.has_fixed_vars = false + end # Multi-worker: persistent worker threads via channels. # Each worker creates its own MadNLP solver on its own thread so that @@ -419,28 +1028,91 @@ function train_tsddr( worker_tasks = Task[] if nworkers > 1 for wi in 1:nworkers - (de, px, pt, pu) = _pool[wi] + _pooled = _build_in_worker ? nothing : _pool[wi] + _builder = worker_problem_builder in_ch = in_channels[wi] out_ch = out_channels[wi] - t = Threads.@spawn begin + _reuse_solver = reuse_solver + _dev = _worker_device(wi) + _wi = wi + t = Threads.@spawn try + # Bind this worker to its GPU (multi-GPU). Must precede DE/solver + # creation so CUDA handles + all CuArray ops on this task target + # `_dev`. Diagnostics go to stderr (flushed) so a hang is + # localizable in the SLURM log even under the WandbLogger. + # The whole body runs under try/catch: a Threads.@spawn task that + # throws dies SILENTLY (exceptions surface only on wait/fetch), so + # without this the main task blocks forever on take!(out_ch) — the + # exact multi-GPU "hang" signature. On error we report loudly and + # close out_ch so the main loop fails fast instead of deadlocking. + println(stderr, "[worker $_wi] task started (dev=$_dev, thread=$(Threads.threadid()))"); flush(stderr) + if _dev !== nothing + CUDA.device!(_dev) + println(stderr, "[worker $_wi] bound to CUDA device $_dev (current=$(CUDA.device()))"); flush(stderr) + end + # Build the DE IN-TASK for multi-GPU (see _build_in_worker note): + # a main-task-built DE deadlocks on the first cross-task solve. + (de, px, pt, pu) = _builder === nothing ? _pooled : _builder(_wi) + _builder === nothing || + (println(stderr, "[worker $_wi] DE built in-task on device $_dev"); flush(stderr)) st = _make_solver(de.model, madnlp_kwargs) + _dev === nothing || (println(stderr, "[worker $_wi] solver ready on device $_dev"); flush(stderr)) + if _reuse_solver + st.has_fixed_vars = false + end while true msg = take!(in_ch) msg === nothing && break (s_idx, init_state, w_flat, xhat_flat) = msg + # Multi-GPU: the main task marshals msg arrays through CPU; + # upload them to THIS worker's device for the solve, but keep + # the CPU w for the reply below — anything sent back must be + # device-neutral (CPU), because the main task consumes it in + # the device-0 gradient (a device-N CuArray there is the + # CUDA-700 illegal access localized by job 10910905). + w_reply = w_flat + if _dev !== nothing + init_state = CUDA.cu(init_state) + w_flat = CUDA.cu(w_flat) + xhat_flat = CUDA.cu(xhat_flat) + end ExaModels.set_parameter!(de.core, px, init_state) ExaModels.set_parameter!(de.core, pu, w_flat) ExaModels.set_parameter!(de.core, pt, Float64.(xhat_flat)) - result = _solve!(st, de.model; warmstart=warmstart, madnlp_kwargs=madnlp_kwargs) - if solve_succeeded(result) && isfinite(result.objective) - λ = result.multipliers[de.target_con_range] + prepare_solve!(de, init_state, w_flat, xhat_flat) + result, retried = _solve_with_retry!( + st, + de.model; + warmstart = warmstart, + madnlp_kwargs = madnlp_kwargs, + retry_on_failure = retry_on_failure, + ) + failure = nothing + if !solve_succeeded(result) + failure = "status_" * _status_key(result.status) + elseif !isfinite(result.objective) + failure = "nonfinite_objective" + else + # Solve succeeded with a finite objective (both negations + # were tested above); only the multipliers remain to check. + λ = target_multipliers(de, result) if all(isfinite, λ) - put!(out_ch, (s_idx, F.(w_flat), F.(Array(λ)), result.objective)) + # Reply with the CPU w (same types the single-GPU + # worker path produces); λ adapts to it → CPU too. + put!(out_ch, (s_idx, F.(w_reply), _adapt_array(F.(λ), w_reply), + result.objective, result.status, nothing, retried)) continue end + failure = "nonfinite_lambda" end - put!(out_ch, (s_idx, nothing, nothing, NaN)) + put!(out_ch, (s_idx, nothing, nothing, NaN, result.status, failure, retried)) end + catch err + # Loud failure + closed channel: the main task's take!(out_ch) + # throws immediately instead of blocking forever on a dead worker. + println(stderr, "[worker $_wi] FATAL: "); showerror(stderr, err, catch_backtrace()); println(stderr); flush(stderr) + close(out_ch) + rethrow() end push!(worker_tasks, t) end @@ -461,24 +1133,36 @@ function train_tsddr( # ── Forward pass: rollout + solve (outside AD tape) ─────────────────── - # Step 1: Roll out policy for all samples (CPU, sequential) - sample_data = Vector{Tuple{Vector{F}, Vector{F}}}(undef, num_train_per_batch) + # Step 1: Roll out policy for all samples + # Precision note: uncertainties are cast to F (typically Float32, the + # policy precision) here, and this F-cast array is later written into + # the Float64 NLP via set_parameter!. The round-trip through Float32 is + # intentional: the NLP must be solved for exactly the targets the policy + # produced from these Float32 inputs, so the resulting λ multipliers + # pair with the same Float32 rollout in the gradient step below + # (train/gradient consistency). Do not "fix" this by keeping w in + # Float64 for the NLP only. + sample_data = Vector{Tuple{AbstractVector{F}, AbstractVector{F}}}(undef, num_train_per_batch) for s in 1:num_train_per_batch w_flat = uncertainty_sampler() nw = length(w_flat) ÷ T + w_dev = _adapt_array(F.(w_flat), initial_state) Flux.reset!(model) - xhat_stages = Vector{Vector{F}}(undef, T) - prev = F.(initial_state) + xhat_stages = Vector{AbstractVector{F}}(undef, T) + prev = initial_state for t in 1:T - wt = F.(w_flat[(t-1)*nw+1 : t*nw]) + wt = view(w_dev, (t-1)*nw+1 : t*nw) xhat_stages[t] = model(vcat(wt, prev)) - prev = xhat_stages[t] + prev = xhat_stages[t] end - sample_data[s] = (F.(w_flat), vcat(xhat_stages...)) + sample_data[s] = (w_dev, vcat(xhat_stages...)) end # Step 2: Solve — parallel across workers if pool provided - solve_ok = Vector{Union{Nothing, Tuple{Vector{F}, Vector{F}, Float64}}}(nothing, num_train_per_batch) + solve_ok = Vector{Union{Nothing, Tuple{AbstractVector{F}, AbstractVector{F}, Float64}}}(nothing, num_train_per_batch) + status_counts = Dict{String, Int}() + failure_counts = Dict{String, Int}() + retry_counts = Dict{String, Int}() if nworkers == 1 (de, px, pt, pu) = _pool[1] @@ -488,12 +1172,30 @@ function train_tsddr( ExaModels.set_parameter!(de.core, px, initial_state) ExaModels.set_parameter!(de.core, pu, w_flat) ExaModels.set_parameter!(de.core, pt, Float64.(xhat_flat)) - result = _solve!(st, de.model; warmstart=warmstart, madnlp_kwargs=madnlp_kwargs) - solve_succeeded(result) || continue - isfinite(result.objective) || continue - λ = result.multipliers[de.target_con_range] - all(isfinite, λ) || continue - solve_ok[s] = (F.(w_flat), F.(Array(λ)), result.objective) + prepare_solve!(de, initial_state, w_flat, xhat_flat) + result, retried = _solve_with_retry!( + st, + de.model; + warmstart = warmstart, + madnlp_kwargs = madnlp_kwargs, + retry_on_failure = retry_on_failure, + ) + retried && _inc_count!(retry_counts, solve_succeeded(result) && isfinite(result.objective) ? "retry_success" : "retry_failure") + _inc_status!(status_counts, result.status) + if !solve_succeeded(result) + _inc_count!(failure_counts, "status_" * _status_key(result.status)) + continue + end + if !isfinite(result.objective) + _inc_count!(failure_counts, "nonfinite_objective") + continue + end + λ = target_multipliers(de, result) + if !all(isfinite, λ) + _inc_count!(failure_counts, "nonfinite_lambda") + continue + end + solve_ok[s] = (F.(w_flat), _adapt_array(F.(λ), initial_state), result.objective) end else for round_start in 1:nworkers:num_train_per_batch @@ -502,19 +1204,47 @@ function train_tsddr( for s in round_start:round_end wi = s - round_start + 1 w_flat, xhat_flat = sample_data[s] - put!(in_channels[wi], (s, initial_state, w_flat, xhat_flat)) + if worker_devices === nothing + put!(in_channels[wi], (s, initial_state, w_flat, xhat_flat)) + else + # Multi-GPU workers run with different current devices. + # Never send a CuArray allocated on device 0 to a worker + # bound to device 1/2; materialize through CPU and let + # the worker copy onto its own device. + put!(in_channels[wi], (s, Array(initial_state), Array(w_flat), Array(xhat_flat))) + end end for wi in 1:round_size - (s_idx, w_out, λ_out, obj_out) = take!(out_channels[wi]) + msg = take!(out_channels[wi]) + if length(msg) == 7 + (s_idx, w_out, λ_out, obj_out, status_out, failure_out, retried_out) = msg + _inc_status!(status_counts, status_out) + failure_out !== nothing && _inc_count!(failure_counts, failure_out) + retried_out && _inc_count!(retry_counts, w_out === nothing ? "retry_failure" : "retry_success") + elseif length(msg) == 6 + (s_idx, w_out, λ_out, obj_out, status_out, failure_out) = msg + _inc_status!(status_counts, status_out) + failure_out !== nothing && _inc_count!(failure_counts, failure_out) + else + (s_idx, w_out, λ_out, obj_out) = msg + end if w_out !== nothing - solve_ok[s_idx] = (w_out, λ_out, obj_out) + # Workers reply device-neutral (CPU) arrays; the actor + # gradient below mixes them with `initial_state`-device + # arrays (vcat/broadcast), so land them on that device + # here — the exact analogue of the single-worker path's + # `_adapt_array(F.(λ), initial_state)`. No-op when the + # types already match (single-GPU pool replies GPU w). + solve_ok[s_idx] = (_adapt_array(w_out, initial_state), + _adapt_array(λ_out, initial_state), + obj_out) end end end end # Step 3: Collect valid results - valid = Vector{Tuple{Vector{F}, Vector{F}}}() + valid = Tuple{AbstractVector{F}, AbstractVector{F}}[] de_samples = CriticSample[] obj_sum = 0.0 for (s, r) in enumerate(solve_ok) @@ -528,6 +1258,13 @@ function train_tsddr( end n_ok = length(valid) mean_obj = n_ok > 0 ? obj_sum / n_ok : NaN + batch_diagnostics(iter, Dict{String, Any}( + "n_ok" => n_ok, + "n_total" => num_train_per_batch, + "status_counts" => copy(status_counts), + "failure_counts" => copy(failure_counts), + "retry_counts" => copy(retry_counts), + )) if has_critic && n_ok > 0 && critic_updates_per_batch > 0 valid_samples = if resolved_critic_training_target isa RolloutCriticTarget @@ -574,18 +1311,18 @@ function train_tsddr( for (w_flat_s, λf) in valid nw = length(w_flat_s) ÷ T Flux.reset!(m) - prev_ad = F.(initial_state) + prev_ad = initial_state for t in 1:T - wt = F.(w_flat_s[(t-1)*nw+1 : t*nw]) + wt = view(w_flat_s, (t-1)*nw+1 : t*nw) xt = m(vcat(wt, prev_ad)) - total = total + sum(λf[(t-1)*nx+1 : t*nx] .* xt) + total = total + sum(view(λf, (t-1)*nx+1 : t*nx) .* xt) prev_ad = xt end end total / F(n_ok) end else - solved_weights = Vector{Tuple{Vector{F}, Vector{F}}}() + solved_weights = Tuple{AbstractVector{F}, AbstractVector{F}}[] for sample in de_samples λf = F.(sample.target_multipliers) if actor_gradient_mode === :control_variate @@ -618,12 +1355,12 @@ function train_tsddr( for (w_flat_s, actor_weight) in solved_weights nw = length(w_flat_s) ÷ T Flux.reset!(m) - prev_ad = F.(initial_state) + prev_ad = initial_state for t in 1:T - wt = F.(w_flat_s[(t-1)*nw+1 : t*nw]) + wt = view(w_flat_s, (t-1)*nw+1 : t*nw) xt = m(vcat(wt, prev_ad)) residual_total = - residual_total + sum(actor_weight[(t-1)*nx+1 : t*nx] .* xt) + residual_total + sum(view(actor_weight, (t-1)*nx+1 : t*nx) .* xt) prev_ad = xt end end @@ -637,7 +1374,7 @@ function train_tsddr( xhat_ad = _rollout_xhat_flat(m, initial_state, w_flat_s, T, F) critic_total = critic_total + critic_value( control_variate, - F.(initial_state), + initial_state, w_flat_s, xhat_ad, ) @@ -659,14 +1396,193 @@ function train_tsddr( end finally - # Shut down worker threads - for ch in in_channels - put!(ch, nothing) + # Shut down worker threads. A worker that already died never drains its + # input channel, so an unconditional put! on a full Channel{Any}(1) + # would block forever; only signal workers that are still running, and + # guard the put! itself against the check-then-put race. + for (i, ch) in enumerate(in_channels) + if !istaskdone(worker_tasks[i]) # skip dead workers (nobody consumes) + try + put!(ch, nothing) # normal shutdown sentinel + catch err + # Worker died between the istaskdone check and the put! + # (or the channel was closed) — nothing left to signal. + @warn "train_tsddr worker $i shutdown signal failed" exception=(err, catch_backtrace()) + end + end end - for t in worker_tasks - wait(t) + for (i, t) in enumerate(worker_tasks) + try + wait(t) # join worker task + catch err + # A failed worker rethrows on wait; log instead of masking the + # original in-flight exception during cleanup. + @warn "train_tsddr worker $i failed" exception=(err, catch_backtrace()) + end end end return model end + +# ── train_tsddr_embedded ───────────────────────────────────────────────────── + +""" + train_tsddr_embedded(model, initial_state, embedded_de, + uncertainty_sampler; kwargs...) -> model + +Train a TS-DDR policy embedded directly in the NLP. + +Unlike [`train_tsddr`](@ref), this function does not roll out targets +externally. The NLP oracle evaluates `model` inline, the solve returns +closed-loop multipliers and realized states, and the actor gradient is computed +from those realized states. + +# Arguments +- `model`: Flux policy captured by the embedded oracle closures. +- `initial_state::AbstractVector`: initial state vector. +- `embedded_de`: embedded deterministic-equivalent problem. +- `uncertainty_sampler`: callable returning a flat uncertainty trajectory. + +# Keywords +- `num_batches::Int`: number of gradient steps. +- `num_train_per_batch::Int`: number of scenarios averaged per step. +- `optimizer`: Flux optimizer or optimizer chain. +- `adjust_hyperparameters`: callback `(iter, opt_state, n) -> n`. +- `record_loss`: callback `(iter, model, loss, tag) -> Bool`; return `true` + to stop training. +- `madnlp_kwargs`: keyword arguments forwarded to MadNLP. +- `warmstart::Bool`: warm-start MadNLP between solves. +- `retry_on_failure::Bool`: retry failed solves with a fresh solver state. +- `get_realized_states`: optional callback `(prob, result) -> x_flat`. +- `batch_diagnostics`: callback `(iter, stats) -> nothing`. + +# Returns +- `model`, updated in place. + +# Notes +The gradient uses +`sum_t dot(lambda_t, pi_theta(w_t, x^*_{t-1}))`, where `x^*` is the realized +state trajectory from the coupled NLP solution. +""" +function train_tsddr_embedded( + model, + initial_state::AbstractVector, + embedded_de, + uncertainty_sampler; + num_batches::Int = 100, + num_train_per_batch::Int = 1, + optimizer = Flux.Optimisers.OptimiserChain( + Flux.Optimisers.ClipGrad(1.0f0), + Flux.Adam(1f-3), + ), + adjust_hyperparameters = (iter, opt_state, n) -> n, + record_loss = (iter, model, loss, tag) -> begin + println("$tag iter=$iter loss=$(round(loss; digits=4))") + return false + end, + madnlp_kwargs = NamedTuple(), + warmstart::Bool = true, + retry_on_failure::Bool = true, + get_realized_states = nothing, + batch_diagnostics = (iter, stats) -> nothing, +) + T = embedded_de.horizon + F = eltype(initial_state) + nx = embedded_de.nx + + _get_states = get_realized_states === nothing ? + (prob, res) -> res.solution[1 : prob.horizon * prob.nx] : + get_realized_states + + state = _make_solver(embedded_de.model, madnlp_kwargs) + opt_state = Flux.setup(optimizer, model) + + for iter in 1:num_batches + num_train_per_batch = adjust_hyperparameters(iter, opt_state, num_train_per_batch) + + valid = Tuple{AbstractVector{F}, AbstractVector{F}, AbstractVector{F}}[] + obj_sum = 0.0 + status_counts = Dict{String, Int}() + failure_counts = Dict{String, Int}() + retry_counts = Dict{String, Int}() + + for s in 1:num_train_per_batch + w_flat = uncertainty_sampler() + + set_x0!(embedded_de, initial_state) + set_uncertainty!(embedded_de, w_flat) + + result, retried = _solve_with_retry!( + state, + embedded_de.model; + warmstart = warmstart, + madnlp_kwargs = madnlp_kwargs, + retry_on_failure = retry_on_failure, + ) + retried && _inc_count!(retry_counts, solve_succeeded(result) && isfinite(result.objective) ? "retry_success" : "retry_failure") + + _inc_status!(status_counts, result.status) + if !solve_succeeded(result) + _inc_count!(failure_counts, "status_" * _status_key(result.status)) + continue + end + if !isfinite(result.objective) + _inc_count!(failure_counts, "nonfinite_objective") + continue + end + + λ = target_multipliers(embedded_de, result) + if !all(isfinite, λ) + _inc_count!(failure_counts, "nonfinite_lambda") + continue + end + + x_sol = _get_states(embedded_de, result) + + λf = _adapt_array(F.(λ), initial_state) + xf = _adapt_array(F.(x_sol), initial_state) + w_dev = _adapt_array(F.(w_flat), initial_state) + push!(valid, (w_dev, λf, xf)) + obj_sum += result.objective + end + + n_ok = length(valid) + mean_obj = n_ok > 0 ? obj_sum / n_ok : NaN + batch_diagnostics(iter, Dict{String, Any}( + "n_ok" => n_ok, + "n_total" => num_train_per_batch, + "status_counts" => copy(status_counts), + "failure_counts" => copy(failure_counts), + "retry_counts" => copy(retry_counts), + )) + + if n_ok > 0 + gs = Zygote.gradient(model) do m + total = zero(F) + for (w_flat_s, λf, x_realized) in valid + nw = length(w_flat_s) ÷ T + Flux.reset!(m) + for t in 1:T + wt = view(w_flat_s, (t-1)*nw+1 : t*nw) + x_prev = (t == 1) ? + initial_state : + view(x_realized, (t-2)*nx+1 : (t-1)*nx) + xt = m(vcat(wt, x_prev)) + total = total + sum(view(λf, (t-1)*nx+1 : t*nx) .* xt) + end + end + total / F(n_ok) + end + + grad = materialize_tangent(gs[1]) + if grad !== nothing && _all_finite_gradient(grad) + Flux.update!(opt_state, model, grad) + end + end + + record_loss(iter, model, mean_obj, "metrics/training_loss") && break + end + + return model +end diff --git a/src/utils.jl b/src/utils.jl index 4ce90ba..208492f 100644 --- a/src/utils.jl +++ b/src/utils.jl @@ -2,25 +2,47 @@ # Small helpers shared across the package. """ - x_index(nx, t, i) + x_index(nx, t, i) -> Int -Linear index for state component `i ∈ 1:nx` at stage `t ∈ 1:T` -when state trajectory is stored as a flat vector of length `T*nx`. +Return the flat-vector index for state component `i` at stage `t`. + +# Arguments +- `nx::Int`: number of state components per stage. +- `t`: one-based stage index. +- `i`: one-based state-component index. + +# Returns +- `Int`: index into a stage-major state trajectory of length `T * nx`. """ @inline x_index(nx::Int, t, i) = (t - 1) * nx + i """ - u_index(nu, t, i) + u_index(nu, t, i) -> Int + +Return the flat-vector index for control component `i` at stage `t`. -Linear index for control component `i ∈ 1:nu` at stage `t ∈ 1:(T-1)` -when controls are stored as a flat vector of length `(T-1)*nu`. +# Arguments +- `nu::Int`: number of control components per stage. +- `t`: one-based stage index. +- `i`: one-based control-component index. + +# Returns +- `Int`: index into a stage-major control trajectory of length `(T - 1) * nu`. """ @inline u_index(nu::Int, t, i) = (t - 1) * nu + i """ - w_index(nw, t, i) + w_index(nw, t, i) -> Int + +Return the flat-vector index for uncertainty component `i` at stage `t`. + +# Arguments +- `nw::Int`: number of uncertainty components per stage. +- `t`: one-based stage index. +- `i`: one-based uncertainty-component index. -Linear index for disturbance component `i ∈ 1:nw` at stage `t ∈ 1:(T-1)` -when disturbances are stored as a flat vector of length `(T-1)*nw`. +# Returns +- `Int`: index into a stage-major uncertainty trajectory of length + `(T - 1) * nw`. """ @inline w_index(nw::Int, t, i) = (t - 1) * nw + i diff --git a/test/runtests.jl b/test/runtests.jl index 857e673..407edc7 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -1,6 +1,8 @@ using Test using DecisionRulesExa +using ExaModels using Flux +using MadNLP using Random using Zygote @@ -24,7 +26,7 @@ using Zygote set_uncertainty!(prob, w) set_targets!(prob, xhat) - res = solve!(prob; tol = 1e-6, max_iter = 200) + res = DecisionRulesExa.solve!(prob; tol = 1e-6, max_iter = 200) n_x = T * nx n_u = (T - 1) * nx @@ -110,6 +112,39 @@ end @test isfinite(critic_loss(hybrid, [sample])) end +@testset "Bounded state policy helper" begin + Random.seed!(21) + lower = Float32[0, 1, -2] + upper = Float32[10, 1, 2] + policy = bounded_state_policy(2, lower, upper, [4]; activation = sigmoid) + + y = policy(Float32[0.2, -0.1, 3, 1, -1]) + @test length(y) == 3 + @test lower[1] <= y[1] <= upper[1] + @test y[2] == lower[2] + @test lower[3] <= y[3] <= upper[3] + @test length(policy.policy.combiner.bias) == 2 + + deep_policy = bounded_state_policy( + 2, + lower, + upper, + [4]; + activation = sigmoid, + combiner_layers = [5, 4], + ) + @test deep_policy.policy.combiner isa Flux.Chain + y_deep = deep_policy(Float32[0.2, -0.1, 3, 1, -1]) + @test length(y_deep) == 3 + @test lower[1] <= y_deep[1] <= upper[1] + @test y_deep[2] == lower[2] + @test lower[3] <= y_deep[3] <= upper[3] + + constant_policy = bounded_state_policy(1, Float32[3, -4], Float32[3, -4], [4]) + @test constant_policy(Float32[0, 99, 100]) == Float32[3, -4] + @test isempty(Flux.trainables(constant_policy)) +end + @testset "Critic and actor update separation" begin Random.seed!(11) critic = Chain(Dense(2 => 1, bias = false)) @@ -183,3 +218,388 @@ end @test materialize_tangent(g_cv).layers[1].weight ≈ materialize_tangent(g_dual).layers[1].weight end + +@testset "EmbeddedDeterministicEquivalentProblem (CPU)" begin + T = 5 + nx = 1 + nw = 1 + + Random.seed!(42) + policy = StateConditionedPolicy(nw, nx, nx, [8]; activation = tanh) + + prob = build_embedded_deterministic_equivalent( + policy; + horizon = T, + nx = nx, + nu = nx, + nw = nw, + backend = nothing, + float_type = Float64, + slack_penalty = 10.0, + u_bounds = (-2.0, 2.0), + ) + + @test prob isa EmbeddedDeterministicEquivalentProblem + @test prob.horizon == T + @test prob.nx == nx + + x0 = [1.0] + w = randn(T * nw) + + set_x0!(prob, x0) + set_uncertainty!(prob, w) + + n_x = T * nx + n_u = (T - 1) * nx + n_var = n_x + n_u + n_x + n_con_initial = nx + n_con_dynamics = (T - 1) * nx + n_con_oracle = n_x + n_con = n_con_initial + n_con_dynamics + n_con_oracle + + res = MadNLP.madnlp(prob.model; tol = 1e-6, max_iter = 500, print_level = MadNLP.ERROR) + @test DecisionRulesExa.solve_succeeded(res) + @test length(res.solution) == n_var + @test length(res.multipliers) == n_con + + λ = target_multipliers(prob, res) + @test length(λ) == n_x + @test all(isfinite, λ) + + x_sol, u_sol, δ_sol = solution_components(prob, res) + @test length(x_sol) == n_x + @test length(u_sol) == n_u + @test length(δ_sol) == n_x + + # Verify oracle constraint satisfaction: x_t + δ_t ≈ π_θ(w_t, x_{t-1}) + Flux.reset!(policy) + for t in 1:T + x_prev = (t == 1) ? Float32.(x0) : Float32.([x_sol[(t-2)*nx+1:(t-1)*nx]...]) + w_t = Float32.([w[(t-1)*nw+1:t*nw]...]) + nn_out = policy(vcat(w_t, x_prev)) + for i in 1:nx + xi = x_sol[(t-1)*nx+i] + di = δ_sol[(t-1)*nx+i] + @test xi + di ≈ Float64(nn_out[i]) atol = 1e-4 + end + end +end + +@testset "Embedded NN gradient (envelope theorem)" begin + T = 4 + nx = 1 + nw = 1 + + Random.seed!(7) + policy = StateConditionedPolicy(nw, nx, nx, [8]; activation = tanh) + + prob = build_embedded_deterministic_equivalent( + policy; + horizon = T, + nx = nx, + nu = nx, + nw = nw, + backend = nothing, + float_type = Float64, + slack_penalty = 10.0, + u_bounds = (-2.0, 2.0), + ) + + x0 = [0.5] + w = randn(T * nw) + + set_x0!(prob, x0) + set_uncertainty!(prob, w) + + res = MadNLP.madnlp(prob.model; tol = 1e-6, max_iter = 500, print_level = MadNLP.ERROR) + @test DecisionRulesExa.solve_succeeded(res) + + λ = target_multipliers(prob, res) + x_sol = res.solution[1 : T * nx] + + # Zygote gradient: ∇_θ Σ_t ⟨λ_t, π_θ(w_t, x*_{t-1})⟩ + gs = Zygote.gradient(policy) do m + total = 0.0f0 + Flux.reset!(m) + for t in 1:T + wt = Float32.([w[(t-1)*nw+1:t*nw]...]) + x_prev = (t == 1) ? + Float32.(x0) : + Float32.([x_sol[(t-2)*nx+1:(t-1)*nx]...]) + xt = m(vcat(wt, x_prev)) + for i in 1:nx + total = total + Float32(λ[(t-1)*nx+i]) * xt[i] + end + end + total + end + + g = materialize_tangent(gs[1]) + @test g !== nothing + @test DecisionRulesExa._all_finite_gradient(g) +end + +@testset "train_tsddr_embedded smoke test" begin + T = 4 + nx = 1 + nw = 1 + + Random.seed!(99) + policy = StateConditionedPolicy(nw, nx, nx, [8]; activation = tanh) + + prob = build_embedded_deterministic_equivalent( + policy; + horizon = T, + nx = nx, + backend = nothing, + slack_penalty = 10.0, + u_bounds = (-2.0, 2.0), + ) + + x0 = Float32[1.0] + losses = Float64[] + + train_tsddr_embedded( + policy, x0, prob, + () -> randn(T * nw); + num_batches = 5, + num_train_per_batch = 2, + madnlp_kwargs = (tol = 1e-6, max_iter = 300, print_level = MadNLP.ERROR), + warmstart = true, + record_loss = (iter, m, loss, tag) -> begin + push!(losses, loss) + return false + end, + ) + + @test length(losses) == 5 + @test all(isfinite, losses) +end + +@testset "rollout_tsddr (CPU)" begin + horizon = 3 + nx = 1 + + # Stage problem: a horizon-2 linear tracking deterministic equivalent used + # as a one-stage projection problem. The realized next state is x_2. + stage_problem = build_linear_tracking_problem( + horizon = 2, + nx = nx, + backend = nothing, + slack_penalty = 10.0, + u_bounds = (-2.0, 2.0), + ) + + # Callback: write (x_{t-1}, w_t, xhat_t) into the stage problem. The stage-1 + # target equals the incoming state (its constraint is slack-absorbed anyway); + # the stage-2 target is the policy target being projected. + set_stage_params! = (prob, state, w_t, target, stage) -> begin + set_x0!(prob, state) + set_uncertainty!(prob, w_t) + set_targets!(prob, vcat(state, target)) + return nothing + end + # Callback: read the realized next state x_2 from the stage solution. + realized = (prob, result) -> begin + x_sol, _, _ = solution_components(prob, result) + return x_sol[end - prob.nx + 1 : end] + end + + Random.seed!(31) + policy = StateConditionedPolicy(1, 1, 1, [4]; activation = tanh) + x0 = Float32[0.5] + w_flat = Float32.(0.1 .* randn(horizon * 1)) + + result = rollout_tsddr( + policy, x0, stage_problem, w_flat; + horizon = horizon, + n_uncertainty = 1, + set_stage_parameters! = set_stage_params!, + realized_state = realized, + madnlp_kwargs = (tol = 1e-6, max_iter = 300, print_level = MadNLP.ERROR), + ) + @test result isa NamedTuple + @test isfinite(result.objective) + @test length(result.state_trajectory) == horizon + 1 + @test length(result.target_trajectory) == horizon + + # The :target feedback mode (policy sees its own previous target) must also run. + result_target = rollout_tsddr( + policy, x0, stage_problem, w_flat; + horizon = horizon, + n_uncertainty = 1, + set_stage_parameters! = set_stage_params!, + realized_state = realized, + policy_state = :target, + madnlp_kwargs = (tol = 1e-6, max_iter = 300, print_level = MadNLP.ERROR), + ) + @test result_target isa NamedTuple + @test isfinite(result_target.objective) + + # A wrong-length uncertainty vector must be rejected before any solve. + @test_throws ArgumentError rollout_tsddr( + policy, x0, stage_problem, Float32[0.1]; + horizon = horizon, + n_uncertainty = 1, + set_stage_parameters! = set_stage_params!, + realized_state = realized, + ) +end + +@testset "train_tsddr open-loop smoke test" begin + T = 4 + nx = 1 + + # train_tsddr writes the full length-T*nw uncertainty sample into + # p_uncertainty via ExaModels.set_parameter!, which enforces an exact size + # match. build_linear_tracking_problem's p_w has length (T-1)*nw (dynamics + # stages only), so this test builds the same linear tracking NLP manually + # with a full-length uncertainty parameter, where the final-stage entry + # does not enter the dynamics. + core = ExaModels.ExaCore(Float64) + x = ExaModels.variable(core, T * nx) + u = ExaModels.variable(core, (T - 1) * nx; lvar = -2.0, uvar = 2.0) + δ = ExaModels.variable(core, T * nx) + p_x0 = ExaModels.parameter(core, zeros(nx)) + p_w = ExaModels.parameter(core, zeros(T * nx)) # full length T*nw + p_target = ExaModels.parameter(core, zeros(T * nx)) + # Stage cost (x_t^2 + u_t^2)/2 plus slack penalty (rho/2)*delta^2, rho = 10. + ExaModels.objective(core, + (x[x_index(nx, t, i)]^2 + u[u_index(nx, t, i)]^2) / 2 + for t in 1:(T - 1), i in 1:nx + ) + ExaModels.objective(core, + 5.0 * δ[x_index(nx, t, i)]^2 + for t in 1:T, i in 1:nx + ) + # Initial condition, dynamics x_{t+1} = x_t + u_t + w_t, then targets LAST. + ExaModels.constraint(core, + x[x_index(nx, 1, i)] - p_x0[i] + for i in 1:nx + ) + ExaModels.constraint(core, + x[x_index(nx, t + 1, i)] - x[x_index(nx, t, i)] - + u[u_index(nx, t, i)] - p_w[w_index(nx, t, i)] + for t in 1:(T - 1), i in 1:nx + ) + ExaModels.constraint(core, + p_target[x_index(nx, t, i)] - x[x_index(nx, t, i)] - δ[x_index(nx, t, i)] + for t in 1:T, i in 1:nx + ) + model = ExaModels.ExaModel(core) + target_start = nx + (T - 1) * nx + 1 + prob = DeterministicEquivalentProblem( + core, model, x, u, δ, + p_x0, p_w, p_target, + nx, nx, nx, T, + target_start:(target_start + T * nx - 1), + ) + + Random.seed!(123) + policy = StateConditionedPolicy(nx, nx, nx, [8]; activation = tanh) + x0 = Float32[1.0] + losses = Float64[] + params_before = _state_vector(policy) + + train_tsddr( + policy, x0, prob, + prob.p_x0, prob.p_target, prob.p_w, + () -> randn(T * nx); + num_batches = 2, + num_train_per_batch = 1, + madnlp_kwargs = (tol = 1e-6, max_iter = 300, print_level = MadNLP.ERROR), + warmstart = true, + record_loss = (iter, m, loss, tag) -> begin + push!(losses, loss) + return false + end, + ) + + @test length(losses) == 2 + @test all(isfinite, losses) + @test _state_vector(policy) != params_before +end + +@testset "StateConditionedPolicy recurrent-state threading" begin + Random.seed!(42) + policy = StateConditionedPolicy(2, 1, 1, [4, 3]; activation = tanh) + x = Float32[0.3, -0.2, 0.5] + + # Memory: the same input twice WITHOUT reset must give different outputs + # (the recurrent state advanced between calls). A memoryless (per-call + # restart) encoder would reproduce the first output exactly. + Flux.reset!(policy) + y1 = policy(x) + y2 = policy(x) + @test y1 != y2 + + # Reset restores the exact initial recurrent state: identical output. + Flux.reset!(policy) + @test policy(x) == y1 + + # Manual LSTMCell recursion with the same weights reproduces the policy's + # stage outputs EXACTLY over a 3-stage open-loop sequence. + ws = [Float32[0.3, -0.2], Float32[0.1, 0.4], Float32[-0.5, 0.2]] + Flux.reset!(policy) + prev = Float32[0.5] + outs = Vector{Vector{Float32}}() + for t in 1:3 + y = policy(vcat(ws[t], prev)) + push!(outs, Float32.(y)) + prev = Float32.(y) + end + + cells = [l.cell for l in policy.encoder.layers] + states = Any[Flux.initialstates(c) for c in cells] + prev = Float32[0.5] + for t in 1:3 + h = ws[t] + for (i, c) in enumerate(cells) + h, states[i] = c(h, states[i]) + end + y = policy.combiner(vcat(h, prev)) + @test Float32.(y) == outs[t] + prev = Float32.(y) + end +end + +@testset "Zygote gradient through threaded 3-stage rollout" begin + Random.seed!(43) + policy = StateConditionedPolicy(2, 1, 1, [4]; activation = tanh) + ws = [Float32[0.3, -0.2], Float32[0.1, 0.4], Float32[-0.5, 0.2]] + x0 = Float32[0.5] + + # Same pattern as the training loops: reset inside the gradient block, + # thread the recurrent state through all stages via the policy forward. + gs = Zygote.gradient(policy) do m + Flux.reset!(m) + total = 0.0f0 + prev = x0 + for t in 1:3 + y = m(vcat(ws[t], prev)) + total = total + sum(y) + prev = y + end + total + end + g = materialize_tangent(gs[1]) + @test g !== nothing + @test DecisionRulesExa._all_finite_gradient(g) + + # Encoder gradients must be finite AND nonzero (the LSTM parameters + # participate in every stage of the threaded rollout). + enc_leaves = Float64[] + function _collect_leaves(x) + if x isa AbstractArray && eltype(x) <: Number + append!(enc_leaves, vec(Float64.(x))) + elseif x isa NamedTuple + foreach(_collect_leaves, values(x)) + elseif x isa Tuple + foreach(_collect_leaves, x) + end + return nothing + end + _collect_leaves(g.encoder) + @test !isempty(enc_leaves) + @test any(!=(0.0), enc_leaves) +end