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..92a8236 100644 --- a/.gitignore +++ b/.gitignore @@ -42,3 +42,13 @@ logs/ # Slurm batch scripts (user-specific, not part of the package) *.sbatch *.sh +examples/HydroPowerModels/results/ +*strong.json + +# Generated evaluation artifacts: per-policy physical audit dumps and result +# shards. They are reproducible from the frozen case plus a checkpoint, they are +# bulky, and they are specific to one run — so they stay out of the package. +# The small reproducibility artifact that DOES belong in it is +# examples/HydroPowerModels/bolivia/case_manifest.json, which is tracked. +examples/**/audit/ +examples/**/results/ 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..b67b5af 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,70 @@ 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. + +The package supports two ways to make strict mode safe: + +- **Embedded strict DE** ([`train_tsddr_embedded`](@ref), + [`build_embedded_deterministic_equivalent`](@ref)) evaluates the policy inside + the NLP against realized states, so the policy always 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. + +The published hydro case study uses the second path; see +[`examples/HydroPowerModels`](examples/HydroPowerModels). + +Do not use strict equality for a generic open-loop target policy. For +unreachable targets, the slack-penalty formulation is the robust fallback. + +The reachable map depends on the incoming state, and that dependence **must be +differentiated**. Declaring the interval endpoints non-differentiable still +produces a gradient and still lowers the loss, while descending a different +direction — measured on the hydro case, 6% of the true magnitude and 48 degrees +off. Check the complete actor gradient against finite differences before +drawing hyperparameter conclusions from it. + +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 +290,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..be45634 --- /dev/null +++ b/examples/BatteryStorageOPF/.gitignore @@ -0,0 +1,5 @@ +# Cases are CONSTRUCTED, never committed. Every artifact under case/ is a pure +# function of the builder in `build_battery_case.jl` plus its recorded seeds, so +# committing it would ship a second, drifting source of truth for the case. +# The manifest hashes belong in the phase record, not in git. +case/ diff --git a/examples/BatteryStorageOPF/Project.toml b/examples/BatteryStorageOPF/Project.toml new file mode 100644 index 0000000..96fe145 --- /dev/null +++ b/examples/BatteryStorageOPF/Project.toml @@ -0,0 +1,43 @@ +[compat] +CUDA = "6" +CUDSS = "0.7, 0.8" +ExaModels = "0.11" +Flux = "0.16" +JLD2 = "0.5, 0.6" +JSON = "0.21, 1" +MadNLP = "0.10" +MadNLPGPU = "0.10" +Optimisers = "0.4" +StableRNGs = "1" +Zygote = "0.7" +julia = "1.11, 1.12" + +[deps] +CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" +CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" +DecisionRulesExa = "7c3e91a4-d8f2-4b6a-9e15-a2c4f7b80d53" +Dates = "ade2ca70-3891-5945-98fb-dc099432e06a" +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" +LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +MadNLP = "2621e9c9-9eb4-46b1-8089-e8c72242dfb6" +MadNLPGPU = "d72a61cc-809d-412f-99be-fd81f4b8a598" +Optimisers = "3bd65402-5787-11e9-1adc-39752487f4e2" +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" +Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" +cuDNN = "02a925ec-e4fe-4b08-9a7e-0d78e3d38ccd" + +[extras] +CUDA_Runtime_jll = "76a88914-d11a-5bdc-97e0-2f5a05c973a2" + +[sources.DecisionRulesExa] +path = "../.." diff --git a/examples/BatteryStorageOPF/README.md b/examples/BatteryStorageOPF/README.md new file mode 100644 index 0000000..6bd050c --- /dev/null +++ b/examples/BatteryStorageOPF/README.md @@ -0,0 +1,425 @@ +# Battery-storage AC-OPF — ExaModels / GPU engine + +This example is the GPU half of the multistage battery-storage study: a +true-ACP, strict-target deterministic equivalent written directly in ExaModels, +the strict reachable policy, and the TS-DDR trainer that drives them. + +The scientific narrative lives in the documentation. This file says how to run +things and what each file is for. + +The CPU half — the PGLib case builder, the PowerModels battery problem +specification and the stock SDDP baseline — lives in +`DecisionRules.jl/examples/BatteryStorageOPF`. The two packages are independent: +neither loads the other. They share the frozen case bytes and two source files +(`battery_case.jl`, `battery_solution_schema.jl`) as copies whose byte identity +is asserted whenever the case is rebuilt there. + +## What is written by hand here, and why + +This is the ONLY manually written network formulation in the project, and it +exists because there is no equally validated PowerModels-to-ExaModels bridge. +Its correctness is not asserted, it is measured: every physical variable is +differenced against the actual `PowerModels.ACPPowerModel` built from the same +frozen case, and the physical residuals of both solutions are recomputed +independently of either engine. + +There is no SOC-WR model here. SDDP does not run through this engine, and TS-DDR +trains and evaluates on true ACP throughout. + +There is exactly ONE formulation: strict. No soft-target, no penalized-target +and no target-deficit variant exists here or anywhere else in the supported +workflow. + +## Files + +| file | role | +|---|---| +| `battery_case.jl` | the frozen case contract, including the FROZEN FINITE DEMAND SUPPORT this engine trains from. **Byte-identical copy in the JuMP package**, where it is built. | +| `battery_solution_schema.jl` | the shared solution schema and the engine-neutral physical residuals. **Byte-identical copy in the JuMP package.** | +| `battery_exa.jl` | the network parse (arbitrary, nonconsecutive component identifiers) and the multistage strict true-ACP deterministic equivalent, its parameter updates, its target multipliers and its solution extraction | +| `battery_reachable_policy.jl` | the two strict policy architectures — recurrent encoder over observed demand, head, and the shared differentiable affine map into the one-stage reachable interval | +| `train_battery_exa_strict.jl` | the single parameterized training entry point, plus the rollout, the panel evaluation, checkpointing, device handling and the study's four method identifiers | +| `portfolio_runner.jl` | the production runner: one preemptible SEGMENT of one long run of `tsddr_nonlinear` or `tsldr_recurrent_linear`, with identity binding, verified checkpoints, resume and a stop protocol | +| `test/runtests.jl` | the consolidated regression suite | +| `battery_portfolio.json` | the frozen PGLib panel manifest. **Byte-identical copy in the JuMP package**, where it is produced. | +| `case//` | the frozen artifacts, mirrored from the JuMP package | + +## The two policy architectures + +Both are strict, both emit an outgoing storage-state target into the same +feasibility layer, and both train through the same dual-gradient path. What +differs is the trainable map, and nothing else. + +| `DR_BAT_ARCH` | encoder | head | raw target is | +|---|---|---|---| +| `tsddr_nonlinear` (default) | `Flux.LSTM` | nonlinear, bounded output, reads `[h_t; e_{t-1}]` | a nonlinear function of the history AND the state | +| `tsldr_recurrent_linear` | `Flux.RNN(·, identity)` | affine, identity output, reads `[h_t; ξ_t]` | an **affine causal** function of the observed history | + +`ξ_t = [context_t; observation_t]` is the stage's clock features +`(sin 2πt/P, cos 2πt/P)` concatenated with the realized per-bus active demand — +the same input both architectures see. + +### What "recurrent linear" means, exactly + +`tsldr_recurrent_linear` is a **structured recurrent parameterization of a +time-series linear decision rule for the storage-state targets**: + +``` +h_t = A h_{t-1} + B ξ_t + b (Flux.RNN with identity activation) +z_t = C h_t + D ξ_t + d (a chain of identity Dense layers) +``` + +Unrolled from `h_0 = 0`, + +``` +z_t = Σ_{k=1..t} C A^{t-k} B ξ_k + D ξ_t + (Σ_{j=0..t-1} C A^j b) + d, +``` + +so the raw target is affine in `ξ_1, …, ξ_t` and depends on nothing later. The +recurrence is a *coefficient family*, not a different function class: it ties the +`T·(T+1)/2` coefficient blocks of a general TSLDR to a shared `(A, B, C, D)`, +which is what keeps the parameter count independent of the horizon. Stage +dependence stays explicit through `ξ_t`'s clock features, in both `B` and `D`. + +The trainable map does **not** read the incoming energy. It cannot: the incoming +energy is the previous stage's squashed target, so a head that read it would make +the raw target a nonlinear function of the history and the name would be false. +The state enters where a decision rule with feasibility restoration puts it — in +the feasibility layer, whose interval endpoints are functions of `e_{t-1}`. + +### The feasibility layer is the same object in both + +``` +ê_t = r̲_t(e_{t-1}) + (r̄_t(e_{t-1}) − r̲_t(e_{t-1})) · s(z_t), s = stretchedsigmoid +``` + +`s` is bounded and boundary-attaining, so every emitted target is reachable **by +construction** and the stage problem's hard target equality is always attainable. +There is no target slack, no penalty and no projection. The nonlinear +architecture applies `s` as its head's own output activation (as it always has); +the linear one may not — that would be a trainable nonlinearity in a map required +to be affine — so it applies `s` in the layer. The composite is the same map, and +the nonlinear architecture's parameters and rollout are bit-identical to what +they were before the second architecture existed. + +### Only the target follows a rule + +In **both** architectures the stage ACP problem optimizes every recourse +variable — generation, the charge/discharge split, voltages, angles and the two +nodal recourse injections. Only the outgoing storage-state target is produced by +a decision rule. This README will not call the stage's dispatch variables linear +decision rules, because they are not. + +### What the suite proves about it + +An activation audit (every function-valued field in the trainable tree is +`identity`, **and** every encoder cell is an `RNNCell` — an `LSTMCell` hides its +gates in its forward pass and carries no activation field); causality (changing a +future atom leaves earlier raw targets bit-identical); history (perturbing each +earlier atom separately moves the last raw target); affinity +`f(αx + (1−α)y) = α f(x) + (1−α) f(y)` in Float64; an explicit hand-unrolling of +the recurrence and its closed form; reachability over `T = 24`; and the actor +gradient against centered finite differences at `T = 4` and `T = 24`. Each has a +**null control** against the nonlinear architecture, which must fail it. + +## Solver accuracy, and what a reported cost is + +Two settings of this engine are load-bearing and neither is a model choice. + +`DEFAULT_SOLVER_OPTIONS` pins `tol = 1e-10` **and** `bound_relax_factor = 0.0`. +MadNLP's default relaxes every variable bound by `1e-8` before solving, so it +converges on a slightly larger feasible set than the model declares and reports +the primal infeasibility of the RELAXED problem. Measured on +`pglib_opf_case1354_pegase`: MadNLP reported `1.18e-12` while the residual +recomputed from its own solution by the shared schema was `2.92e-06` — four +orders above the study's `1e-7` gate. Tightening `tol` does not touch it, because +the solver already believes it has converged. Zeroing the relaxation takes the +residual to `2.11e-12` and ran `5.7×` faster. + +`physical_stage_cost`, from the byte-identical `battery_solution_schema.jl`, is +the only function that may produce a headline cost. This engine parks the two +nodal recourse injections a bound-relaxation BELOW zero; at a recourse price of +1e5–1e6 per pu that is tens of cost units of barrier residue in the raw +objective. The contract projects every element within `1e-6` pu to exactly zero, +marks the solve inadmissible if any element is outside it, and keeps the raw +objective for diagnostics. Both engines run that same code. + +## The frozen PGLib panel + +This engine trains and evaluates on a preregistered panel of canonical PGLib +systems. It cannot construct one: it has no PGLib and no PowerModels dependency +by design, and acquiring a benchmark, placing storage and calibrating a demand +level are the JuMP package's business. What ships here is the panel MANIFEST — a +small, self-hashing JSON file, byte-identical to the JuMP package's copy — +and the case artifacts materialized from it. + +```bash +# in the JuMP package, once per case +julia --project=. battery_portfolio.jl --case pglib_opf_case118_ieee \ + --out /path/to/DecisionRulesExa.jl/examples/BatteryStorageOPF/case + +# here +DR_BAT_CASE_DIR=case/pglib_opf_case118_ieee julia --project=. test/runtests.jl +``` + +The manifest records, per case: the canonical network digest, the storage buses, +the region sizes and demand shares, the calibrated demand level `κ_case`, the +support digest, and the screening/final protocol seeds and digests. The +regression suite reads it with nothing but `JSON` and `SHA`, recomputes its +self-digest, and asserts byte identity against the JuMP package's copy — because +a manifest that had drifted between the two engines would let them evaluate two +different panels while both reported success. + +## Commands + +```bash +# consolidated regression suite (CPU) +julia --project=. test/runtests.jl + +# the same suite on a GPU +DR_BAT_DEVICE=gpu julia --project=. test/runtests.jl + +# a short strict training smoke +DR_BAT_STAGES=4 DR_BAT_EPOCHS=1 DR_BAT_BATCHES=2 DR_BAT_TRAJ=1 \ +DR_BAT_ENCODER=8 DR_BAT_HEAD=12 DR_BAT_EVAL_EVERY=2 DR_BAT_EVAL_COLS=1,2 \ + julia --project=. -t auto train_battery_exa_strict.jl + +# the same, with the recurrent linear decision rule +DR_BAT_ARCH=tsldr_recurrent_linear \ + julia --project=. -t auto train_battery_exa_strict.jl + +# a full strict training stage on a GPU +DR_BAT_DEVICE=gpu julia --project=. -t auto train_battery_exa_strict.jl +``` + +Or through the study's stable method identifiers: + +```julia +include("train_battery_exa_strict.jl") +battery_method(:tsldr_recurrent_linear) # the descriptor and the shared invariants +run_battery_method(:tsldr_recurrent_linear; num_stages = 24) +run_battery_method(:sddp_soc) # refused here, by name: it is the JuMP engine's +``` + +## Environment variables + +One training stage is fully parameterized, which is what will let a declarative +lineage driver replay a published schedule rather than a narrative. + +| variable | meaning | default | +|---|---|---| +| `DR_BAT_CASE_DIR` | frozen case directory | `case/pglib_opf_case14_ieee` | +| `DR_BAT_ARCH` | `tsddr_nonlinear` or `tsldr_recurrent_linear` | `tsddr_nonlinear` | +| `DR_BAT_STAGES` | horizon `T` | 24 | +| `DR_BAT_EPOCHS`, `DR_BAT_BATCHES` | update budget (`epochs × batches` gradient steps) | 2, 5 | +| `DR_BAT_TRAJ` | trajectories per gradient step | 2 | +| `DR_BAT_LR`, `DR_BAT_LR_FINAL` | cosine learning-rate ramp | 1e-3, 1e-4 | +| `DR_BAT_ENCODER`, `DR_BAT_HEAD` | encoder and head widths, comma separated | `64,64`, `128,128` | +| `DR_BAT_EVAL_EVERY`, `DR_BAT_EVAL_COLS` | screening-panel cadence and its protocol columns | 5, `1,2,3,4` | +| `DR_BAT_MAX_RECOURSE` | physical admissibility tolerance, pu | 1e-6 | +| `DR_BAT_SEED` | training seed | 20260804 | +| `DR_BAT_DEVICE` | `cpu` or `gpu` | `cpu` | +| `DR_BAT_CHECKPOINT` | checkpoint path | `battery_policy.jld2` | + +## The demand this engine trains on + +This engine never sees a demand sampler. What it reads is the frozen finite +support in `demand.json`: for every stage, a list of JOINT multiplier vectors +over the case's loads with explicit probabilities, hashed and mirrored +byte-identically from the JuMP package. + +That is not a convenience. Both methods of the study train from finite support — +SDDP enumerates it in its backward pass, TS-DDR samples atom indices from it in +its trajectories — and if each were allowed to discretize a continuous authoring +law on its own, the two would face two different stochastic programs while every +report still said "the same demand process". `support_digest` is recomputed here +on load and checked against the manifest, so "the two engines consumed the same +support" is verified rather than intended. + +Three consequences for this engine: + +- the support is STAGE-DEPENDENT in general (`K_t` may differ across stages), so + a training trajectory draws each stage's atom from that stage's own + probabilities; +- the multiplier is per LOAD, so the realized per-bus demand is the scaled loads + AGGREGATED to the bus, not a bus-level factor — anything else would average + away a regional or per-load structure and silently change the problem; +- the stage clock feature the policy is given uses the period the support + records, and stage indices outside the frozen horizon are an error rather than + a wrap. + +## Generators that exist in some stages and not others + +A case may declare, for any generator, a per-stage AVAILABILITY schedule: a +vector of multipliers under the `stage_availability` key of that generator's row +in `network.json`, applied to `pmin`, `pmax`, `qmin` and `qmax` alike, so an +entry of `0` takes the unit out of service completely — active and reactive — +rather than leaving something that cannot generate but can still hold up a +voltage for free. + +The convention is OPTIONAL and additive: a generator that carries no schedule is +available in every stage, and a case built before the convention existed produces +bit-identical variable bounds today. Because the schedule lives inside +`network.json`, it is covered by the case digest and travels with the case. + +The JuMP package applies it to the parsed network just before PowerModels +instantiates one stage. This engine builds every stage of the horizon in ONE +model, so it applies the multiplier to each stage's generator variable bounds +instead — `build_battery_exa` takes a `stages` keyword naming which CASE stage +each of its `T` model positions is (`1:T` by default, a window such as `[2]` for +a continuation problem solved on its own). Three consequences: + +- the model's SHAPE never depends on the schedule. The unit keeps its variables, + its cost row and its position in every flat array, and only its bounds close; + `gen_status` is deliberately untouched, because PowerModels drops an + out-of-service generator from `ref` and that would change the variable set from + one stage to the next in the JuMP engine. +- the schedule is DATA. It reaches the model through `lvar`/`uvar` and nothing + else — no objective term, no constraint coefficient, no parameter — so it lies + on no automatic-differentiation path, and the trajectory multipliers the + trainer consumes are still exactly the derivative of the solved value. +- a case WITH a schedule may only be solved on the window it was built for. + `assert_stage_window`, called from `strict_solve!`, fails closed rather than + silently solving stage 5 with stage 1's availability; a case without a schedule + accepts every offset exactly as it always did. + +A schedule that is not a non-empty vector, a multiplier that is not finite or +lies outside `[0, 1]`, inconsistent bounds on a scheduled unit, and a stage the +schedule does not cover are all errors at parse or build time. + +## Selection rule + +A checkpoint is written only when a COMPLETE screening-panel evaluation improves +on the best complete evaluation so far. Complete means every panel column +solved AND the worst physical recourse on every column is within +`DR_BAT_MAX_RECOURSE`. Averaging the columns that happened to succeed would +report a policy that does not exist, and a policy that leans on the recourse is +not admissible however cheap it looks. + +The training loss, the screening-panel rollout and an SDDP bound are three +distinct signals and are never compared in absolute level. + +Only the SCREENING protocol is used for selection. The final 500-column protocol +is not opened by anything in this example. + +## What a checkpoint carries + +Schema `battery_storage_opf/checkpoint/3`: the trainable state, the +**architecture**, the optimizer state and the training trajectory. Reachability +metadata is deliberately not restored from it — that belongs to the frozen case, +and a checkpoint that could override a battery rating would let a stale file +silently redefine the problem. + +`load_checkpoint!` refuses three things rather than continuing while reporting +something untrue: a file without the schema tag (it predates the architecture +field and the optimizer state), a file from a different network, and a file from +a different **architecture** — checked by name, before any array is touched, so +it does not rely on two encoders happening to have incompatible weight shapes. + +The optimizer state is saved because a checkpoint that restores only the +parameters does not restore the RUN: Adam's moment estimates are as much of the +optimizer's position as the weights are, and a resumed stage that silently +restarts them takes a different first step than an uninterrupted one would have. + +## The study's four method identifiers + +`BATTERY_METHODS` carries the four the study compares, with the same rows and the +same invariant fields in **both** public engines: + +| identifier | engine | what varies | +|---|---|---| +| `tsddr_nonlinear` | this one | LSTM encoder, nonlinear head | +| `tsldr_recurrent_linear` | this one | affine recurrence, affine head | +| `sddp_soc` | the JuMP engine | `SOCWRConicPowerModel` backward cuts | +| `sddp_dc` | the JuMP engine | `DCPPowerModel` backward cuts | + +Every row declares the same horizon (24), protocol (screening), strict target +semantics, recourse and admissibility rule, cost contract +(`physical_stage_cost`) and comparison path (true ACP on paired protocol +columns), and each suite asserts it. `run_battery_method` runs the two this +engine owns and refuses the other two by name, naming the engine that owns them: +neither package loads the other, by design. + +## Running a long study: `portfolio_runner.jl` + +`train_strict` is one training call in one process. A study run is longer than +any queue reservation and can be killed at any moment, so it is executed as a +sequence of SEGMENTS, each a separate invocation of `portfolio_runner.jl` that +continues the previous one from a verified checkpoint. The runner adds no +science: the policy, the stage model, the gradient, the cost contract and the +screening panel are the same objects this file's other sections describe. + +```bash +julia --project=. portfolio_runner.jl \ + --case-manifest case/pglib_opf_case118_ieee/case_manifest.json \ + --method tsddr_nonlinear \ + --config config.toml \ + --protocol screening.toml \ + --output run/seg001 \ + --resume-from none +``` + +Those six flags are the whole contract; `--run-id`, `--segment`, `--attempt`, +`--stop-file` and `--max-seconds` exist for an automated caller and all default. +To continue, point `--resume-from` at the previous segment's newest checkpoint. +The protocol descriptor is written once per case with + +```julia +include("portfolio_runner.jl") +write_protocol_descriptor("case/pglib_opf_case118_ieee", "screening.toml") +``` + +and a descriptor naming the FINAL protocol is refused, both when writing one and +when a run is launched against one — before any scenario is solved. + +**What makes a resumed run the same run.** The learning rate is +`cosine_lr(i, target_index, …)`, a function of the GLOBAL update index rather +than of a per-segment counter; the scenario sampler's state and the optimizer's +moment estimates are checkpointed and restored exactly; and every coordinate +that defines the run — the case manifest digest, the case content digest, the +method, the config digest, the protocol digest and kind, the horizon, the seed, +the architecture and the common `ACP_BOUND_RELAX_FACTOR` — is hashed into an +identity record that every checkpoint carries and every resume re-derives. A +mismatch on any one of them refuses the resume and names the field. + +**What a segment writes.** `checkpoints/ck_XXXXXXXX.jld2` with a `.meta.toml` +sidecar naming its digest (payload written and hashed first, sidecar second, so +no sidecar can ever vouch for an unfinished file); `history.csv`, +`trajectory.csv` and `evaluation.csv`; `result.toml`; and `identity.toml`. The +stop file is polled between complete updates: on a stop request the current +update finishes, a checkpoint is written and an honest `preempted` result is +recorded. `complete` is reported only when the configured target index was +reached. + +## Devices and precision + +`DR_BAT_DEVICE=gpu` moves the policy with `Flux.gpu`, builds the ExaModels core +on a CUDA backend and selects `MadNLPGPU.CUDSSSolver`. Three failure modes are +checked rather than assumed: + +- `Flux.gpu` is a silent no-op without cuDNN, so `cuDNN` is imported and + `assert_device` verifies that every trainable array and the recurrent state + really are device arrays; +- `MadNLPGPU.CUDSSSolver` is `nothing` unless CUDSS.jl has been loaded, which is + checked before it is passed to the solver; +- the ExaModels model stays in `Float64` on both devices; the policy is + `Float32` for training and can be promoted with `Flux.f64` for + finite-difference work. + +On a cluster whose NVIDIA driver is newer than the runtime CUDA.jl can +auto-select, `CUDA.functional()` returns false with a "JLLs were precompiled +without an NVIDIA driver present" message. Pin the runtime once per environment +with `CUDA.set_runtime_version!(v"12.6")` — this writes a machine-local +`LocalPreferences.toml`, which is not part of the published example. + +## The solver is fresh on every solve + +`solve!` builds a new MadNLP solver each time, deliberately. PGLib cases contain +synchronous condensers whose active-power box is exactly `[0, 0]`, MadNLP's +default `fixed_variable_treatment` removes such variables from its internal +primal vector, and its re-solve path then fails to map a full-length starting +point into the reduced one. The only re-solve configuration that works widens +those boxes by about `1e-8`, which makes this engine's feasible set larger than +the PowerModels model it is validated against. Correctness wins; the model +itself (sparsity pattern, derivative kernels) is still built once and reused, +and a fresh 24-stage solve of the correctness-phase case takes about 0.2 s. diff --git a/examples/BatteryStorageOPF/battery_case.jl b/examples/BatteryStorageOPF/battery_case.jl new file mode 100644 index 0000000..51bec40 --- /dev/null +++ b/examples/BatteryStorageOPF/battery_case.jl @@ -0,0 +1,1658 @@ +# battery_case.jl +# +# Frozen case contract for the multistage battery-storage AC-OPF study. +# +# This file is the SINGLE source of truth for what "the case" is, and it is +# shipped BYTE-IDENTICALLY in both public engines (DecisionRules.jl, the +# JuMP/PowerModels/SDDP engine, and DecisionRulesExa.jl, the ExaModels/GPU +# engine). Neither engine may re-derive a battery parameter, a demand +# realization, or a scenario index on its own: both read them from here, so a +# disagreement between the engines can never be a disagreement about the case. +# +# It therefore depends only on JSON, SHA, StableRNGs and the Julia standard +# library. In particular it does NOT depend on PowerModels, PGLib or +# Distributions: those are needed to BUILD the frozen artifacts (see +# `battery_demand.jl` and `build_battery_case.jl`, which +# exist only in the JuMP engine), never to READ them. +# +# Artifacts of one case live in one directory: +# +# /network.json the parsed PGLib network, per-unit, verbatim +# /batteries.json battery placement and parameters +# /demand.json the FROZEN finite demand support +# /case_manifest.json units, counts, stage duration and SHA-256s +# +# Every number that both engines must agree on is in one of those four files. +# +# THE DEMAND CONTRACT, stated once. +# The authoring sampler (a `Distribution`, a callable, a regional group model — +# see `battery_demand.jl`) is NOT part of the case. What is frozen, hashed and +# mirrored is its FINITE SUPPORT: for every stage t, a list of joint multiplier +# vectors over the case's loads together with their probabilities. Both SDDP and +# TS-DDR train from those bytes and neither is permitted to resample or +# rediscretize the authoring sampler. That is what makes "the two methods faced +# the same stochastic program" a checkable statement rather than an intention. + +using JSON +using SHA +using StableRNGs +using Printf + +# ───────────────────────────────────────────────────────────────────────────── +# Schema tags +# +# Every artifact carries a schema string. A loader that meets an unknown schema +# FAILS rather than guessing, because a silently-shifted field is exactly the +# class of defect that makes two engines solve two different problems. +# +# The demand artifact is at schema 2: schema 1 carried a single scalar +# multiplier per stage, which cannot express a joint per-load realization. +# ───────────────────────────────────────────────────────────────────────────── + +const BATTERY_NETWORK_SCHEMA = "battery_storage_opf/network/1" +const BATTERY_BATTERY_SCHEMA = "battery_storage_opf/batteries/2" +const BATTERY_DEMAND_SCHEMA = "battery_storage_opf/demand/2" +const BATTERY_MANIFEST_SCHEMA = "battery_storage_opf/manifest/3" + +""" + STAGE_AVAILABILITY_KEY + +Name of the optional generator field that carries a per-stage availability +schedule: `gen[STAGE_AVAILABILITY_KEY][t]` is a nonnegative multiplier applied to +that generator's active and reactive limits at stage `t` by +[`apply_stage_availability!`](@ref). + +# Notes +The schedule lives INSIDE the network table rather than beside it in an artifact +of its own, for one reason: the frozen case hashes `network.json`, so a schedule +carried there is covered by the case digest, travels with the case to every +consumer, and cannot drift out of step with the network it describes. A separate +artifact would have needed its own hash, its own read-back check and its own +statement of which generator each row refers to. + +The network schema is unchanged because the field is OPTIONAL and additive: a +generator that does not carry it is available in every stage, so every case built +before this convention existed still means exactly what it meant then. +""" +const STAGE_AVAILABILITY_KEY = "stage_availability" + +# ───────────────────────────────────────────────────────────────────────────── +# Canonical JSON +# +# `JSON.print` iterates a `Dict` in hash order, so writing the same object twice +# from two processes can produce two different byte strings and destroy the +# point of hashing an artifact. The emitter below sorts object keys and prints +# every scalar through a round-tripping representation, which makes the bytes a +# pure function of the value. +# ───────────────────────────────────────────────────────────────────────────── + +""" + canonical_json(value) -> String + +Serialize `value` to JSON whose bytes depend only on the value, not on +dictionary iteration order or on floating-point printing defaults. + +# Arguments +- `value`: any nesting of `AbstractDict{<:AbstractString}`, `AbstractVector`, + `AbstractString`, `Bool`, `Integer`, `AbstractFloat` and `nothing`. + +# Returns +- A `String` holding the canonical JSON text (2-space indentation, object keys + sorted lexicographically by `isless` on the key strings). + +# Notes +Floats are printed with `Base.print`, which emits the shortest decimal literal +that round-trips through `parse(Float64, ·)`. Reading the emitted text back +with `JSON.parsefile` therefore reproduces the original `Float64` bit pattern, +which is what lets the two engines hash and compare the same artifact. + +Non-finite floats are rejected: JSON has no representation for them, and a +silently emitted `NaN` token would be unparseable by a conforming reader. +""" +function canonical_json(value) + io = IOBuffer() + _canonical_json!(io, value, 0) + return String(take!(io)) +end + +# Recursive canonical writer. `depth` is the current indentation level; the +# emitter never depends on the container's iteration order. +function _canonical_json!(io::IO, value, depth::Int) + pad = " "^depth + pad_in = " "^(depth + 1) + if value === nothing + print(io, "null") + elseif value isa Bool + # Checked before Integer: `Bool <: Integer` in Julia. + print(io, value ? "true" : "false") + elseif value isa Integer + print(io, string(value)) + elseif value isa AbstractFloat + isfinite(value) || error("canonical_json: non-finite float $value has no JSON representation") + # Shortest round-tripping decimal; `1.0` stays `1.0` (never `1`), which + # keeps the emitted type distinguishable from an integer on re-read. + print(io, string(Float64(value))) + elseif value isa AbstractString + _canonical_json_string!(io, value) + elseif value isa AbstractDict + isempty(value) && return print(io, "{}") + # Stringify the keys once, then sort: sorting is what makes the bytes + # order-independent, and going through the pair list avoids re-indexing + # the source dictionary with a converted key. + pairs = sort!([(string(k), v) for (k, v) in value]; by = first) + allunique(first.(pairs)) || + error("canonical_json: dictionary has keys that collide once stringified") + print(io, "{\n") + for (i, (k, v)) in enumerate(pairs) + print(io, pad_in) + _canonical_json_string!(io, k) + print(io, ": ") + _canonical_json!(io, v, depth + 1) + print(io, i == length(pairs) ? "\n" : ",\n") + end + print(io, pad, "}") + elseif value isa AbstractVector + isempty(value) && return print(io, "[]") + print(io, "[\n") + for (i, v) in enumerate(value) + print(io, pad_in) + _canonical_json!(io, v, depth + 1) + print(io, i == length(value) ? "\n" : ",\n") + end + print(io, pad, "]") + else + error("canonical_json: unsupported value of type $(typeof(value))") + end + return nothing +end + +# Minimal RFC 8259 string escaping. +function _canonical_json_string!(io::IO, s::AbstractString) + print(io, '"') + for c in s + if c == '"' + print(io, "\\\"") + elseif c == '\\' + print(io, "\\\\") + elseif c == '\n' + print(io, "\\n") + elseif c == '\r' + print(io, "\\r") + elseif c == '\t' + print(io, "\\t") + elseif c < ' ' + print(io, "\\u", lpad(string(UInt16(c); base = 16), 4, '0')) + else + print(io, c) + end + end + print(io, '"') + return nothing +end + +""" + write_canonical_json(path, value) -> String + +Write `canonical_json(value)` to `path` and return the SHA-256 of the bytes +actually written. + +# Arguments +- `path::AbstractString`: destination file. +- `value`: object accepted by [`canonical_json`](@ref). + +# Returns +- Lowercase hexadecimal SHA-256 digest of the file contents. +""" +function write_canonical_json(path::AbstractString, value) + text = canonical_json(value) + mkpath(dirname(path)) + write(path, text) + return bytes2hex(sha256(text)) +end + +""" + sha256_file(path) -> String + +Lowercase hexadecimal SHA-256 digest of the bytes of `path`. +""" +sha256_file(path::AbstractString) = bytes2hex(sha256(read(path))) + +""" + plain(value) + +Recursively rebuild a parsed-JSON tree out of plain `Dict{String,Any}`, +`Vector{Any}` and scalars. + +# Notes +JSON parsers return their own container types (`JSON.Object`, lazily-typed +arrays). Those satisfy the `AbstractDict`/`AbstractVector` interfaces but not the +CONCRETE types that downstream modelling packages assume when they build typed +lookup tables from a network dictionary, which surfaces as a `convert` error +deep inside a library rather than as a data problem. Normalizing once, at the +boundary where the case is read, keeps that class of failure out of every +consumer. +""" +function plain(value) + if value isa AbstractDict + return Dict{String,Any}(string(k) => plain(v) for (k, v) in value) + elseif value isa AbstractString + return String(value) + elseif value isa AbstractVector + return Any[plain(v) for v in value] + else + return value + end +end + +# ───────────────────────────────────────────────────────────────────────────── +# Battery parameters +# ───────────────────────────────────────────────────────────────────────────── + +""" + BatterySpec + +Parameters of one battery, in the per-unit system of the host network. + +# Fields +- `index::Int`: battery identifier. Identifiers are arbitrary positive integers + and need not be consecutive; every engine keys on this value. +- `bus::Int`: identifier of the bus the battery injects into. Again an + arbitrary network identifier, never a positional index. +- `energy_min::Float64`, `energy_max::Float64`: energy bounds ``\\underline e_b`` + and ``\\overline e_b`` in per-unit-hours (pu·h), i.e. per-unit power sustained + for one hour. +- `energy_initial::Float64`: ``e_{b,0}``, the energy carried into stage 1 (pu·h). +- `charge_max::Float64`, `discharge_max::Float64`: ``\\overline p^{ch}_b`` and + ``\\overline p^{dis}_b`` in per-unit power (pu). +- `charge_efficiency::Float64`, `discharge_efficiency::Float64`: + ``\\eta^{ch}_b, \\eta^{dis}_b \\in (0,1]``. +- `self_discharge::Float64`: ``\\alpha_b \\in (0,1]``, the fraction of stored + energy retained across one stage. +- `throughput_cost::Float64`: ``c^{deg}_b``, the degradation price charged on + ``\\Delta t\\,(p^{ch}+p^{dis})``, in objective units per pu·h. + +# Notes +The state transition these fields parameterize is + +```math +e_{b,t} = \\alpha_b e_{b,t-1} + + \\eta^{ch}_b \\Delta t\\, p^{ch}_{b,t} + - \\frac{\\Delta t}{\\eta^{dis}_b} p^{dis}_{b,t}, +``` + +with ``e_{b,t}`` the END-of-stage energy. That convention is fixed here and is +never re-stated with a different meaning anywhere in either engine. +""" +struct BatterySpec + index::Int + bus::Int + energy_min::Float64 + energy_max::Float64 + energy_initial::Float64 + charge_max::Float64 + discharge_max::Float64 + charge_efficiency::Float64 + discharge_efficiency::Float64 + self_discharge::Float64 + throughput_cost::Float64 +end + +""" + reachable_interval(b::BatterySpec, e_prev, Δt) -> (lower, upper) + +One-stage battery-dynamic reachable interval for the outgoing energy. + +# Arguments +- `b::BatterySpec`: battery parameters. +- `e_prev::Real`: incoming energy ``e_{b,t-1}`` (pu·h). +- `Δt::Real`: stage duration in hours. + +# Returns +- `(lower, upper)`: the closed interval + +```math +\\underline r = \\max\\{\\underline e_b,\\; + \\alpha_b e_{t-1} - \\tfrac{\\Delta t}{\\eta^{dis}_b}\\overline p^{dis}_b\\}, +\\qquad +\\overline r = \\min\\{\\overline e_b,\\; + \\alpha_b e_{t-1} + \\eta^{ch}_b \\Delta t\\, \\overline p^{ch}_b\\}. +``` + +# Notes +Every value in `[lower, upper]` is attained by an admissible +``(p^{ch}, p^{dis})`` pair, because the transition is affine and monotone in +each control and the controls' own boxes are intervals containing 0. This is +the map the strict policy squashes its normalized output into; note that BOTH +endpoints depend on `e_prev` with slope ``\\alpha_b`` wherever the energy bound +is not the binding term, which is why a policy that differentiates through this +map must not treat the endpoints as constants. + +The returned interval is nonempty whenever ``\\underline e_b \\le \\alpha_b +e_{t-1} + \\eta^{ch}\\Delta t \\overline p^{ch}`` and ``\\alpha_b e_{t-1} - +\\Delta t \\overline p^{dis}/\\eta^{dis} \\le \\overline e_b``; with +``\\alpha_b = 1`` and ``e_{t-1} \\in [\\underline e_b, \\overline e_b]`` both +hold, so the interval is nonempty by induction along any trajectory the policy +itself generates. +""" +function reachable_interval(b::BatterySpec, e_prev::Real, Δt::Real) + decayed = b.self_discharge * e_prev + lower = max(b.energy_min, decayed - (Δt / b.discharge_efficiency) * b.discharge_max) + upper = min(b.energy_max, decayed + b.charge_efficiency * Δt * b.charge_max) + return lower, upper +end + +""" + dispatch_for_target(b::BatterySpec, e_prev, e_target, Δt) -> (p_ch, p_dis) + +The charge/discharge pair that realizes `e_target` from `e_prev` in one stage. + +# Arguments +- `b::BatterySpec`, `e_prev::Real`, `e_target::Real`, `Δt::Real`. + +# Returns +- `(p_ch, p_dis)`: nonnegative powers (pu) satisfying the state transition + exactly, with at most one of them nonzero. + +# Notes +Writing ``\\delta := e_{target} - \\alpha_b e_{prev}``, the transition +``\\delta = \\eta^{ch}\\Delta t\\,p^{ch} - (\\Delta t/\\eta^{dis})p^{dis}`` +is solved by + +```math +p^{ch} = \\frac{\\max(\\delta, 0)}{\\eta^{ch}\\Delta t}, +\\qquad +p^{dis} = \\frac{\\eta^{dis}\\max(-\\delta, 0)}{\\Delta t}. +``` + +This is the unique solution with `p_ch * p_dis == 0`; it is admissible exactly +when `e_target` lies in [`reachable_interval`](@ref). It is used to CERTIFY +recourse (given a reachable target, exhibit the controls that hit it) and never +to replace an optimizer's choice inside a stage problem. +""" +function dispatch_for_target(b::BatterySpec, e_prev::Real, e_target::Real, Δt::Real) + δ = e_target - b.self_discharge * e_prev + p_ch = max(δ, 0.0) / (b.charge_efficiency * Δt) + p_dis = b.discharge_efficiency * max(-δ, 0.0) / Δt + return p_ch, p_dis +end + +""" + battery_injection(b::BatterySpec, p_ch, p_dis) -> Float64 + +Active power injected into the network, ``p^{bat} = p^{dis} - p^{ch}`` (pu). + +# Notes +The battery operates at unity power factor: ``q^{bat} \\equiv 0``. Discharging +is a positive injection; charging is a negative one. +""" +battery_injection(::BatterySpec, p_ch::Real, p_dis::Real) = float(p_dis - p_ch) + +""" + RecourseCosts + +Prices of the two-sided physical active-power recourse, in objective units per +pu per stage. + +# Fields +- `deficit::Float64`: ``C^{def}``, price of the nonnegative uncapped injection + ``d_{i,t}`` (unserved load, or the active power a charging target needs and + the grid cannot deliver). +- `surplus::Float64`: ``C^{sur}``, price of the nonnegative uncapped sink + ``s_{i,t}`` (active power a discharging target produces and the grid cannot + absorb). + +# Notes +Both prices must sit far above the most expensive generator so that recourse is +never an economic substitute for dispatch; both must be IDENTICAL in the +PowerModels ACP model, the PowerModels SOC-WR model, the Exa ACP model, and in +both SDDP passes. They travel in the frozen case artifact for exactly that +reason: neither engine gets to choose them. + +`d` and `s` are physical operating recourse, not target slack. They appear only +in the nodal ACTIVE balance; they appear in no battery state equation and in no +strict target equality, and there is no target-slack variable anywhere in the +supported formulation. +""" +struct RecourseCosts + deficit::Float64 + surplus::Float64 +end + +# ───────────────────────────────────────────────────────────────────────────── +# The frozen finite demand support +# +# Demand is the study's ONLY uncertainty. For the original PGLib load values +# p^{d,0}_i and q^{d,0}_i, the realized demand of load i at stage t under atom k +# is +# +# p^d_{i,t,k} = h_{i,t} m^{(k)}_{i,t} p^{d,0}_i +# q^d_{i,t,k} = h_{i,t} m^{(k)}_{i,t} q^{d,0}_i +# +# with h a DETERMINISTIC temporal profile and m the uncertain multiplier. The +# SAME multiplier scales the active and the reactive demand, so every +# realization has the case's own power factor: the uncertainty moves how much +# power is consumed, never what kind. +# +# The multiplier is a JOINT VECTOR over loads, not a scalar and not a collection +# of independent draws — an independent-per-load sampler is one way to produce +# such a vector, never the representation itself. +# ───────────────────────────────────────────────────────────────────────────── + +""" + DemandSupport + +The frozen, stage-major finite support of the demand process. + +# Fields +- `stage_hours::Float64`: ``\\Delta t``, the duration of one stage in hours. +- `horizon::Int`: number of stages the support is frozen for. Stage indices + outside `1:horizon` are an error, never silently wrapped. +- `load_ids::Vector{Int}`: LOAD identifiers, sorted ascending. This vector fixes + the order of every multiplier and profile row and is the only definition of + "component `j`" in this artifact. +- `profile::Matrix{Float64}`: ``h_{i,t}``, size `(length(load_ids), horizon)`, + the deterministic temporal profile. +- `atoms::Vector{Matrix{Float64}}`: `atoms[t]` has size + `(length(load_ids), K_t)`; column `k` is the joint multiplier vector + ``m^{(k)}_{\\cdot,t}``. +- `probabilities::Vector{Vector{Float64}}`: `probabilities[t]` has length + `K_t` and sums to 1. +- `protocol_seed::Int`: seed of the `StableRNG` that generates evaluation + scenario index matrices. +- `source::Dict{String,Any}`: a description of the AUTHORING sampler and of the + discretization that produced these atoms. Documentation, not data: nothing + reads it to build a model. It exists so a frozen support can be traced back to + the sampler it came from. + +# Notes +The support is stage-dependent by construction (`K_t` may differ across stages) +and stagewise independent: an atom index at stage `t` carries no information +about stage `t+1`. That is what both SDDP's backward enumeration and TS-DDR's +trajectory sampling assume, and it is enforced by the representation rather than +by a comment. +""" +struct DemandSupport + stage_hours::Float64 + horizon::Int + load_ids::Vector{Int} + profile::Matrix{Float64} + atoms::Vector{Matrix{Float64}} + probabilities::Vector{Vector{Float64}} + protocol_seed::Int + source::Dict{String,Any} +end + +"Number of loads the support is defined over." +num_loads(s::DemandSupport) = length(s.load_ids) + +"Number of stages the support is frozen for." +horizon(s::DemandSupport) = s.horizon + +""" + profile_period(s::DemandSupport) -> Int + +The cycle length the deterministic profile repeats on, in stages. + +# Notes +Recorded by the freezing operation and used for exactly one purpose: as the +period of the ``(\\sin, \\cos)`` clock feature a policy is given, so that the +position in the daily cycle is encoded without the discontinuity a raw stage +index would introduce at midnight. It is DETERMINISTIC information — knowing the +clock is not knowing the future demand — and it never enters a stage problem. + +Falls back to the frozen horizon when a support was written without one, which +degrades the feature to "position in the horizon" rather than silently claiming +a 24-stage cycle a case may not have. +""" +profile_period(s::DemandSupport) = Int(get(s.source, "profile_period", s.horizon)) + +""" + num_atoms(s::DemandSupport, t) -> Int + +Size ``K_t`` of the finite support at stage `t`. +""" +function num_atoms(s::DemandSupport, t::Integer) + _check_stage(s, t) + return length(s.probabilities[t]) +end + +""" + atom_probabilities(s::DemandSupport, t) -> Vector{Float64} + +The probabilities ``(p_{t,1},\\ldots,p_{t,K_t})`` of stage `t`'s atoms. +""" +function atom_probabilities(s::DemandSupport, t::Integer) + _check_stage(s, t) + return s.probabilities[t] +end + +""" + demand_multipliers(s::DemandSupport, t, atom) -> Vector{Float64} + +The TOTAL per-load multiplier ``h_{i,t}\\,m^{(atom)}_{i,t}`` at stage `t`, in +`load_ids` order. + +# Notes +This is the only place the deterministic profile and the uncertain multiplier are +combined, so the two can never be applied twice or in the wrong order anywhere +downstream. +""" +function demand_multipliers(s::DemandSupport, t::Integer, atom::Integer) + _check_stage(s, t) + K = num_atoms(s, t) + 1 <= atom <= K || + throw(ArgumentError("atom index $atom outside 1:$K at stage $t")) + return @views s.profile[:, t] .* s.atoms[t][:, atom] +end + +# Fail closed on a stage index outside the frozen window. Silently wrapping (as +# a cyclic profile would) is how a horizon change becomes an undetected change +# of problem. +function _check_stage(s::DemandSupport, t::Integer) + 1 <= t <= s.horizon || + throw(ArgumentError("stage $t outside the frozen horizon 1:$(s.horizon)")) + return nothing +end + +""" + support_digest(s::DemandSupport) -> String + +SHA-256 of the frozen support, in a fixed textual encoding. + +# Notes +This digest is what makes "SDDP and TS-DDR consumed the same demand support" a +verifiable claim: both engines recompute it from the bytes they loaded and it is +recorded in the manifest. It covers the stage duration, the horizon, the load +order, the profile, every atom and every probability — that is, everything a +stage problem's demand depends on — and deliberately NOT the `source` +description, which is prose about how the atoms were authored and must not be +able to change the identity of a support. +""" +function support_digest(s::DemandSupport) + io = IOBuffer() + println(io, "battery_storage_opf/support/2") + println(io, s.stage_hours, " ", s.horizon, " ", num_loads(s), " ", s.protocol_seed) + println(io, join(s.load_ids, ",")) + for t in 1:s.horizon + println(io, "t", t, " ", num_atoms(s, t)) + println(io, join((string(x) for x in @views s.profile[:, t]), ",")) + for k in 1:num_atoms(s, t) + println(io, string(s.probabilities[t][k]), " ", + join((string(x) for x in @views s.atoms[t][:, k]), ",")) + end + end + return bytes2hex(sha256(take!(io))) +end + +""" + scenario_index_matrix(s::DemandSupport, num_stages, num_scenarios; + seed=nothing, exclude=nothing) -> Matrix{Int} + +A paired evaluation protocol, reproduced by construction rather than stored. + +# Arguments +- `s::DemandSupport`: supplies the default seed and the per-stage support sizes. +- `num_stages::Integer`, `num_scenarios::Integer`: shape of the protocol. + +# Keywords +- `seed`: `nothing` for the support's own `protocol_seed` — which is the FINAL + protocol's seed — or another integer for an INDEPENDENT protocol. A study needs + at least two: a small screening protocol it may look at while choosing a case + and selecting checkpoints, and a final one no policy was ever selected on. + Taking the screening set as a prefix of the final one would make the final + protocol not fresh, which is the whole property it exists to have. +- `exclude`: an iterable of length-`num_stages` integer columns this protocol may + not contain. Passing the FINAL protocol's columns here is what makes a + screening protocol disjoint from it BY CONSTRUCTION rather than by the + probabilistic argument that a collision is unlikely — see the notes. + +# Returns +- `Matrix{Int}` of size `(num_stages, num_scenarios)`; entry `[t, s]` is the + atom index realized at stage `t` of paired column `s`. + +# Notes +Drawn from `StableRNG(protocol_seed)`, whose stream is fixed across Julia +versions and platforms, so both engines regenerate the identical matrix and only +its SHA-256 needs to be recorded in the manifest. Scenario columns are global +and immutable: column `s` means the same demand path to every policy and to +every shard of an evaluation. + +Draw ORDER is stage-major (all scenarios of stage 1, then all of stage 2, …). +Because each stage's support size ``K_t`` may differ, a scenario-major order +would make the stream position depend on the horizon; stage-major keeps a +protocol of `num_scenarios` columns a prefix of a protocol of more columns only +within a stage, which is the property shard boundaries rely on. + +The exclusion is applied as a REPAIR after that stage-major draw, never as a +per-draw filter, precisely so the stage-major property survives it: the matrix is +drawn exactly as it would have been without `exclude`, then any column that is +banned or that repeats an earlier column of this same matrix is redrawn — in +ascending column order, from the continuation of the same stream, retrying until +the column is admissible. On a support with more paths than columns nothing is +ever redrawn and the matrix is bit-identical to the unexcluded one; the repair +exists so that "screening and final share no scenario" is a structural fact on +a small support too, where a collision is not merely unlikely but certain. +""" +function scenario_index_matrix(s::DemandSupport, num_stages::Integer, num_scenarios::Integer; + seed = nothing, exclude = nothing) + num_stages >= 1 || throw(ArgumentError("num_stages must be positive")) + num_scenarios >= 1 || throw(ArgumentError("num_scenarios must be positive")) + num_stages <= s.horizon || + throw(ArgumentError("protocol asks for $num_stages stages but the support is frozen for $(s.horizon)")) + rng = StableRNG(seed === nothing ? s.protocol_seed : Int(seed)) + m = Matrix{Int}(undef, num_stages, num_scenarios) + for t in 1:num_stages + K = num_atoms(s, t) + for c in 1:num_scenarios + m[t, c] = rand(rng, 1:K) + end + end + exclude === nothing && return m + + # The banned set: the columns the caller forbids, plus — as they are + # accepted — the columns of this protocol itself, so a repaired protocol + # never contains the same scenario twice either. + banned = Set{Vector{Int}}() + for col in exclude + v = Int.(collect(col)) + length(v) == num_stages || + throw(ArgumentError("excluded column has $(length(v)) stages, expected $num_stages")) + push!(banned, v) + end + # The support has ∏_t K_t distinct paths; asking for more admissible columns + # than exist is a specification error, not something to discover by looping. + capacity = prod(BigInt(num_atoms(s, t)) for t in 1:num_stages) + capacity >= length(banned) + num_scenarios || + throw(ArgumentError("the support has $capacity distinct $num_stages-stage paths, " * + "which cannot supply $num_scenarios columns disjoint from " * + "$(length(banned)) excluded ones")) + for c in 1:num_scenarios + col = Int[m[t, c] for t in 1:num_stages] + while col in banned + for t in 1:num_stages + col[t] = rand(rng, 1:num_atoms(s, t)) + end + end + for t in 1:num_stages + m[t, c] = col[t] + end + push!(banned, col) + end + return m +end + +""" + protocol_columns(m::AbstractMatrix{<:Integer}) -> Vector{Vector{Int}} + +The columns of a protocol index matrix, in the form +[`scenario_index_matrix`](@ref) accepts as `exclude`. +""" +protocol_columns(m::AbstractMatrix{<:Integer}) = + [Int[m[t, c] for t in 1:size(m, 1)] for c in 1:size(m, 2)] + +""" + protocol_digest(s::DemandSupport, num_stages, num_scenarios; + seed=nothing, exclude=nothing) -> String + +SHA-256 of the protocol index matrix, in a fixed textual encoding. + +# Notes +The digest, not the matrix, is what the manifest stores. Both engines recompute +the matrix from the seed and must obtain this digest; a mismatch means the two +engines are not evaluating the same scenarios and no comparison between them is +meaningful. + +The digest is of the MATRIX, so it says nothing about how the matrix was +repaired: two calls that produce the same columns hash the same whether or not an +exclusion set was in force. What records the exclusion is the manifest field that +names it, which is also what a reader needs in order to regenerate the matrix. +""" +function protocol_digest(s::DemandSupport, num_stages::Integer, num_scenarios::Integer; + seed = nothing, exclude = nothing) + m = scenario_index_matrix(s, num_stages, num_scenarios; seed = seed, exclude = exclude) + io = IOBuffer() + println(io, "battery_storage_opf/protocol/2") + println(io, num_stages, " ", num_scenarios, " ", + seed === nothing ? s.protocol_seed : Int(seed)) + println(io, join((num_atoms(s, t) for t in 1:num_stages), ",")) + for t in 1:num_stages + println(io, join(view(m, t, :), ",")) + end + return bytes2hex(sha256(take!(io))) +end + +""" + validate_support(s::DemandSupport) -> Nothing + +Fail closed on every property the rest of the study assumes of a frozen support. + +# Notes +Each check corresponds to a way two engines could end up solving different +problems while both reporting success: a probability vector that does not +normalize silently reweights an SDDP backward pass; a negative or non-finite +multiplier produces a load the network was never meant to serve; a load order +that is not sorted-unique makes "component `j`" mean two different things in two +engines. +""" +function validate_support(s::DemandSupport) + s.stage_hours > 0 || error("stage_hours must be positive, got $(s.stage_hours)") + s.horizon >= 1 || error("horizon must be at least 1, got $(s.horizon)") + n = num_loads(s) + n >= 1 || error("a demand support must cover at least one load") + issorted(s.load_ids) && allunique(s.load_ids) || + error("load_ids must be sorted and unique; got $(s.load_ids)") + size(s.profile) == (n, s.horizon) || + error("profile must be $(n)×$(s.horizon), got $(size(s.profile))") + all(isfinite, s.profile) || error("profile has a non-finite entry") + all(>=(0), s.profile) || error("profile has a negative entry") + length(s.atoms) == s.horizon || + error("support has $(length(s.atoms)) stages of atoms but horizon $(s.horizon)") + length(s.probabilities) == s.horizon || + error("support has $(length(s.probabilities)) stages of probabilities but horizon $(s.horizon)") + for t in 1:s.horizon + A = s.atoms[t] + p = s.probabilities[t] + size(A, 1) == n || + error("stage $t atoms have $(size(A, 1)) rows but the support covers $n loads") + size(A, 2) == length(p) || + error("stage $t has $(size(A, 2)) atoms but $(length(p)) probabilities") + length(p) >= 1 || error("stage $t has an empty support") + all(isfinite, A) || error("stage $t has a non-finite multiplier") + all(>=(0), A) || error("stage $t has a negative multiplier") + all(>(0), p) || error("stage $t has a non-positive probability") + isapprox(sum(p), 1.0; atol = 1e-12) || + error("stage $t probabilities sum to $(sum(p)), not 1") + end + return nothing +end + +# ───────────────────────────────────────────────────────────────────────────── +# Battery placement +# +# Placement is authoring-side, but it lives here because the manifest must be +# able to record exactly how a fleet was chosen, and because the eligibility and +# validity rules are properties of the case contract rather than of a script. +# ───────────────────────────────────────────────────────────────────────────── + +""" + PlacementStrategy + +How the buses hosting batteries are chosen. Concrete strategies: +[`ExplicitPlacement`](@ref), [`SampledPlacement`](@ref), +[`CallablePlacement`](@ref). + +# Notes +Every strategy returns bus IDENTIFIERS, never positions, and every strategy is +reproducible from the data recorded in the manifest alone. +""" +abstract type PlacementStrategy end + +""" + ExplicitPlacement(buses) + +Place batteries at the given bus identifiers, in ascending order. + +# Notes +`count` is not consulted: the list IS the fleet size. Duplicates are rejected +rather than deduplicated, because a repeated identifier is far more likely to be +a typo than a request for two batteries at one bus (which is expressed by giving +two `BatterySpec`s at the same bus instead). +""" +struct ExplicitPlacement <: PlacementStrategy + buses::Vector{Int} +end + +ExplicitPlacement(buses) = ExplicitPlacement(sort!(collect(Int.(buses)))) + +""" + SampledPlacement(count; seed, weight=nothing) + +Draw `count` distinct eligible buses without replacement. + +# Fields +- `count::Int`: fleet size. +- `seed::Int`: seed of the `StableRNG` driving the draw. +- `weight`: `nothing` for a uniform draw, or a callable `bus -> Float64` + returning a nonnegative sampling weight (e.g. nominal demand at the bus). + +# Notes +Without replacement means a bus drawn once is removed from the pool, so a +weighted draw is a successive-sampling scheme rather than `count` independent +draws. The candidate pool is SORTED before the first draw, which is what makes +the result independent of dictionary iteration order. +""" +struct SampledPlacement <: PlacementStrategy + count::Int + seed::Int + weight::Any +end + +SampledPlacement(count::Integer; seed::Integer, weight = nothing) = + SampledPlacement(Int(count), Int(seed), weight) + +""" + CallablePlacement(f; name="callable") + +Place batteries at `f(candidates, meta)`, where `candidates` is the sorted vector +of eligible bus identifiers and `meta` is the placement metadata named tuple. + +# Notes +The escape hatch for a placement rule the study does not anticipate — a +graph-theoretic centrality, an optimization, a hand-drawn map. Whatever it +returns is validated exactly as any other strategy's output, and `name` is what +the manifest records in place of a rule it cannot serialize. +""" +struct CallablePlacement <: PlacementStrategy + f::Any + name::String +end + +CallablePlacement(f; name::AbstractString = "callable") = CallablePlacement(f, String(name)) + +""" + load_buses(network) -> Vector{Int} + +Sorted identifiers of buses hosting at least one in-service load. + +# Notes +The default eligible set. A battery at a bus that neither consumes nor generates +is a pure network-support device, which is a different study; restricting to load +buses keeps a randomly placed fleet physically interpretable on any PGLib case. +""" +function load_buses(network::AbstractDict) + out = Set{Int}() + for (_, load) in network["load"] + Int(get(load, "status", 1)) == 0 && continue + push!(out, Int(load["load_bus"])) + end + return sort!(collect(out)) +end + +""" + nominal_load_at_bus(network) -> Dict{Int,Float64} + +Nominal in-service active demand aggregated per bus identifier (pu). +""" +function nominal_load_at_bus(network::AbstractDict) + out = Dict{Int,Float64}() + for (_, load) in network["load"] + Int(get(load, "status", 1)) == 0 && continue + bus = Int(load["load_bus"]) + out[bus] = get(out, bus, 0.0) + Float64(load["pd"]) + end + return out +end + +""" + eligible_buses(network; eligible=nothing) -> Vector{Int} + +The sorted candidate set a sampling placement draws from. + +# Keywords +- `eligible`: `nothing` for the default (in-service load buses), an iterable of + bus identifiers, or a predicate `bus_dict -> Bool` applied to each bus entry of + the network. + +# Notes +Whatever the source, the returned buses are checked to exist, to be in service +and to be connected — a bus with no incident in-service branch cannot host a +battery that participates in the study, and PGLib cases do contain isolated +buses. +""" +function eligible_buses(network::AbstractDict; eligible = nothing) + ids = Set(Int(b["index"]) for (_, b) in network["bus"]) + candidates = if eligible === nothing + load_buses(network) + elseif eligible isa Function + sort!([Int(b["index"]) for (_, b) in network["bus"] if eligible(b)]) + else + sort!(collect(Int.(eligible))) + end + allunique(candidates) || error("eligible bus set contains duplicates") + in_service = Set(Int(b["index"]) for (_, b) in network["bus"] + if Int(get(b, "bus_type", 1)) != 4) + connected = Set{Int}() + for (_, br) in network["branch"] + Int(get(br, "br_status", 1)) == 0 && continue + push!(connected, Int(br["f_bus"])) + push!(connected, Int(br["t_bus"])) + end + for b in candidates + b in ids || error("bus $b is not in the network") + b in in_service || error("bus $b is out of service (bus_type 4)") + b in connected || error("bus $b has no in-service branch and is disconnected") + end + isempty(candidates) && error("no eligible bus remains after filtering") + return candidates +end + +""" + select_battery_buses(network, strategy; eligible=nothing) -> (buses, record) + +Apply a [`PlacementStrategy`](@ref) and return both the chosen buses and the +manifest record describing how they were chosen. + +# Returns +- `buses::Vector{Int}`: sorted, distinct, validated bus identifiers. +- `record::Dict{String,Any}`: strategy name, seed, eligible set, weights and the + selection, in a form the manifest can serialize verbatim. + +# Notes +The eligible set is recorded in FULL, not summarized. "Three buses were drawn +from the load buses" is not reproducible if a later revision of the case adds a +load; the actual pool that was drawn from is. +""" +function select_battery_buses(network::AbstractDict, strategy::PlacementStrategy; + eligible = nothing) + candidates = eligible_buses(network; eligible = eligible) + record = Dict{String,Any}("eligible" => candidates) + + buses = if strategy isa ExplicitPlacement + allunique(strategy.buses) || error("explicit battery buses must be distinct") + for b in strategy.buses + b in candidates || + error("explicit battery bus $b is not in the eligible set") + end + record["strategy"] = "explicit" + copy(strategy.buses) + + elseif strategy isa SampledPlacement + strategy.count >= 1 || throw(ArgumentError("count must be at least 1")) + strategy.count <= length(candidates) || + throw(ArgumentError("cannot place $(strategy.count) batteries on $(length(candidates)) eligible buses")) + rng = StableRNG(strategy.seed) + weights = strategy.weight === nothing ? + fill(1.0, length(candidates)) : + [Float64(strategy.weight(b)) for b in candidates] + all(isfinite, weights) || error("placement weights must be finite") + all(>=(0), weights) || error("placement weights must be nonnegative") + record["strategy"] = strategy.weight === nothing ? "uniform" : "weighted" + record["seed"] = strategy.seed + record["weights"] = weights + sort!(_sample_without_replacement(rng, candidates, weights, strategy.count)) + + elseif strategy isa CallablePlacement + chosen = sort!(collect(Int.(strategy.f(candidates, (network = network, + candidates = candidates))))) + allunique(chosen) || error("callable placement returned duplicate buses") + for b in chosen + b in candidates || error("callable placement returned ineligible bus $b") + end + record["strategy"] = "callable:" * strategy.name + chosen + + else + error("unsupported placement strategy $(typeof(strategy))") + end + + isempty(buses) && error("placement selected no bus") + record["selected"] = buses + return buses, record +end + +""" + _sample_without_replacement(rng, items, weights, count) -> Vector + +Successive weighted sampling without replacement. + +# Notes +At each of `count` rounds the remaining items are sampled with probability +proportional to their weight and the chosen item is removed. With all weights +equal this reduces to a uniform draw without replacement. The implementation +consumes the stream through `rand(rng)` only, so the result depends on the seed +and not on any `Random` API whose behaviour is free to change between Julia +versions. +""" +function _sample_without_replacement(rng, items::AbstractVector, weights::AbstractVector, + count::Integer) + pool = collect(items) + w = collect(Float64.(weights)) + out = eltype(items)[] + for _ in 1:count + total = sum(w) + total > 0 || error("placement weights of the remaining pool sum to zero") + u = rand(rng) * total + acc = 0.0 + j = length(w) + for i in eachindex(w) + acc += w[i] + if u <= acc + j = i + break + end + end + push!(out, pool[j]) + deleteat!(pool, j) + deleteat!(w, j) + end + return out +end + +""" + battery_fleet(network, buses; power, energy_hours, charge_efficiency, + discharge_efficiency, self_discharge, throughput_cost, + initial_fraction) -> (Vector{BatterySpec}, record) + +Give the selected buses their ratings. + +# Arguments +- `buses::AbstractVector{Int}`: the output of [`select_battery_buses`](@ref). + +# Keywords +- `power`: the power rating rule. Either a `Real` in pu applied to every + battery, a `Dict{Int,<:Real}` keyed by bus, or a callable `bus -> Real`. A + callable closing over a `Distribution` and an RNG is how a SAMPLED capacity is + expressed without this file depending on Distributions.jl. +- `energy_hours`: energy rating as hours at full discharge power; same three + forms as `power`. +- `charge_efficiency`, `discharge_efficiency`, `self_discharge`, + `throughput_cost`, `initial_fraction`: same three forms; scalars in practice. +- `reserve_fraction`: the OPERATING BAND. `energy_min = reserve_fraction * + energy_max` and `energy_max` is unchanged, so a nonzero value keeps the battery + off the exact bottom of its box. Physically it is the reserve a real battery is + not allowed to discharge below; numerically it matters more than it sounds, + because at an exact box corner the one-stage reachable interval collapses + against a bound, the transition equality and the energy bound become parallel, + and the resulting near-degenerate face is what defeats a conic interior-point + method on the SOC-WR relaxation. + +# Returns +- The fleet sorted by battery index, and the manifest record of the capacity rule. + +# Notes +Batteries are indexed `1:n` in the order of the (sorted) bus identifiers. Battery +INDEX is an identity, not a position — every engine keys on it — but assigning +them consecutively at construction keeps the frozen artifact readable. + +Every parameter is validated here rather than at read time as well, so a case +that cannot be built is rejected where the rule that produced it is still in +scope. +""" +function battery_fleet(network::AbstractDict, buses::AbstractVector{<:Integer}; + power, + energy_hours, + charge_efficiency = 0.95, + discharge_efficiency = 0.95, + self_discharge = 1.0, + throughput_cost = 0.0, + initial_fraction = 0.5, + reserve_fraction = 0.0) + resolve(rule, bus) = rule isa Function ? Float64(rule(bus)) : + rule isa AbstractDict ? Float64(rule[bus]) : Float64(rule) + + specs = BatterySpec[] + record = Dict{String,Any}("power_pu" => Dict{String,Any}(), + "energy_hours" => Dict{String,Any}()) + for (i, bus) in enumerate(buses) + p = resolve(power, bus) + h = resolve(energy_hours, bus) + ηc = resolve(charge_efficiency, bus) + ηd = resolve(discharge_efficiency, bus) + α = resolve(self_discharge, bus) + c = resolve(throughput_cost, bus) + f0 = resolve(initial_fraction, bus) + rf = resolve(reserve_fraction, bus) + + p > 0 || error("battery at bus $bus: power rating must be positive, got $p") + h > 0 || error("battery at bus $bus: energy duration must be positive, got $h") + 0 < ηc <= 1 || error("battery at bus $bus: charge_efficiency out of (0,1]") + 0 < ηd <= 1 || error("battery at bus $bus: discharge_efficiency out of (0,1]") + 0 < α <= 1 || error("battery at bus $bus: self_discharge out of (0,1]") + c >= 0 || error("battery at bus $bus: throughput_cost must be nonnegative") + 0 <= f0 <= 1 || error("battery at bus $bus: initial_fraction out of [0,1]") + 0 <= rf < 1 || error("battery at bus $bus: reserve_fraction out of [0,1)") + rf <= f0 || error("battery at bus $bus: initial_fraction $f0 is below the reserve $rf") + + e_max = h * p + push!(specs, BatterySpec(i, Int(bus), rf * e_max, e_max, f0 * e_max, p, p, + ηc, ηd, α, c)) + record["power_pu"][string(bus)] = p + record["reserve_fraction"] = rf + record["energy_hours"][string(bus)] = h + end + return specs, record +end + +# ───────────────────────────────────────────────────────────────────────────── +# Case container and I/O +# ───────────────────────────────────────────────────────────────────────────── + +""" + BatteryCase + +Everything both engines need in order to build the same stage problem. + +# Fields +- `dir::String`: directory the artifacts were read from. +- `name::String`: PGLib case name, e.g. `"pglib_opf_case14_ieee"`. +- `network::Dict{String,Any}`: the parsed PGLib network, per-unit, verbatim. +- `batteries::Vector{BatterySpec}`: sorted by battery index. +- `recourse::RecourseCosts`: prices of the two-sided nodal active recourse. +- `demand::DemandSupport`: the frozen finite demand support. +- `manifest::Dict{String,Any}`: the manifest as read from disk. +""" +struct BatteryCase + dir::String + name::String + network::Dict{String,Any} + batteries::Vector{BatterySpec} + recourse::RecourseCosts + demand::DemandSupport + manifest::Dict{String,Any} +end + +"Stage duration ``\\Delta t`` in hours." +stage_hours(c::BatteryCase) = c.demand.stage_hours + +""" + nominal_load_demand(case) -> (pd::Vector{Float64}, qd::Vector{Float64}) + +Nominal active and reactive demand of every load in `case.demand.load_ids` +order (pu). + +# Notes +The support's load order — not the network dictionary's iteration order — is what +indexes every multiplier vector, so it is what indexes the nominal values too. +""" +function nominal_load_demand(case::BatteryCase) + by_id = Dict{Int,Any}(Int(l["index"]) => l for (_, l) in case.network["load"]) + pd = Vector{Float64}(undef, num_loads(case.demand)) + qd = Vector{Float64}(undef, num_loads(case.demand)) + for (j, id) in enumerate(case.demand.load_ids) + load = by_id[id] + pd[j] = Float64(load["pd"]) + qd[j] = Float64(load["qd"]) + end + return pd, qd +end + +""" + nominal_bus_demand(case) -> (pd::Dict{Int,Float64}, qd::Dict{Int,Float64}) + +Nominal active and reactive demand aggregated per BUS identifier (pu). + +# Notes +A bus may host several loads; the network's nodal balance constrains only their +sum, so both engines aggregate to the bus before anything else happens. Buses +with no load appear with an explicit `0.0` so downstream code can index every +bus without a `get` default and its attendant typo risk. +""" +function nominal_bus_demand(case::BatteryCase) + pd = Dict{Int,Float64}(Int(b["index"]) => 0.0 for (_, b) in case.network["bus"]) + qd = Dict{Int,Float64}(Int(b["index"]) => 0.0 for (_, b) in case.network["bus"]) + for (_, load) in case.network["load"] + Int(get(load, "status", 1)) == 0 && continue + bus = Int(load["load_bus"]) + pd[bus] += Float64(load["pd"]) + qd[bus] += Float64(load["qd"]) + end + return pd, qd +end + +""" + realized_bus_demand(case, t, atom) -> (pd::Dict{Int,Float64}, qd::Dict{Int,Float64}) + +Per-bus demand realized at stage `t` under atom index `atom` (pu). + +# Notes +Each load is scaled by its own total multiplier +``h_{i,t} m^{(atom)}_{i,t}`` and the scaled loads are then aggregated to their +bus. The same multiplier scales active and reactive demand, so the power factor +of every individual load is preserved exactly — which is a stronger statement +than preserving the aggregate power factor at the bus, and is the one the study +claims. + +Loads that are out of service contribute nothing, and buses with no load appear +with `0.0`, so the returned dictionaries cover every bus of the network. +""" +function realized_bus_demand(case::BatteryCase, t::Integer, atom::Integer) + pd = Dict{Int,Float64}(Int(b["index"]) => 0.0 for (_, b) in case.network["bus"]) + qd = Dict{Int,Float64}(Int(b["index"]) => 0.0 for (_, b) in case.network["bus"]) + mult = demand_multipliers(case.demand, t, atom) + by_id = Dict{Int,Any}(Int(l["index"]) => l for (_, l) in case.network["load"]) + for (j, id) in enumerate(case.demand.load_ids) + load = by_id[id] + Int(get(load, "status", 1)) == 0 && continue + bus = Int(load["load_bus"]) + pd[bus] += Float64(load["pd"]) * mult[j] + qd[bus] += Float64(load["qd"]) * mult[j] + end + return pd, qd +end + +""" + demand_path(case, atoms) -> Vector{Tuple{Dict{Int,Float64},Dict{Int,Float64}}} + +Materialize a COMPLETE demand path: the per-bus `(pd, qd)` of every stage of the +atom-index vector `atoms`. + +# Notes +A "demand path" is the object a deterministic-equivalent solve and a +perfect-foresight panel consume; giving it a name here keeps every caller from +re-deriving the stage-to-atom mapping and getting the stage offset wrong. +""" +function demand_path(case::BatteryCase, atoms::AbstractVector{<:Integer}) + return [realized_bus_demand(case, t, atoms[t]) for t in eachindex(atoms)] +end + +""" + write_battery_case(dir; name, network, batteries, recourse, demand, + source_version, placement, protocol_stages, + protocol_scenarios) -> Dict{String,Any} + +Write the four frozen artifacts and return the manifest that was written. + +# Notes +The manifest is written LAST and records the SHA-256 of the three artifacts as +they landed on disk, so a manifest can never describe bytes that were never +written. Every value the two engines must agree on — stage duration, unit +conventions, component counts, the support digest, the protocol digest — is +recorded here rather than recomputed independently on each side. + +Stage duration is recorded once, in hours, and read back by +[`read_battery_case`](@ref) with a fail-closed check. This is the battery +analogue of the hydro `stage_hours`, whose omission once rescaled a whole +study's dynamics by a factor of 168. +""" +function write_battery_case(dir::AbstractString; + name::AbstractString, + network::AbstractDict, + batteries::AbstractVector{BatterySpec}, + recourse::RecourseCosts, + demand::DemandSupport, + source_version::AbstractString, + placement::AbstractDict = Dict{String,Any}(), + protocol_stages::Integer, + protocol_scenarios::Integer, + screening_seed::Union{Nothing,Integer} = nothing, + screening_scenarios::Integer = 0) + validate_support(demand) + mkpath(dir) + + network_obj = Dict{String,Any}( + "schema" => BATTERY_NETWORK_SCHEMA, + "name" => name, + "source_version" => source_version, + "data" => network, + ) + network_sha = write_canonical_json(joinpath(dir, "network.json"), network_obj) + + batteries_obj = Dict{String,Any}( + "schema" => BATTERY_BATTERY_SCHEMA, + "case" => name, + # The two-sided nodal active recourse is part of the same extension + # layer as the batteries: it is what makes a strict, dynamically + # reachable target admissible under the true network. Freezing its + # prices here is what guarantees both engines and both SDDP passes + # charge for it identically. + "recourse" => Dict{String,Any}( + "deficit_cost" => recourse.deficit, + "surplus_cost" => recourse.surplus, + ), + # How the fleet was chosen, in enough detail to redraw it. + "placement" => Dict{String,Any}(placement), + "batteries" => [Dict{String,Any}( + "index" => b.index, + "bus" => b.bus, + "energy_min" => b.energy_min, + "energy_max" => b.energy_max, + "energy_initial" => b.energy_initial, + "charge_max" => b.charge_max, + "discharge_max" => b.discharge_max, + "charge_efficiency" => b.charge_efficiency, + "discharge_efficiency" => b.discharge_efficiency, + "self_discharge" => b.self_discharge, + "throughput_cost" => b.throughput_cost, + ) for b in batteries], + ) + batteries_sha = write_canonical_json(joinpath(dir, "batteries.json"), batteries_obj) + + demand_obj = Dict{String,Any}( + "schema" => BATTERY_DEMAND_SCHEMA, + "case" => name, + "stage_hours" => demand.stage_hours, + "horizon" => demand.horizon, + "load_ids" => demand.load_ids, + # Stage-major, load-minor: `profile[t][j]` is load `load_ids[j]` at stage + # `t`. Writing it stage-major matches how a stage problem reads it. + "profile" => [Float64[demand.profile[j, t] for j in 1:num_loads(demand)] + for t in 1:demand.horizon], + "atoms" => [[Float64[demand.atoms[t][j, k] for j in 1:num_loads(demand)] + for k in 1:num_atoms(demand, t)] for t in 1:demand.horizon], + "probabilities" => [copy(demand.probabilities[t]) for t in 1:demand.horizon], + "protocol_seed" => demand.protocol_seed, + "source" => Dict{String,Any}(demand.source), + ) + demand_sha = write_canonical_json(joinpath(dir, "demand.json"), demand_obj) + + manifest = Dict{String,Any}( + "schema" => BATTERY_MANIFEST_SCHEMA, + "case" => name, + "source" => Dict{String,Any}("package" => "PGLib.jl", "version" => source_version), + "stage_hours" => demand.stage_hours, + "units" => Dict{String,Any}( + "power" => "per-unit on network baseMVA", + "energy" => "per-unit-hours (pu power sustained for one hour)", + "time" => "hours", + # Every number this study builds, solves and reports is in this one + # unit. No stage objective is rescaled on its way into a solver and + # none is converted on its way out: the model a solver sees carries + # the physical stage cost, so a reported cost, a cut and a multiplier + # are all comparable without any conversion step. + "cost" => "objective units of the PGLib case per hour", + ), + "counts" => Dict{String,Any}( + "bus" => length(network["bus"]), + "gen" => length(network["gen"]), + "branch" => length(network["branch"]), + "load" => length(network["load"]), + "shunt" => length(get(network, "shunt", Dict())), + "battery" => length(batteries), + "horizon" => demand.horizon, + "demand_atom_min" => minimum(num_atoms(demand, t) for t in 1:demand.horizon), + "demand_atom_max" => maximum(num_atoms(demand, t) for t in 1:demand.horizon), + ), + "baseMVA" => Float64(network["baseMVA"]), + "recourse" => Dict{String,Any}( + "deficit_cost" => recourse.deficit, + "surplus_cost" => recourse.surplus, + ), + "support" => Dict{String,Any}( + "sha256" => support_digest(demand), + "source" => Dict{String,Any}(demand.source), + ), + # The FINAL paired protocol. Generated from the support's own seed and + # hashed here; a phase that must not evaluate on it can still record what + # it will be. It is generated FIRST and depends on nothing else, which is + # what keeps it independent of every screening decision. + "protocol" => Dict{String,Any}( + "seed" => demand.protocol_seed, + "num_stages" => protocol_stages, + "num_scenarios" => protocol_scenarios, + "sha256" => protocol_digest(demand, protocol_stages, protocol_scenarios), + ), + # The SCREENING protocol, drawn from an INDEPENDENT seed and repaired + # against the final protocol's columns, so the two panels share no + # scenario BY CONSTRUCTION. Everything a case-selection or + # checkpoint-selection decision may look at comes from here, which is what + # leaves the final protocol fresh. + "screening" => screening_seed === nothing ? nothing : Dict{String,Any}( + "seed" => Int(screening_seed), + "num_stages" => protocol_stages, + "num_scenarios" => Int(screening_scenarios), + "excludes" => "protocol", + "sha256" => protocol_digest(demand, protocol_stages, Int(screening_scenarios); + seed = Int(screening_seed), + exclude = protocol_columns( + scenario_index_matrix(demand, protocol_stages, + protocol_scenarios))), + ), + "artifacts" => Dict{String,Any}( + "network.json" => network_sha, + "batteries.json" => batteries_sha, + "demand.json" => demand_sha, + ), + ) + write_canonical_json(joinpath(dir, "case_manifest.json"), manifest) + return manifest +end + +""" + read_battery_case(dir; verify=true) -> BatteryCase + +Read a frozen case from `dir`. + +# Keywords +- `verify::Bool`: when `true` (the default) every artifact hash, schema tag, + stage duration, support digest and protocol digest recorded in the manifest is + re-checked against the bytes on disk before anything is returned. + +# Notes +Verification is on by default and failures are ERRORS, never warnings: an +engine that proceeds on a case it could not verify is producing numbers that +cannot be compared with the other engine's. +""" +function read_battery_case(dir::AbstractString; verify::Bool = true) + manifest_path = joinpath(dir, "case_manifest.json") + isfile(manifest_path) || error("no case_manifest.json in $dir") + manifest = JSON.parsefile(manifest_path) + manifest["schema"] == BATTERY_MANIFEST_SCHEMA || + error("unexpected manifest schema $(manifest["schema"]); expected $BATTERY_MANIFEST_SCHEMA") + + if verify + for (file, want) in manifest["artifacts"] + path = joinpath(dir, file) + isfile(path) || error("case artifact $file missing from $dir") + got = sha256_file(path) + got == want || error("case artifact $file has SHA-256 $got but the manifest records $want") + end + end + + network_obj = JSON.parsefile(joinpath(dir, "network.json")) + network_obj["schema"] == BATTERY_NETWORK_SCHEMA || + error("unexpected network schema $(network_obj["schema"])") + network = plain(network_obj["data"])::Dict{String,Any} + + batteries_obj = JSON.parsefile(joinpath(dir, "batteries.json")) + batteries_obj["schema"] == BATTERY_BATTERY_SCHEMA || + error("unexpected batteries schema $(batteries_obj["schema"])") + batteries = BatterySpec[ + BatterySpec(Int(b["index"]), Int(b["bus"]), + Float64(b["energy_min"]), Float64(b["energy_max"]), + Float64(b["energy_initial"]), + Float64(b["charge_max"]), Float64(b["discharge_max"]), + Float64(b["charge_efficiency"]), Float64(b["discharge_efficiency"]), + Float64(b["self_discharge"]), Float64(b["throughput_cost"])) + for b in batteries_obj["batteries"]] + sort!(batteries; by = b -> b.index) + recourse = RecourseCosts(Float64(batteries_obj["recourse"]["deficit_cost"]), + Float64(batteries_obj["recourse"]["surplus_cost"])) + + demand_obj = JSON.parsefile(joinpath(dir, "demand.json")) + demand_obj["schema"] == BATTERY_DEMAND_SCHEMA || + error("unexpected demand schema $(demand_obj["schema"])") + load_ids = Int.(demand_obj["load_ids"]) + T = Int(demand_obj["horizon"]) + n = length(load_ids) + profile = Matrix{Float64}(undef, n, T) + for t in 1:T + col = Float64.(demand_obj["profile"][t]) + length(col) == n || + error("demand.json profile row $t has $(length(col)) entries, expected $n") + profile[:, t] .= col + end + atoms = Vector{Matrix{Float64}}(undef, T) + probs = Vector{Vector{Float64}}(undef, T) + for t in 1:T + raw = demand_obj["atoms"][t] + K = length(raw) + A = Matrix{Float64}(undef, n, K) + for k in 1:K + col = Float64.(raw[k]) + length(col) == n || + error("demand.json stage $t atom $k has $(length(col)) entries, expected $n") + A[:, k] .= col + end + atoms[t] = A + probs[t] = Float64.(demand_obj["probabilities"][t]) + end + demand = DemandSupport(Float64(demand_obj["stage_hours"]), T, load_ids, + profile, atoms, probs, + Int(demand_obj["protocol_seed"]), + plain(get(demand_obj, "source", Dict{String,Any}()))) + + # ── Fail-closed contract checks ───────────────────────────────────────── + # Each of these has a documented failure mode behind it; none is cosmetic. + validate_support(demand) + demand.stage_hours == Float64(manifest["stage_hours"]) || + error("demand.json stage_hours $(demand.stage_hours) disagrees with manifest $(manifest["stage_hours"])") + network_load_ids = sort!([Int(l["index"]) for (_, l) in network["load"]]) + demand.load_ids == network_load_ids || + error("demand support covers loads $(demand.load_ids) but the network has $(network_load_ids)") + bus_ids = Set(Int(b["index"]) for (_, b) in network["bus"]) + for b in batteries + b.bus in bus_ids || error("battery $(b.index) sits at bus $(b.bus), which is not in the network") + 0 < b.charge_efficiency <= 1 || error("battery $(b.index): charge_efficiency out of (0,1]") + 0 < b.discharge_efficiency <= 1 || error("battery $(b.index): discharge_efficiency out of (0,1]") + 0 < b.self_discharge <= 1 || error("battery $(b.index): self_discharge out of (0,1]") + b.energy_min <= b.energy_initial <= b.energy_max || + error("battery $(b.index): initial energy $(b.energy_initial) outside [$(b.energy_min), $(b.energy_max)]") + b.charge_max >= 0 && b.discharge_max >= 0 || + error("battery $(b.index): negative power rating") + b.throughput_cost >= 0 || error("battery $(b.index): negative throughput cost") + end + allunique(b.index for b in batteries) || error("battery indices are not unique") + recourse.deficit > 0 && recourse.surplus > 0 || + error("recourse prices must be strictly positive; got $(recourse)") + recourse.deficit == Float64(manifest["recourse"]["deficit_cost"]) && + recourse.surplus == Float64(manifest["recourse"]["surplus_cost"]) || + error("batteries.json recourse prices disagree with the manifest") + if verify + want_support = manifest["support"]["sha256"] + got_support = support_digest(demand) + got_support == want_support || + error("regenerated support digest $got_support does not match the manifest's $want_support") + want = manifest["protocol"]["sha256"] + got = protocol_digest(demand, Int(manifest["protocol"]["num_stages"]), + Int(manifest["protocol"]["num_scenarios"])) + got == want || + error("regenerated protocol digest $got does not match the manifest's $want") + scr = get(manifest, "screening", nothing) + if scr !== nothing + wants = scr["sha256"] + # The screening protocol is regenerated exactly as it was written: + # from its own seed, excluding the final protocol's columns when the + # record says it does. Regenerating it without the exclusion would + # silently pass on every case where no repair was needed and fail + # only on the small supports where the property actually bites. + ex = get(scr, "excludes", nothing) == "protocol" ? + protocol_columns(scenario_index_matrix(demand, + Int(manifest["protocol"]["num_stages"]), + Int(manifest["protocol"]["num_scenarios"]))) : + nothing + gots = protocol_digest(demand, Int(scr["num_stages"]), + Int(scr["num_scenarios"]); seed = Int(scr["seed"]), + exclude = ex) + gots == wants || + error("regenerated screening digest $gots does not match the manifest's $wants") + end + end + + return BatteryCase(String(dir), String(manifest["case"]), network, batteries, + recourse, demand, manifest) +end + +""" + _sampler_kind(d) -> String + +A one-line name for a recorded authoring sampler. + +# Notes +The full description is a nested dictionary that can run to thousands of +characters on a stage-dependent regional sampler. It stays in the artifact, where +it belongs; a case summary that scrolled it off the screen would be worse than +useless. +""" +function _sampler_kind(d) + d isa AbstractDict || return "(unrecorded)" + kind = String(get(d, "sampler", "?")) + kind == "product" && return "product(" * + join([_sampler_kind(c) for c in get(d, "components", [])], " × ") * ")" + if kind == "stage" + inner = sort!(unique([_sampler_kind(v) for (_, v) in get(d, "stages", Dict())])) + return "stage[" * join(inner, "|") * "]" + end + kind == "group" && return "group(" * string(length(get(d, "groups", []))) * " regions)" + return kind +end + +""" + describe(case::BatteryCase) -> String + +One-screen human summary of a frozen case: counts, stage duration, battery +ratings and the demand support. +""" +function describe(case::BatteryCase) + s = case.demand + io = IOBuffer() + println(io, "battery case: ", case.name, " (", case.dir, ")") + @printf(io, " buses %d gens %d branches %d loads %d baseMVA %.1f\n", + length(case.network["bus"]), length(case.network["gen"]), + length(case.network["branch"]), length(case.network["load"]), + Float64(case.network["baseMVA"])) + @printf(io, " stage duration %.4f h horizon %d loads in support %d\n", + s.stage_hours, s.horizon, num_loads(s)) + ks = [num_atoms(s, t) for t in 1:s.horizon] + @printf(io, " atoms per stage: min %d max %d support sha %s\n", + minimum(ks), maximum(ks), support_digest(s)[1:16]) + @printf(io, " profile range over stages: [%.4f, %.4f]\n", + minimum(s.profile), maximum(s.profile)) + @printf(io, " authoring sampler: %s (freeze %s, seed %s)\n", + _sampler_kind(get(s.source, "sampler", nothing)), + get(s.source, "method", "?"), string(get(s.source, "seed", "?"))) + @printf(io, " recourse prices: deficit %.1f surplus %.1f (per pu per stage)\n", + case.recourse.deficit, case.recourse.surplus) + for b in case.batteries + @printf(io, " battery %d @ bus %-4d e∈[%.4f, %.4f] e0=%.4f pch≤%.4f pdis≤%.4f η=(%.3f,%.3f) α=%.4f c_deg=%.4f\n", + b.index, b.bus, b.energy_min, b.energy_max, b.energy_initial, + b.charge_max, b.discharge_max, + b.charge_efficiency, b.discharge_efficiency, + b.self_discharge, b.throughput_cost) + end + return String(take!(io)) +end + +""" + evaluation_protocol(case) -> (matrix, kind) + +The protocol a policy may be SELECTED on, and which one it is. + +# Returns +- `matrix::Matrix{Int}`: the `(stages × scenarios)` atom-index matrix. +- `kind::Symbol`: `:screening` when the case declares a screening protocol, + `:sole` when it declares only one protocol and therefore has no final/screening + split at all. + +# Notes +**Selection may never touch the final protocol.** A case of the study's panel +declares two: a large final one, drawn from the support's own `protocol_seed` +and evaluated ONCE after every selection is made, and a small screening one from +an independent seed, repaired against the final one so the two share no scenario +by construction. Regenerating the screening protocol therefore has to regenerate +the final one's COLUMNS as the exclusion set — which is index arithmetic on the +frozen support, exactly what `read_battery_case` already does on every load, and +not an evaluation of anything. + +An earlier revision of this file read `manifest["protocol"]` here. That is the +FINAL protocol, so checkpoint selection was scoring policies on the very panel +that exists to be fresh. The defect was silent — the columns solve, the costs are +finite and the numbers look like a panel — which is why the protocol's kind is +returned beside the matrix, recorded in the checkpoint and printed by the +trainer, rather than left as something a reader has to re-derive. + +`:sole` is reachable only on a case built without a screening protocol at all — +the small correctness fixture this package's regression suite runs on. Every +panel case has the split, so a study run cannot land there. The digest is +re-verified against the manifest either way. +""" +function evaluation_protocol(case::BatteryCase) + scr = get(case.manifest, "screening", nothing) + if scr === nothing + stages = Int(case.manifest["protocol"]["num_stages"]) + scen = Int(case.manifest["protocol"]["num_scenarios"]) + m = scenario_index_matrix(case.demand, stages, scen) + protocol_digest(case.demand, stages, scen) == case.manifest["protocol"]["sha256"] || + error("regenerated protocol digest does not match the manifest's") + return m, :sole + end + ex = get(scr, "excludes", nothing) == "protocol" ? + protocol_columns(scenario_index_matrix(case.demand, + Int(case.manifest["protocol"]["num_stages"]), + Int(case.manifest["protocol"]["num_scenarios"]))) : + nothing + stages, scen, seed = Int(scr["num_stages"]), Int(scr["num_scenarios"]), Int(scr["seed"]) + m = scenario_index_matrix(case.demand, stages, scen; seed = seed, exclude = ex) + protocol_digest(case.demand, stages, scen; seed = seed, exclude = ex) == scr["sha256"] || + error("regenerated screening digest does not match the manifest's") + return m, :screening +end diff --git a/examples/BatteryStorageOPF/battery_exa.jl b/examples/BatteryStorageOPF/battery_exa.jl new file mode 100644 index 0000000..bc67dcd --- /dev/null +++ b/examples/BatteryStorageOPF/battery_exa.jl @@ -0,0 +1,1165 @@ +# battery_exa.jl +# +# The GPU engine's model: a multistage, strict-target battery-storage AC-OPF +# deterministic equivalent written directly in ExaModels. +# +# This is the ONLY manually written network formulation in the project, and it +# exists because there is no equally validated PowerModels-to-ExaModels bridge. +# Its correctness is not asserted — it is MEASURED, by differencing every +# physical variable against the actual `PowerModels.ACPPowerModel` that the JuMP +# engine builds from the same frozen case. +# +# What is here: +# * a parser from the frozen `network.json` into flat, positionally indexed +# arrays, with explicit identifier→position maps so nonconsecutive PGLib +# component identifiers are handled correctly; +# * the full AC polar formulation — reference angle, Ohm's law at both ends +# with transformer taps and phase shifts, angle-difference limits, +# apparent-power limits at BOTH branch ends, shunts, generator boxes and +# polynomial costs, and a HARD reactive balance; +# * the battery layer — charge/discharge controls, the state transition with +# the outgoing energy held as a PARAMETER (strict targets), unity-power- +# factor injection, throughput cost; +# * the two-sided uncapped nodal active recourse, priced exactly as the JuMP +# engine prices it. +# +# What is deliberately NOT here: any SOC-WR model. SDDP does not run through +# this engine, and TS-DDR trains and evaluates on true ACP throughout. +# +# There is exactly ONE formulation: strict. There is no soft-target, no +# penalized-target and no target-deficit variant, here or anywhere else in the +# supported workflow. +# +# STRICT-MODE INVARIANT. The energy trajectory is an ExaModels PARAMETER of +# length `(T+1)·nBat` laid out as `[e_0; \hat e_1; …; \hat e_T]`. Because it is +# a parameter, an explicit initial-condition row `e_0 = x_0` would be a +# parameter-only constraint — an all-zero Jacobian row — so it is omitted and +# the initial condition is maintained by DATA: every writer of the energy +# parameter must keep its first `nBat` entries equal to `x_0`. +# `set_energy_path!` is the only writer and it guarantees this. + +using ExaModels +using MadNLP +using JSON +using LinearAlgebra +using Logging +using Printf +# The three verbs below are DecisionRulesExa generics; this file adds the +# battery problem's methods to them rather than shadowing the names, so a script +# that has the package in scope keeps one meaning for each verb. +import DecisionRulesExa: solve!, target_multipliers, solve_succeeded + +# ───────────────────────────────────────────────────────────────────────────── +# Flat index helpers +# +# Every array is stage-major: entry (t, i) lives at (t-1)*n + i. The energy +# parameter is the one exception — it is indexed from stage 0 — and has its own +# helper so the off-by-one can never be re-derived by hand at a call site. +# ───────────────────────────────────────────────────────────────────────────── + +@inline _bi(nBus, t, i) = (t - 1) * nBus + i # bus-indexed, stages 1..T +@inline _gi(nGen, t, g) = (t - 1) * nGen + g # generator-indexed +@inline _bri(nBr, t, l) = (t - 1) * nBr + l # branch-indexed +@inline _bti(nBat, t, b) = (t - 1) * nBat + b # battery-indexed, stages 1..T +@inline _ei(nBat, t, b) = t * nBat + b # energy parameter, stages 0..T + +# ───────────────────────────────────────────────────────────────────────────── +# Network data +# ───────────────────────────────────────────────────────────────────────────── + +""" + ExaBusData + +One bus, in positional form. + +# Fields +- `id::Int`: the network identifier (arbitrary, possibly nonconsecutive). +- `bus_type::Int`: 1 PQ, 2 PV, 3 reference, 4 isolated. +- `gs::Float64`, `bs::Float64`: TOTAL shunt conductance/susceptance at the bus, + aggregated over the case's shunt table (pu). +- `vmin::Float64`, `vmax::Float64`: voltage-magnitude bounds (pu). +""" +struct ExaBusData + id::Int + bus_type::Int + gs::Float64 + bs::Float64 + vmin::Float64 + vmax::Float64 +end + +""" + ExaGenData + +One generator, in positional form. + +# Fields +- `id::Int`: network identifier. +- `bus_pos::Int`: POSITION of its bus in the bus array. +- `pmin`, `pmax`, `qmin`, `qmax`: capability box (pu), as the case declares it, + BEFORE any per-stage availability is applied. +- `c2`, `c1`, `c0`: polynomial cost coefficients such that the generator's cost + is ``c_2 p^2 + c_1 p + c_0`` with `p` in pu. +- `availability::Vector{Float64}`: the case's per-stage availability schedule for + this unit, read from [`STAGE_AVAILABILITY_KEY`](@ref). EMPTY means the unit + carries no schedule and is available in every stage — which is what every case + built before the convention existed says, and why the field is additive. +""" +struct ExaGenData + id::Int + bus_pos::Int + pmin::Float64 + pmax::Float64 + qmin::Float64 + qmax::Float64 + c2::Float64 + c1::Float64 + c0::Float64 + availability::Vector{Float64} +end + +""" + ExaBranchData + +One branch, in positional form, with the raw MATPOWER/PowerModels π-model +parameters the AC polar equations need. + +# Fields +- `id::Int`: network identifier. +- `f_pos::Int`, `t_pos::Int`: POSITIONS of the from/to buses. +- `br_r`, `br_x`: series resistance and reactance (pu). +- `g_fr`, `b_fr`, `g_to`, `b_to`: line-charging shunts at each end (pu). +- `tap`, `shift`: transformer turns ratio and phase shift (rad). +- `rate_a`: apparent-power limit (pu). +- `angmin`, `angmax`: angle-difference limits (rad). +""" +struct ExaBranchData + id::Int + f_pos::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 + +""" + ExaNetwork + +The frozen network in the flat, positional form the ExaModels builder needs. + +# Fields +- `buses`, `gens`, `branches`: sorted by network identifier. +- `bus_pos::Dict{Int,Int}`: identifier → position. Nothing anywhere assumes an + identifier equals a position. +- `ref_bus_positions::Vector{Int}`: positions of the reference buses. +- `baseMVA::Float64`. +- `nominal_pd`, `nominal_qd::Vector{Float64}`: nominal per-bus demand (pu), + aggregated over the case's load table and indexed by bus POSITION. + +# Notes +Sorting by identifier is what makes the layout reproducible: dictionary +iteration order is not, and a variable vector whose meaning depends on hash +order cannot be compared with another engine's. + +Inactive components are dropped exactly as PowerModels drops them — buses with +`bus_type == 4`, generators with `gen_status == 0`, branches with +`br_status == 0`, loads and shunts with `status == 0` — so both engines see the +same system. +""" +struct ExaNetwork + buses::Vector{ExaBusData} + gens::Vector{ExaGenData} + branches::Vector{ExaBranchData} + bus_pos::Dict{Int,Int} + ref_bus_positions::Vector{Int} + baseMVA::Float64 + nominal_pd::Vector{Float64} + nominal_qd::Vector{Float64} +end + +nbus(net::ExaNetwork) = length(net.buses) +ngen(net::ExaNetwork) = length(net.gens) +nbranch(net::ExaNetwork) = length(net.branches) + +# ───────────────────────────────────────────────────────────────────────────── +# Per-stage generator availability +# +# The case may declare, for any generator, a per-stage multiplier on its whole +# capability box (see `STAGE_AVAILABILITY_KEY` in `battery_case.jl`). The JuMP +# engine applies it to the parsed network just before PowerModels instantiates a +# stage; this engine builds every stage of the horizon at once, so it applies it +# to the VARIABLE BOUNDS of each stage's generator block instead. The two +# statements are the same statement — `pmin`, `pmax`, `qmin` and `qmax` scaled by +# the same multiplier — made in the only place each engine has to make it. +# +# The schedule is DATA. It reaches the model through `lvar`/`uvar` and through +# nothing else: no objective term, no constraint coefficient, no parameter. That +# is what keeps it off every automatic-differentiation path in the trainer, whose +# gradient flows through the energy parameter and the multipliers only. +# ───────────────────────────────────────────────────────────────────────────── + +""" + gen_availability(gen) -> Vector{Float64} + +The per-stage availability schedule declared by one raw generator row, or an +empty vector when it declares none. + +# Notes +Rejected, rather than repaired: a schedule that is not a non-empty vector, a +multiplier that is not finite, and a multiplier outside `[0, 1]`. Availability is +a FRACTION of a declared capability — a value above one would silently give a +unit more capacity than the case says it has, and the case is the only place +capacity may be stated. +""" +function gen_availability(gen::AbstractDict) + haskey(gen, STAGE_AVAILABILITY_KEY) || return Float64[] + sched = gen[STAGE_AVAILABILITY_KEY] + (sched isa AbstractVector && !isempty(sched)) || + error("generator $(get(gen, "index", "?")): \"$STAGE_AVAILABILITY_KEY\" must be a non-empty vector of multipliers") + av = Float64.(collect(sched)) + all(a -> isfinite(a) && 0 <= a <= 1, av) || + error("generator $(get(gen, "index", "?")): availability multipliers must be finite and in [0, 1], got $av") + return av +end + +""" + availability_at(g::ExaGenData, t::Integer) -> Float64 + +Generator `g`'s availability multiplier at stage `t`. + +# Notes +Fails closed on a schedule that does not cover `t`, exactly as the JuMP engine +does: a case declaring a two-stage schedule that is then built over three stages +has been mixed up with a different case, and reusing the last entry would hide +that. A unit carrying no schedule is available in every stage, and the multiplier +returned for it is exactly `1.0` — which the bound builder recognises and skips, +so a case without schedules produces bit-identical bounds to one built before +this convention existed. +""" +@inline function availability_at(g::ExaGenData, t::Integer) + isempty(g.availability) && return 1.0 + t <= length(g.availability) || + error("generator $(g.id): \"$STAGE_AVAILABILITY_KEY\" covers $(length(g.availability)) stages but stage $t was requested") + return g.availability[t] +end + +# Scale one bound, leaving it untouched at full availability. `a == 1` is exact +# for the multiplier written by a case that means "available", and the branch +# also keeps `±Inf` bounds out of a `Inf * 0 == NaN`. +@inline _avail_scale(v::Real, a::Real) = a == 1 ? Float64(v) : Float64(v) * Float64(a) + +raw""" + _pin_exact_boxes!(lb, ub) -> Vector{NamedTuple{(:i, :v)}} + +Open every EXACTLY degenerate box in `lb`/`ub` IN PLACE and return the +`(index, value)` pairs that must be pinned by an equality row instead. + +# Returns +- one `(i = index, v = value)` per coordinate that had `lb[i] == ub[i]`, in + ascending index order. `lb[i]`/`ub[i]` are set to `-Inf`/`+Inf`. + +# Notes +A variable with `lb == ub` is not a decision at all; it is data wearing a +variable's clothes. PGLib cases are full of them — synchronous condensers carry +`pmin = pmax = 0`, and this study's per-stage availability schedule creates one +for every unit it takes fully out of service. Both forms below describe the +SAME feasible set: + +```math +x \in [v, v] +\qquad\text{versus}\qquad +x \in (-\infty, \infty),\; x - v = 0 . +``` + +The second is the one this engine builds, and the reason is measured rather than +stylistic. A zero-width box forces an interior-point method down a +fixed-variable code path, and on this model every such path is defective: + +* MadNLP's default `MakeParameter` REMOVES the variable from its internal primal + vector. On the CPU that works; on the CUDA/CUDSS backend the solve fails in + restoration at iteration 2, on every case and every horizon measured + (`case14` T=3 and T=24, `case118` T=24, `case1354_pegase` T=24). The same + removal is what makes MadNLP's `reinitialize!` path raise a `DimensionMismatch` + on this model, which is why the engine already builds a fresh solver per solve. +* `RelaxBound` does not remove it, and then the zero-width box itself defeats the + barrier: measured `RESTORATION_FAILED` on BOTH devices. + +The alternative that hides the problem is a nonzero `bound_relax_factor`, which +widens EVERY bound in the model — not only the degenerate ones — and put the +recomputed physical residual of `case1354_pegase` at `2.9e-6`, four orders above +this study's `1e-7` gate. That is the trade this function exists to refuse: the +degeneracy is removed where it lives, in the two variables that have it, and +every other bound in the model stays exact. + +The equality is imposed at the case's own value with no tolerance, so a solve +that satisfies it satisfies the original box exactly; the residual a caller +recomputes from the reported solution is the honest check and is unaffected by +this reformulation. +""" +function _pin_exact_boxes!(lb::AbstractVector, ub::AbstractVector) + length(lb) == length(ub) || + throw(ArgumentError("bound vectors of different length: $(length(lb)) and $(length(ub))")) + T = eltype(lb) + pins = NamedTuple{(:i, :v),Tuple{Int,T}}[] + for i in eachindex(lb) + lb[i] == ub[i] || continue + push!(pins, (i = i, v = lb[i])) + lb[i] = T(-Inf) + ub[i] = T(Inf) + end + return pins +end + +""" + exa_network(case::BatteryCase) -> ExaNetwork + +Build the flat positional network from a frozen case. + +# Notes +No PowerModels call appears here or anywhere else in this engine: the frozen +`network.json` is the interface between the two engines, and it holds the case +exactly as PGLib/PowerModels parsed it. + +Generator cost coefficients are read from PowerModels' highest-order-first +polynomial with `ncost` terms and re-expressed as ``(c_2, c_1, c_0)``. A model +with more than three terms is rejected rather than truncated. +""" +function exa_network(case::BatteryCase) + data = case.network + + bus_rows = sort!([b for (_, b) in data["bus"] if Int(b["bus_type"]) != 4]; + by = b -> Int(b["index"])) + bus_pos = Dict{Int,Int}(Int(b["index"]) => i for (i, b) in enumerate(bus_rows)) + + # Shunts live in their own table; a bus may carry several. + gs = zeros(Float64, length(bus_rows)) + bs = zeros(Float64, length(bus_rows)) + for (_, sh) in get(data, "shunt", Dict{String,Any}()) + Int(get(sh, "status", 1)) == 0 && continue + p = get(bus_pos, Int(sh["shunt_bus"]), 0) + p == 0 && continue + gs[p] += Float64(get(sh, "gs", 0.0)) + bs[p] += Float64(get(sh, "bs", 0.0)) + end + + buses = [ExaBusData(Int(b["index"]), Int(b["bus_type"]), gs[i], bs[i], + Float64(get(b, "vmin", 0.9)), Float64(get(b, "vmax", 1.1))) + for (i, b) in enumerate(bus_rows)] + ref_positions = [i for (i, b) in enumerate(buses) if b.bus_type == 3] + isempty(ref_positions) && error("exa_network: the case declares no reference bus") + + gen_rows = sort!([g for (_, g) in data["gen"] + if Int(get(g, "gen_status", 1)) != 0 && + haskey(bus_pos, Int(g["gen_bus"]))]; + by = g -> Int(g["index"])) + gens = ExaGenData[] + for g in gen_rows + Int(get(g, "model", 2)) == 2 || + error("exa_network: generator $(g["index"]) has a non-polynomial cost model") + cost = Float64.(g["cost"]) + n = Int(g["ncost"]) + n <= 3 || error("exa_network: generator $(g["index"]) has a degree-$(n-1) cost polynomial") + tail = cost[(end - n + 1):end] + c2 = n >= 3 ? tail[end - 2] : 0.0 + c1 = n >= 2 ? tail[end - 1] : 0.0 + c0 = n >= 1 ? tail[end] : 0.0 + av = gen_availability(g) + pmin, pmax = Float64(get(g, "pmin", 0.0)), Float64(g["pmax"]) + qmin, qmax = Float64(get(g, "qmin", -Inf)), Float64(get(g, "qmax", Inf)) + # Bound consistency is checked for SCHEDULED units only. Scaling by a + # nonnegative multiplier preserves the order of an interval, so a + # schedule can never create an inconsistency the case did not already + # carry; and checking every unit would let this engine REJECT a case that + # built before the convention existed, which the additivity requirement + # forbids. A scheduled unit is new data, so it is checked where it is read. + if !isempty(av) + pmin <= pmax || + error("generator $(g["index"]): scheduled unit has pmin $pmin above pmax $pmax") + qmin <= qmax || + error("generator $(g["index"]): scheduled unit has qmin $qmin above qmax $qmax") + end + push!(gens, ExaGenData(Int(g["index"]), bus_pos[Int(g["gen_bus"])], + pmin, pmax, qmin, qmax, c2, c1, c0, av)) + end + + br_rows = sort!([b for (_, b) in data["branch"] + if Int(get(b, "br_status", 1)) != 0 && + haskey(bus_pos, Int(b["f_bus"])) && haskey(bus_pos, Int(b["t_bus"]))]; + by = b -> Int(b["index"])) + branches = ExaBranchData[] + for b in br_rows + tap = Float64(get(b, "tap", 1.0)) + tap = tap ≈ 0 ? 1.0 : tap # PowerModels treats a zero tap as 1 + push!(branches, ExaBranchData( + Int(b["index"]), bus_pos[Int(b["f_bus"])], bus_pos[Int(b["t_bus"])], + Float64(get(b, "br_r", 0.0)), Float64(b["br_x"]), + Float64(get(b, "g_fr", 0.0)), Float64(get(b, "b_fr", 0.0)), + Float64(get(b, "g_to", 0.0)), Float64(get(b, "b_to", 0.0)), + tap, Float64(get(b, "shift", 0.0)), + Float64(get(b, "rate_a", Inf)), + Float64(get(b, "angmin", -pi)), Float64(get(b, "angmax", pi)))) + end + + pd = zeros(Float64, length(buses)) + qd = zeros(Float64, length(buses)) + for (_, l) in data["load"] + Int(get(l, "status", 1)) == 0 && continue + p = get(bus_pos, Int(l["load_bus"]), 0) + p == 0 && continue + pd[p] += Float64(l["pd"]) + qd[p] += Float64(l["qd"]) + end + + return ExaNetwork(buses, gens, branches, bus_pos, ref_positions, + Float64(data["baseMVA"]), pd, qd) +end + +""" + branch_coefficients(br, T) -> NamedTuple + +Precompute the eight AC-polar branch coefficients in element type `T`. + +# Notes +With ``t_r = \\tau\\cos\\theta_s``, ``t_i = \\tau\\sin\\theta_s``, +``t_m = t_r^2 + t_i^2``, ``g + jb = 1/(r + jx)``: + +```math +\\begin{aligned} +c_1 &= (-g t_r - b t_i)/t_m, & c_2 &= (-b t_r + g t_i)/t_m,\\\\ +c_3 &= (-g t_r + b t_i)/t_m, & c_4 &= (-b t_r - g t_i)/t_m,\\\\ +c_5 &= (g + g^{fr})/t_m, & c_6 &= (b + b^{fr})/t_m,\\\\ +c_7 &= g + g^{to}, & c_8 &= b + b^{to}, +\\end{aligned} +``` + +so that, writing ``\\theta = \\theta_f - \\theta_t``, + +```math +\\begin{aligned} +p^{fr} &= c_5 v_f^2 + c_3 v_f v_t \\cos\\theta + c_4 v_f v_t \\sin\\theta,\\\\ +q^{fr} &= -c_6 v_f^2 - c_4 v_f v_t \\cos\\theta + c_3 v_f v_t \\sin\\theta,\\\\ +p^{to} &= c_7 v_t^2 + c_1 v_t v_f \\cos(-\\theta) + c_2 v_t v_f \\sin(-\\theta),\\\\ +q^{to} &= -c_8 v_t^2 - c_2 v_t v_f \\cos(-\\theta) + c_1 v_t v_f \\sin(-\\theta). +\\end{aligned} +``` + +This is PowerModels' `constraint_ohms_yt_from`/`_to` for the polar AC form, +transformer taps and phase shifts included. A zero `t_m` (only reachable from a +degenerate tap) is replaced by 1 so the model builds; the case verifier rejects +such data upstream. +""" +function branch_coefficients(br::ExaBranchData, ::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) + tr = T(br.tap) * cos(T(br.shift)) + ti = T(br.tap) * sin(T(br.shift)) + 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 + +# ───────────────────────────────────────────────────────────────────────────── +# The deterministic equivalent +# ───────────────────────────────────────────────────────────────────────────── + +""" + BatteryExaProblem + +A `T`-stage strict-target battery-storage AC-OPF deterministic equivalent. + +# Fields +- `core`, `model`: the `ExaCore` and the built `ExaModel`. +- `net::ExaNetwork`, `case::BatteryCase`: the data the model was built from. +- `batteries::Vector{BatterySpec}`: sorted by identifier; battery `b` occupies + position `b` in every flat battery array. +- `p_pd`, `p_qd`: per-bus per-stage demand parameters (length `T·nBus`). +- `p_energy`: the energy trajectory parameter, length `(T+1)·nBat`, laid out + `[e_0; \\hat e_1; …; \\hat e_T]`. See the STRICT-MODE INVARIANT at the top of + this file. +- `energy_values::Vector{Float64}`: the last trajectory written, kept so the + solution extractor can report the state without reading a parameter back off + a device. +- `transition_range::UnitRange{Int}`: rows of `result.multipliers` holding the + battery state-transition duals. +- `Δt::Float64`: stage duration in hours. +- `stages::Vector{Int}`: which CASE stage each of the model's `T` positions is. + `1:T` for a model built from the start of the horizon; anything else for a + window. It matters only for data that is indexed by case stage rather than by + position — today that is the per-stage generator availability, which is baked + into the variable bounds at build time and therefore cannot be re-pointed at a + different window afterwards. +- `horizon::Int`, `nBus`, `nGen`, `nBranch`, `nBat::Int`: sizes. +""" +struct BatteryExaProblem{C,M,P1,P2,P3} + core::C + model::M + net::ExaNetwork + case::BatteryCase + batteries::Vector{BatterySpec} + p_pd::P1 + p_qd::P2 + p_energy::P3 + energy_values::Vector{Float64} + transition_range::UnitRange{Int} + Δt::Float64 + stages::Vector{Int} + horizon::Int + nBus::Int + nGen::Int + nBranch::Int + nBat::Int +end + +"True when any generator of `prob` carries a per-stage availability schedule." +has_stage_schedule(net::ExaNetwork) = any(g -> !isempty(g.availability), net.gens) +has_stage_schedule(prob::BatteryExaProblem) = has_stage_schedule(prob.net) + +""" + assert_stage_window(prob, stages) + +Check that `stages` is the window `prob` was BUILT for, and fail if it is not. + +# Notes +Demand is written into parameters, so one built model can serve any window of the +horizon by re-imposing the demand — which is how the trainer solves a rolling +window. Availability is not data of that kind: it lives in the variable bounds +and is fixed when the model is built. A case with no schedule is therefore free +to be solved at any offset, exactly as before this convention existed, and a case +WITH one may only be solved on its own window. The alternative — silently solving +stage 5 with stage 1's availability — is the failure this study cannot afford. +""" +function assert_stage_window(prob::BatteryExaProblem, stages::AbstractVector{<:Integer}) + has_stage_schedule(prob) || return nothing + collect(Int, stages) == prob.stages || + error("this problem was built for case stages $(prob.stages) and its generator " * + "availability is baked into its bounds; it cannot be solved for stages " * + "$(collect(Int, stages)). Build a problem for that window instead.") + return nothing +end + +""" + build_battery_exa(case, T; backend=nothing, float_type=Float64, stages=1:T) + -> BatteryExaProblem + +Build the `T`-stage strict deterministic equivalent. + +# Arguments +- `case::BatteryCase`: the frozen case. +- `T::Int`: horizon. + +# Keywords +- `backend`: `nothing` for CPU, or a KernelAbstractions backend (e.g. + `CUDABackend()`) for GPU. +- `float_type`: working precision. `Float64` throughout the study; the AC + equations are ill-conditioned enough that reduced precision changes answers. +- `stages`: which CASE stage each of the `T` model positions is, `1:T` by + default. Pass a window (`stages = 2:3`, or `[2]` for a single continuation + problem) to build the model a case's LATER stages describe. It changes exactly + one thing — which entry of each generator's availability schedule is applied — + and a case that declares no schedule builds identically for every `stages`. + +# Returns +- The [`BatteryExaProblem`](@ref). + +# Notes +Constraint ORDER is part of the contract, because the target multipliers are a +slice of `result.multipliers`. The order is: reference angle, the four branch +flow definitions, angle-difference limits, apparent-power limits at each end, +active balance, reactive balance, and LAST the battery state transitions — +whose rows `transition_range` records. + +The stage problems of a strict trajectory are COUPLED only through the energy +parameter, which is data; the deterministic equivalent is nonetheless built as +one model so a single solve produces the whole trajectory and all its +multipliers. + +A generator the case schedules out of some stage keeps its variables, its cost +row and its position in every flat array — only its bounds close to zero in that +stage. The model's SHAPE is therefore the same whatever the schedule says, which +is what lets one built problem be re-solved across atoms and horizons, and it +matches the JuMP engine, which scales the same four limits rather than flipping +`gen_status` (PowerModels would drop an out-of-service unit from `ref` and change +the variable set). The constant term of a scheduled-out unit's cost polynomial is +still added, in both engines, because a polynomial cost evaluated at a pinned +zero is exactly `c_0`. +""" +function build_battery_exa(case::BatteryCase, T::Int; + backend = nothing, + float_type::Type{<:AbstractFloat} = Float64, + stages::AbstractVector{<:Integer} = 1:T) + T >= 1 || throw(ArgumentError("horizon must be at least 1")) + stage_of = collect(Int, stages) + length(stage_of) == T || + throw(ArgumentError("stages must name one case stage per model position, got $(length(stage_of)) for T=$T")) + all(>=(1), stage_of) || throw(ArgumentError("stages must be 1-based, got $stage_of")) + net = exa_network(case) + batteries = sort(collect(case.batteries); by = b -> b.index) + nB, nG, nBR, nBat = nbus(net), ngen(net), nbranch(net), length(batteries) + Δt = float_type(stage_hours(case)) + bat_pos = [net.bus_pos[b.bus] for b in batteries] + for (b, p) in zip(batteries, bat_pos) + p > 0 || error("battery $(b.index) sits at bus $(b.bus), which is not an active bus") + end + + # `concrete = Val(false)` keeps the MUTABLE core, which is what + # `ExaModels.constraint!` needs in order to add terms to an existing + # constraint row — the nodal balances below are assembled that way. It is + # passed explicitly because the default is scheduled to flip. ExaModels + # emits a deprecation warning for the mutable core; it is silenced HERE + # ONLY, around this single call, because a model build happens once per run + # while the warning would otherwise print on every one of them. + core = Logging.with_logger(Logging.NullLogger()) do + ExaModels.ExaCore(float_type; backend = backend, concrete = Val(false)) + end + + # ── Variables, in the order the extractor unpacks them ─────────────────── + va = ExaModels.variable(core, T * nB) + vm = ExaModels.variable(core, T * nB; + lvar = float_type.(repeat([b.vmin for b in net.buses], T)), + uvar = float_type.(repeat([b.vmax for b in net.buses], T)), + start = ones(float_type, T * nB)) + # Generator boxes are per STAGE, because the case may take a unit out of + # service in some stages and not others (see `availability_at`). The + # comprehension runs `t` outermost so the layout is stage-major, exactly as + # `_gi` indexes it and exactly as the `repeat` it replaces laid it out; at + # full availability every entry is the same Float64 as before. + # + # The infinite reactive bounds are substituted BEFORE scaling: a case that + # leaves `qmin` unstated means "unlimited", and `-Inf * 0` is `NaN`, not the + # zero an unavailable unit must have. + pg_lb = float_type[_avail_scale(g.pmin, availability_at(g, s)) for s in stage_of for g in net.gens] + pg_ub = float_type[_avail_scale(g.pmax, availability_at(g, s)) for s in stage_of for g in net.gens] + qg_lb = float_type[_avail_scale(isfinite(g.qmin) ? g.qmin : -1e4, availability_at(g, s)) + for s in stage_of for g in net.gens] + qg_ub = float_type[_avail_scale(isfinite(g.qmax) ? g.qmax : 1e4, availability_at(g, s)) + for s in stage_of for g in net.gens] + # An EXACTLY degenerate box is pinned by an EQUALITY ROW instead — see + # `_pin_exact_boxes!`. The bounds handed to `variable` are therefore the + # opened ones; the pinning constraints are added below, before the + # transitions, so those stay last. + pg_pins = _pin_exact_boxes!(pg_lb, pg_ub) + qg_pins = _pin_exact_boxes!(qg_lb, qg_ub) + pg = ExaModels.variable(core, T * nG; lvar = pg_lb, uvar = pg_ub) + qg = ExaModels.variable(core, T * nG; lvar = qg_lb, uvar = qg_ub) + # Branch flow boxes are ±rate_a, exactly as PowerModels' bounded branch + # power variables are; the apparent-power disks below are what actually + # binds, and a box alone would be a strictly weaker (square) relaxation. + flow_lb = float_type.(repeat([-b.rate_a for b in net.branches], T)) + flow_ub = float_type.(repeat([b.rate_a for b in net.branches], T)) + p_fr = ExaModels.variable(core, T * nBR; lvar = flow_lb, uvar = flow_ub) + q_fr = ExaModels.variable(core, T * nBR; lvar = flow_lb, uvar = flow_ub) + p_to = ExaModels.variable(core, T * nBR; lvar = flow_lb, uvar = flow_ub) + q_to = ExaModels.variable(core, T * nBR; lvar = flow_lb, uvar = flow_ub) + + # Two-sided physical active recourse: nonnegative, and with NO upper bound + # of any kind. Capping `deficit` by the realized demand would destroy + # relatively complete recourse for strict charging targets. + deficit = ExaModels.variable(core, T * nB; lvar = float_type(0)) + surplus = ExaModels.variable(core, T * nB; lvar = float_type(0)) + + p_ch = ExaModels.variable(core, T * nBat; lvar = float_type(0), + uvar = float_type.(repeat([b.charge_max for b in batteries], T))) + p_dis = ExaModels.variable(core, T * nBat; lvar = float_type(0), + uvar = float_type.(repeat([b.discharge_max for b in batteries], T))) + + # ── Parameters ─────────────────────────────────────────────────────────── + p_pd = ExaModels.parameter(core, float_type.(repeat(net.nominal_pd, T))) + p_qd = ExaModels.parameter(core, float_type.(repeat(net.nominal_qd, T))) + p_energy = ExaModels.parameter(core, zeros(float_type, (T + 1) * nBat)) + + coeff = [branch_coefficients(br, float_type) for br in net.branches] + + # ── Objective ──────────────────────────────────────────────────────────── + gen_items = [(t = t, g = i, c2 = float_type(g.c2), c1 = float_type(g.c1), c0 = float_type(g.c0)) + for t in 1:T for (i, g) in enumerate(net.gens)] + ExaModels.objective(core, + item.c2 * pg[_gi(nG, item.t, item.g)]^2 + + item.c1 * pg[_gi(nG, item.t, item.g)] + + item.c0 + for item in gen_items) + + rec_items = [(idx = _bi(nB, t, i), + cd = float_type(case.recourse.deficit), + cs = float_type(case.recourse.surplus)) + for t in 1:T for i in 1:nB] + ExaModels.objective(core, + item.cd * deficit[item.idx] + item.cs * surplus[item.idx] + for item in rec_items) + + if nBat > 0 + thr_items = [(idx = _bti(nBat, t, k), c = float_type(b.throughput_cost) * Δt) + for t in 1:T for (k, b) in enumerate(batteries)] + ExaModels.objective(core, + item.c * (p_ch[item.idx] + p_dis[item.idx]) for item in thr_items) + end + + n_con = 0 + + # ── 1. Reference angle ─────────────────────────────────────────────────── + ExaModels.constraint(core, + va[_bi(nB, item.t, item.r)] + for item in [(t = t, r = r) for t in 1:T for r in net.ref_bus_positions]) + n_con += T * length(net.ref_bus_positions) + + # ── 2-5. Branch flows at both ends ─────────────────────────────────────── + fr_items = [(t = t, l = l, f = br.f_pos, tb = br.t_pos, + c3 = coeff[l].c3, c4 = coeff[l].c4, c5 = coeff[l].c5, c6 = coeff[l].c6) + for t in 1:T for (l, br) in enumerate(net.branches)] + to_items = [(t = t, l = l, f = br.f_pos, tb = br.t_pos, + c1 = coeff[l].c1, c2 = coeff[l].c2, c7 = coeff[l].c7, c8 = coeff[l].c8) + for t in 1:T for (l, br) in enumerate(net.branches)] + + ExaModels.constraint(core, + p_fr[_bri(nBR, item.t, item.l)] + - item.c5 * vm[_bi(nB, item.t, item.f)]^2 + - item.c3 * vm[_bi(nB, item.t, item.f)] * vm[_bi(nB, item.t, item.tb)] + * cos(va[_bi(nB, item.t, item.f)] - va[_bi(nB, item.t, item.tb)]) + - item.c4 * vm[_bi(nB, item.t, item.f)] * vm[_bi(nB, item.t, item.tb)] + * sin(va[_bi(nB, item.t, item.f)] - va[_bi(nB, item.t, item.tb)]) + for item in fr_items) + ExaModels.constraint(core, + q_fr[_bri(nBR, item.t, item.l)] + + item.c6 * vm[_bi(nB, item.t, item.f)]^2 + + item.c4 * vm[_bi(nB, item.t, item.f)] * vm[_bi(nB, item.t, item.tb)] + * cos(va[_bi(nB, item.t, item.f)] - va[_bi(nB, item.t, item.tb)]) + - item.c3 * vm[_bi(nB, item.t, item.f)] * vm[_bi(nB, item.t, item.tb)] + * sin(va[_bi(nB, item.t, item.f)] - va[_bi(nB, item.t, item.tb)]) + for item in fr_items) + ExaModels.constraint(core, + p_to[_bri(nBR, item.t, item.l)] + - item.c7 * vm[_bi(nB, item.t, item.tb)]^2 + - item.c1 * vm[_bi(nB, item.t, item.tb)] * vm[_bi(nB, item.t, item.f)] + * cos(va[_bi(nB, item.t, item.tb)] - va[_bi(nB, item.t, item.f)]) + - item.c2 * vm[_bi(nB, item.t, item.tb)] * vm[_bi(nB, item.t, item.f)] + * sin(va[_bi(nB, item.t, item.tb)] - va[_bi(nB, item.t, item.f)]) + for item in to_items) + ExaModels.constraint(core, + q_to[_bri(nBR, item.t, item.l)] + + item.c8 * vm[_bi(nB, item.t, item.tb)]^2 + + item.c2 * vm[_bi(nB, item.t, item.tb)] * vm[_bi(nB, item.t, item.f)] + * cos(va[_bi(nB, item.t, item.tb)] - va[_bi(nB, item.t, item.f)]) + - item.c1 * vm[_bi(nB, item.t, item.tb)] * vm[_bi(nB, item.t, item.f)] + * sin(va[_bi(nB, item.t, item.tb)] - va[_bi(nB, item.t, item.f)]) + for item in to_items) + n_con += 4 * T * nBR + + # ── 6. Angle-difference limits ─────────────────────────────────────────── + ExaModels.constraint(core, + va[_bi(nB, item.t, item.f)] - va[_bi(nB, item.t, item.tb)] + for item in fr_items; + lcon = float_type.(repeat([br.angmin for br in net.branches], T)), + ucon = float_type.(repeat([br.angmax for br in net.branches], T))) + n_con += T * nBR + + # ── 7. Apparent-power limits at BOTH ends ──────────────────────────────── + thermal_ub = float_type.(repeat([br.rate_a^2 for br in net.branches], T)) + ExaModels.constraint(core, + p_fr[_bri(nBR, item.t, item.l)]^2 + q_fr[_bri(nBR, item.t, item.l)]^2 + for item in fr_items; + lcon = fill(float_type(-Inf), T * nBR), ucon = thermal_ub) + ExaModels.constraint(core, + p_to[_bri(nBR, item.t, item.l)]^2 + q_to[_bri(nBR, item.t, item.l)]^2 + for item in to_items; + lcon = fill(float_type(-Inf), T * nBR), ucon = thermal_ub) + n_con += 2 * T * nBR + + # ── 8. Active balance ──────────────────────────────────────────────────── + # Written as pd + gs·vm² − Σpg + Σp_fr + Σp_to − p^bat − d + s = 0, + # i.e. the plan's balance moved to one side. The battery injects + # p^bat = p^dis − p^ch, and the recourse pair enters with opposite signs. + kcl_p = ExaModels.constraint(core, + p_pd[_bi(nB, item.t, item.i)] + item.gs * vm[_bi(nB, item.t, item.i)]^2 + for item in [(t = t, i = i, gs = float_type(net.buses[i].gs)) for t in 1:T for i in 1:nB]) + ExaModels.constraint!(core, kcl_p, + item.row => -pg[item.col] + for item in [(row = _bi(nB, t, g.bus_pos), col = _gi(nG, t, k)) + for t in 1:T for (k, g) in enumerate(net.gens)]) + ExaModels.constraint!(core, kcl_p, + item.row => p_fr[item.col] + for item in [(row = _bi(nB, t, br.f_pos), col = _bri(nBR, t, l)) + for t in 1:T for (l, br) in enumerate(net.branches)]) + ExaModels.constraint!(core, kcl_p, + item.row => p_to[item.col] + for item in [(row = _bi(nB, t, br.t_pos), col = _bri(nBR, t, l)) + for t in 1:T for (l, br) in enumerate(net.branches)]) + ExaModels.constraint!(core, kcl_p, + item.row => -deficit[item.col] + surplus[item.col] + for item in [(row = _bi(nB, t, i), col = _bi(nB, t, i)) for t in 1:T for i in 1:nB]) + if nBat > 0 + ExaModels.constraint!(core, kcl_p, + item.row => -p_dis[item.col] + p_ch[item.col] + for item in [(row = _bi(nB, t, bat_pos[k]), col = _bti(nBat, t, k)) + for t in 1:T for k in 1:nBat]) + end + n_con += T * nB + + # ── 9. Reactive balance — HARD, no slack of any kind ───────────────────── + kcl_q = ExaModels.constraint(core, + p_qd[_bi(nB, item.t, item.i)] - item.bs * vm[_bi(nB, item.t, item.i)]^2 + for item in [(t = t, i = i, bs = float_type(net.buses[i].bs)) for t in 1:T for i in 1:nB]) + ExaModels.constraint!(core, kcl_q, + item.row => -qg[item.col] + for item in [(row = _bi(nB, t, g.bus_pos), col = _gi(nG, t, k)) + for t in 1:T for (k, g) in enumerate(net.gens)]) + ExaModels.constraint!(core, kcl_q, + item.row => q_fr[item.col] + for item in [(row = _bi(nB, t, br.f_pos), col = _bri(nBR, t, l)) + for t in 1:T for (l, br) in enumerate(net.branches)]) + ExaModels.constraint!(core, kcl_q, + item.row => q_to[item.col] + for item in [(row = _bi(nB, t, br.t_pos), col = _bri(nBR, t, l)) + for t in 1:T for (l, br) in enumerate(net.branches)]) + n_con += T * nB + + # ── 9b. Exactly-fixed generator variables, pinned by EQUALITY ──────────── + # `pmin == pmax` (a synchronous condenser, or any unit an availability + # schedule takes fully out of service) would otherwise be a zero-width box. + # A zero-width box is a MODELLING accident, not a physical statement: the + # same feasible set is expressed exactly by an open variable and the row + # `x − v = 0`, and that form has no degenerate bound for an interior-point + # method to choke on. See `_pin_exact_boxes!` for why this is not optional. + # + # The rows are EQUALITIES at the case's own value, so the feasible set is + # unchanged and no tolerance is involved anywhere in the statement. + for (var, pins) in ((pg, pg_pins), (qg, qg_pins)) + isempty(pins) && continue + ExaModels.constraint(core, + var[item.i] - item.v for item in pins) + n_con += length(pins) + end + + # ── 10. Battery state transition — ADDED LAST ──────────────────────────── + # e_t − α e_{t-1} − η^{ch} Δt p^{ch}_t + (Δt/η^{dis}) p^{dis}_t = 0, + # with e a PARAMETER. The duals of these rows are what + # `target_multipliers` turns into ∂Q/∂x̂. + transition_start = n_con + 1 + if nBat > 0 + ExaModels.constraint(core, + p_energy[_ei(nBat, item.t, item.k)] + - item.α * p_energy[_ei(nBat, item.t - 1, item.k)] + - item.ηc * p_ch[_bti(nBat, item.t, item.k)] + + item.ηd * p_dis[_bti(nBat, item.t, item.k)] + for item in [(t = t, k = k, + α = float_type(b.self_discharge), + ηc = float_type(b.charge_efficiency) * Δt, + ηd = Δt / float_type(b.discharge_efficiency)) + for t in 1:T for (k, b) in enumerate(batteries)]) + n_con += T * nBat + end + transition_range = transition_start:(transition_start + T * nBat - 1) + + model = ExaModels.ExaModel(core) + prob = BatteryExaProblem(core, model, net, case, batteries, + p_pd, p_qd, p_energy, + zeros(Float64, (T + 1) * nBat), + transition_range, Float64(Δt), stage_of, + T, nB, nG, nBR, nBat) + # Start from the initial energy so a solve before any explicit write is + # still a well-posed problem rather than an all-zero trajectory. + set_energy_path!(prob, + [b.energy_initial for b in batteries], + repeat([b.energy_initial for b in batteries], T)) + return prob +end + +# ───────────────────────────────────────────────────────────────────────────── +# Parameter updates +# ───────────────────────────────────────────────────────────────────────────── + +""" + realized_demand(case, net, stages, atoms) -> (pd, qd) + +Per-bus realized demand matrices for one scenario. + +# Arguments +- `case::BatteryCase`, `net::ExaNetwork`. +- `stages::AbstractVector{<:Integer}`: the ABSOLUTE stage indices, which is what + selects the deterministic shape entry. +- `atoms::AbstractVector{<:Integer}`: realized atom index per stage. + +# Returns +- `(pd, qd)`: two `T×nBus` matrices in pu, indexed by bus POSITION. + +# Notes +The realized demand is read from the FROZEN finite support through the shared +`realized_bus_demand`, which scales each LOAD by its own total multiplier and +then aggregates to the bus. Both matrices carry the same multiplier per load, so +every realization preserves each load's power factor exactly. + +Doing it per load rather than per bus matters as soon as the support is anything +but system-wide: a regional or per-load multiplier applied to a bus AGGREGATE +would already have averaged away the structure the study is about, and the two +engines would then be solving two different problems while both reported "the +same demand". + +Bus POSITION is this engine's own indexing; the shared function returns bus +IDENTIFIERS, and `net.bus_pos` is the only place the two are related. +""" +function realized_demand(case::BatteryCase, net::ExaNetwork, + stages::AbstractVector{<:Integer}, + atoms::AbstractVector{<:Integer}) + length(stages) == length(atoms) || + throw(ArgumentError("stages and atoms must have the same length")) + T = length(stages) + pd = zeros(Float64, T, nbus(net)) + qd = zeros(Float64, T, nbus(net)) + for t in 1:T + bus_pd, bus_qd = realized_bus_demand(case, stages[t], atoms[t]) + for (id, p) in bus_pd + pos = get(net.bus_pos, id, 0) + pos == 0 && continue # a bus this engine dropped (bus_type 4) + pd[t, pos] = p + qd[t, pos] = bus_qd[id] + end + end + return pd, qd +end + +""" + set_demand!(prob, pd, qd) + +Write the realized per-bus demand into the model's parameters. + +# Arguments +- `pd`, `qd`: `T×nBus` matrices in pu, indexed by bus position. +""" +function set_demand!(prob::BatteryExaProblem, pd::AbstractMatrix, qd::AbstractMatrix) + size(pd) == (prob.horizon, prob.nBus) || + error("pd must be $(prob.horizon)×$(prob.nBus), got $(size(pd))") + size(qd) == size(pd) || error("qd must have the same shape as pd") + ExaModels.set_parameter!(prob.core, prob.p_pd, + [pd[t, i] for t in 1:prob.horizon for i in 1:prob.nBus]) + ExaModels.set_parameter!(prob.core, prob.p_qd, + [qd[t, i] for t in 1:prob.horizon for i in 1:prob.nBus]) + return prob +end + +""" + set_energy_path!(prob, x0, xhat) + +Write the strict energy trajectory `[x0; xhat]` into the energy parameter. + +# Arguments +- `x0::AbstractVector`: initial energy per battery, in battery-position order. +- `xhat::AbstractVector`: the `T·nBat` flat, stage-major target trajectory. + +# Notes +This is the ONLY writer of the energy parameter, and it is what maintains the +strict-mode invariant stated at the top of this file: the first `nBat` entries +of the parameter always equal `x0`, because the model has no explicit +initial-condition row to enforce it. +""" +function set_energy_path!(prob::BatteryExaProblem, x0::AbstractVector, xhat::AbstractVector) + prob.nBat == 0 && return prob + length(x0) == prob.nBat || error("x0 must have length nBat=$(prob.nBat)") + length(xhat) == prob.horizon * prob.nBat || + error("xhat must have length T*nBat=$(prob.horizon * prob.nBat)") + vals = vcat(Float64.(vec(Array(x0))), Float64.(vec(Array(xhat)))) + copyto!(prob.energy_values, vals) + ExaModels.set_parameter!(prob.core, prob.p_energy, vals) + return prob +end + +""" + target_multipliers(prob, result) -> Vector{Float64} + +Turn the battery-transition duals into the actor signal +``\\partial Q/\\partial \\hat e_{b,t}``. + +# Notes +Let ``\\mu_{b,t}`` be the multiplier of the transition row + +```math +c_{b,t} := \\hat e_{b,t} - \\alpha_b \\hat e_{b,t-1} + - \\eta^{ch}_b \\Delta t\\, p^{ch}_{b,t} + + \\tfrac{\\Delta t}{\\eta^{dis}_b} p^{dis}_{b,t} = 0 . +``` + +The target ``\\hat e_{b,t}`` appears in row ``t`` with coefficient ``+1`` and in +row ``t+1`` with coefficient ``-\\alpha_b``, and in no other row: the recourse +variables and the network appear in the balance, never in the transition. By the +envelope theorem, + +```math +\\frac{\\partial Q}{\\partial \\hat e_{b,t}} + = \\mu_{b,t} - \\alpha_b \\mu_{b,t+1}, +\\qquad +\\frac{\\partial Q}{\\partial \\hat e_{b,T}} = \\mu_{b,T}. +``` + +The ``\\alpha_b`` factor is not decorative: with a self-discharging battery, the +value of energy left at the end of stage `t` reaches stage `t+1` attenuated, and +dropping it would misprice every interstage trade-off by that factor per stage. +""" +function target_multipliers(prob::BatteryExaProblem, result) + prob.nBat == 0 && return Float64[] + raw = Float64.(vec(Array(result.multipliers))[prob.transition_range]) + nBat, T = prob.nBat, prob.horizon + out = copy(raw) + if T > 1 + for t in 1:(T - 1), k in 1:nBat + out[_bti(nBat, t, k)] -= prob.batteries[k].self_discharge * raw[_bti(nBat, t + 1, k)] + end + end + return out +end + +# ───────────────────────────────────────────────────────────────────────────── +# Solving and extraction +# ───────────────────────────────────────────────────────────────────────────── + +""" + DEFAULT_SOLVER_OPTIONS + +MadNLP options every solve in this engine uses unless the caller overrides them. + +# Notes +The tolerance sits well below every physical tolerance the study reports at. An +interior-point method parks a nonnegative variable roughly one tolerance below +its zero bound, and a positively priced variable sitting there lowers the +objective by a near-constant amount at every stage — an offset that looks +exactly like a systematic model difference when two engines are compared. + +`bound_relax_factor` is the second half, and `tol` cannot substitute for it. +It is set EXPLICITLY to `ACP_BOUND_RELAX_FACTOR` — the single value shared by +every true-ACP path of this study, on both engines and both devices — rather +than inherited from a solver default, because MadNLP's CPU and GPU paths were +measured to report DIFFERENT effective defaults here, and a study whose engines +relax bounds differently is not comparing like with like. + +**It may not be set to zero.** An earlier revision did exactly that, justified by +a CPU-only residual measurement, and it broke the GPU: `MadNLPGPU`/CUDSS fails in +restoration at iteration 2 with `0.0`, on every case and horizon measured +(`case14` T=3 and T=24, `case118` T=24, `case1354_pegase` T=24), while the CPU +path is unaffected. The regression survived because the GPU was never re-gated +after the change. + +The guarantee is NOT this factor. It is the physical residual recomputed from the +reported solution by the shared schema, checked against the study's gate, plus +the maximum ORIGINAL-model bound violation reported per variable family. The +solver's own infeasibility report describes the RELAXED problem and cannot +establish either. + +One configuration for every portfolio case. Not a per-case setting, and not a +change to any model equation or to any case datum. +""" +const DEFAULT_SOLVER_OPTIONS = (print_level = MadNLP.ERROR, tol = 1e-10, + bound_relax_factor = ACP_BOUND_RELAX_FACTOR) + +""" + solve!(prob; solver_kwargs...) -> result + +Solve the deterministic equivalent with a FRESH MadNLP solver. + +# Notes +A fresh solver per solve, deliberately. MadNLP's re-solve path +(`reinitialize!`) is incompatible with this model as written: PGLib cases +contain synchronous condensers whose active-power box is exactly `[0, 0]`, and +MadNLP's default `fixed_variable_treatment = MakeParameter` removes those +variables from its internal primal vector, after which the re-solve path tries +to broadcast the full-length starting point into the reduced one and raises a +`DimensionMismatch`. The only re-solve configuration that works, +`fixed_variable_treatment = RelaxBound`, widens those boxes to about `1e-8` and +therefore makes this engine's feasible set larger than the PowerModels model it +is validated against — a change to the problem, traded for a constant factor of +speed. Correctness wins: on the correctness-phase case a fresh solve of a +24-stage horizon takes about 0.2 s. +""" +function solve!(prob::BatteryExaProblem; solver_kwargs...) + # `Base.invokelatest` because the GPU linear solver arrives through a + # package EXTENSION that is loaded at run time: a caller that switched to + # the GPU inside a function body is executing in a world older than the + # extension's methods, and MadNLP's option check then reports + # "no method matching input_type(::CUDSSSolver) … the applicable method may + # be too new". The dynamic dispatch is free next to an NLP solve. + return Base.invokelatest(MadNLP.madnlp, prob.model; + DEFAULT_SOLVER_OPTIONS..., solver_kwargs...) +end + +""" + battery_solution(prob, result) -> NamedTuple + +Unpack the flat solution vector into named, positionally indexed components. + +# Notes +The unpacking order MUST match the declaration order in +[`build_battery_exa`](@ref); it is written here as a single sequential walk over +the vector precisely so that the two orders can be read side by side. + +The energy trajectory is not part of the solution vector — it is a parameter — +so it is reported from the last value written, which is the strict-mode +invariant's other half. +""" +function battery_solution(prob::BatteryExaProblem, result) + T, nB, nG, nBR, nBat = prob.horizon, prob.nBus, prob.nGen, prob.nBranch, prob.nBat + sol = Float64.(vec(Array(result.solution))) + off = 0 + take(n) = (v = sol[off .+ (1:n)]; off += n; v) + + va = reshape(take(T * nB), nB, T) + vm = reshape(take(T * nB), nB, T) + pg = reshape(take(T * nG), nG, T) + qg = reshape(take(T * nG), nG, T) + p_fr = reshape(take(T * nBR), nBR, T) + q_fr = reshape(take(T * nBR), nBR, T) + p_to = reshape(take(T * nBR), nBR, T) + q_to = reshape(take(T * nBR), nBR, T) + deficit = reshape(take(T * nB), nB, T) + surplus = reshape(take(T * nB), nB, T) + p_ch = nBat == 0 ? zeros(0, T) : reshape(take(T * nBat), nBat, T) + p_dis = nBat == 0 ? zeros(0, T) : reshape(take(T * nBat), nBat, T) + energy = nBat == 0 ? zeros(0, T + 1) : reshape(copy(prob.energy_values), nBat, T + 1) + + 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, + deficit = deficit, surplus = surplus, + p_ch = p_ch, p_dis = p_dis, p_bat = p_dis .- p_ch, + energy = energy) +end + +""" + stage_costs(prob, sol) -> NamedTuple + +Decompose the objective into its physical components, per stage. + +# Returns +`(generation, throughput, deficit, surplus, total)`, each a length-`T` vector. + +# Notes +Recomputed from the extracted physical values rather than read off the solver, +so that "the sum of the parts equals the objective" is a real check on both the +extraction order and the objective assembly. +""" +function stage_costs(prob::BatteryExaProblem, sol) + T = prob.horizon + gen = zeros(T); thr = zeros(T); def = zeros(T); sur = zeros(T) + for t in 1:T + for (k, g) in enumerate(prob.net.gens) + p = sol.pg[k, t] + gen[t] += g.c2 * p^2 + g.c1 * p + g.c0 + end + for (k, b) in enumerate(prob.batteries) + thr[t] += b.throughput_cost * prob.Δt * (sol.p_ch[k, t] + sol.p_dis[k, t]) + end + def[t] = prob.case.recourse.deficit * sum(view(sol.deficit, :, t)) + sur[t] = prob.case.recourse.surplus * sum(view(sol.surplus, :, t)) + end + return (generation = gen, throughput = thr, deficit = def, surplus = sur, + total = gen .+ thr .+ def .+ sur) +end diff --git a/examples/BatteryStorageOPF/battery_portfolio.json b/examples/BatteryStorageOPF/battery_portfolio.json new file mode 100644 index 0000000..6e79df1 --- /dev/null +++ b/examples/BatteryStorageOPF/battery_portfolio.json @@ -0,0 +1,3342 @@ +{ + "battery": { + "charge_efficiency": 0.95, + "discharge_efficiency": 0.95, + "duration_hours": 8.0, + "initial_fraction": 0.5, + "reserve_fraction": 0.05, + "self_discharge": 0.999, + "system_power_share": 0.1, + "throughput_cost": 5.0, + "weight_cap": 3.0 + }, + "calibration": { + "bracket": [ + 0.5, + 1.25 + ], + "formulation": "PowerModels.ACPPowerModel, unmodified network, no batteries", + "gate_stages": [ + 4, + 11 + ], + "margin": 0.95, + "recourse_tolerance": 1.0e-6, + "residual_tolerance": 1.0e-7, + "step": 0.05, + "tolerance": 0.001 + }, + "cases": [ + { + "artifacts": { + "batteries.json": "7c6d8cc62a1582672db38411a27aa9b83fc61251c10c797d4f4906089a35b153", + "demand.json": "f9e48de85d50134f8efcfc224a3ceb85f9267c1c92182dc231576edde6c10a8e", + "network.json": "831a859593f53797ebb64d7a9de435ee5b1a4e01e7650e10db03ba8cb9fbff26" + }, + "battery": { + "digest": "99ab113f3a8a9fc82fef6af1d8b5f16b55caa2b691f124f7a3e909083a275767", + "energy_budget_puh": 37.604004374999995, + "power_budget_pu": 4.700500546874999, + "power_max_pu": 0.46367649462394134, + "power_min_pu": 0.0478017004766949 + }, + "case": "pglib_opf_case118_ieee", + "counts": { + "battery": 24, + "branch": 186, + "bus": 118, + "eligible_bus": 99, + "gen": 54, + "load": 99 + }, + "kappa_case": 1.1080859374999998, + "kappa_evaluations": 9, + "kappa_max": 1.1664062499999999, + "kappa_retreats": 0, + "network_sha256": "6c92fd1dfa9021b964d77a1627906092081bf46cdc989699a40bb3931b7b50e2", + "nominal_demand_pu": 42.42, + "peak_demand_pu": 47.00500546874999, + "placement": { + "algorithm": "sha256-exponential-key weighted sampling without replacement", + "buses": [ + 6, + 8, + 12, + 18, + 36, + 41, + 42, + 49, + 56, + 60, + 66, + 80, + 90, + 92, + 95, + 97, + 98, + 99, + 104, + 107, + 110, + 112, + 115, + 116 + ], + "count": 24, + "digest": "7f5c2a7f2654fd622fad61b8fe14459c3fb36e1cd58a2a157b2704c7c4365994", + "eligible": 99 + }, + "protocols": { + "final": { + "num_scenarios": 500, + "num_stages": 24, + "seed": 594161976, + "sha256": "7de27f0b33175fd37eee8f028be7040bac3757f73281ea928b202f7afeb1ac40" + }, + "screening": { + "excludes": "final", + "num_scenarios": 32, + "num_stages": 24, + "seed": 1994805207, + "sha256": "b0a5bae2e0ecd7320c4912188c304ccdb1ed61ba31b66aa021c1ba38b8157e4f" + } + }, + "regions": { + "corridors": [ + 5, + 12, + 23, + 31, + 33, + 39, + 41, + 52, + 53, + 55, + 56, + 65, + 70, + 71, + 75, + 76, + 78, + 81, + 83, + 102, + 103, + 108, + 110, + 112, + 114, + 115, + 116, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 135, + 136, + 137, + 139, + 148, + 149, + 151, + 152, + 153, + 155, + 158, + 159, + 163, + 164, + 167, + 168, + 171, + 173, + 174, + 177, + 179, + 185 + ], + "count": 6, + "demand_pu": [ + 11.58, + 10.03, + 9.95, + 3.72, + 3.71, + 3.43 + ], + "demand_share": [ + 0.272984441301273, + 0.2364450730787364, + 0.23455917020273453, + 0.0876944837340877, + 0.08745874587458745, + 0.08085808580858087 + ], + "digest": "875923af8cb35b87de1f7ddb081751542c35e20d51aa99c34f8ff7b2bb3f4dda", + "dispersion": 0.3965562759141299, + "effective_regions": 4.823410902915079, + "share_cap": 0.28, + "single_bus_exception": false, + "sizes": [ + 37, + 14, + 28, + 7, + 7, + 6 + ], + "sweeps": 3, + "unconstrained_dispersion": 0.40605418717126485, + "unconstrained_share": [ + 0.2885431400282885, + 0.2670909948137671, + 0.23455917020273453, + 0.09123055162659123, + 0.0876944837340877, + 0.03088165959453088 + ] + }, + "support": { + "sha256": "0a9763629bf78cd91ef289198dab89edd6489194c30f030b5f96bf341315f349" + }, + "verification": { + "retreats": 0, + "stage_atom_checked": 144, + "stage_atom_failures": 0 + } + }, + { + "artifacts": { + "batteries.json": "3e40b98943ab44224a5fd2fa9ad4f492d2a7942e8cacb8f2716de80da729f86d", + "demand.json": "2e92e4f4afa54f4d492ac4bd9e4835870674ede47925be9e23c550615716d3a5", + "network.json": "ea9c702f68ac9ca4d39a27b598d49eebd06ddc2d1dee9fdde41dec04e98edbe4" + }, + "battery": { + "digest": "d3e56bde42d5337316cffc9e6372415e6cd9a0c9de2b4d057e6bad2930616442", + "energy_budget_puh": 599.1013589062499, + "power_budget_pu": 74.88766986328123, + "power_max_pu": 0.7914335803966963, + "power_min_pu": 0.022400109743608326 + }, + "case": "pglib_opf_case1951_rte", + "counts": { + "battery": 240, + "branch": 2596, + "bus": 1951, + "eligible_bus": 940, + "gen": 391, + "load": 1015 + }, + "kappa_case": 0.9284765624999999, + "kappa_evaluations": 13, + "kappa_max": 0.97734375, + "kappa_retreats": 0, + "network_sha256": "1e5eb455fb49b7cce6c050bcd3a9c3f7e663065f6b2eedc7e61b193b9c242cea", + "nominal_demand_pu": 806.5649999999999, + "peak_demand_pu": 748.8766986328123, + "placement": { + "algorithm": "sha256-exponential-key weighted sampling without replacement", + "buses": [ + 3, + 13, + 19, + 21, + 22, + 40, + 42, + 43, + 44, + 45, + 49, + 53, + 55, + 57, + 71, + 82, + 84, + 87, + 98, + 107, + 111, + 114, + 123, + 149, + 199, + 209, + 213, + 222, + 237, + 247, + 263, + 273, + 276, + 280, + 295, + 297, + 303, + 309, + 313, + 317, + 325, + 328, + 330, + 342, + 344, + 345, + 354, + 367, + 387, + 389, + 394, + 398, + 404, + 406, + 407, + 409, + 413, + 414, + 428, + 440, + 441, + 444, + 461, + 464, + 468, + 469, + 472, + 473, + 478, + 490, + 493, + 522, + 529, + 530, + 535, + 536, + 546, + 554, + 556, + 568, + 595, + 598, + 600, + 605, + 606, + 609, + 613, + 618, + 627, + 630, + 641, + 650, + 655, + 656, + 668, + 670, + 676, + 695, + 698, + 699, + 711, + 712, + 730, + 734, + 735, + 738, + 740, + 741, + 746, + 752, + 754, + 757, + 776, + 790, + 792, + 793, + 795, + 806, + 825, + 827, + 830, + 840, + 844, + 845, + 846, + 847, + 849, + 865, + 870, + 873, + 881, + 884, + 887, + 891, + 895, + 896, + 910, + 911, + 919, + 929, + 931, + 933, + 937, + 941, + 943, + 945, + 950, + 958, + 959, + 963, + 964, + 977, + 993, + 994, + 1003, + 1021, + 1024, + 1029, + 1030, + 1032, + 1035, + 1042, + 1044, + 1048, + 1050, + 1059, + 1060, + 1062, + 1066, + 1087, + 1098, + 1101, + 1118, + 1119, + 1133, + 1140, + 1143, + 1151, + 1167, + 1168, + 1171, + 1172, + 1176, + 1177, + 1185, + 1188, + 1189, + 1193, + 1199, + 1201, + 1202, + 1206, + 1208, + 1217, + 1220, + 1229, + 1231, + 1236, + 1256, + 1276, + 1279, + 1285, + 1295, + 1301, + 1303, + 1304, + 1324, + 1325, + 1342, + 1349, + 1355, + 1357, + 1359, + 1377, + 1380, + 1387, + 1389, + 1406, + 1407, + 1410, + 1411, + 1412, + 1673, + 1674, + 1690, + 1715, + 1729, + 1735, + 1798, + 1802, + 1803, + 1806, + 1810, + 1811, + 1814, + 1815, + 1820, + 1824, + 1825, + 1839 + ], + "count": 240, + "digest": "d9dcc2bc35594d16408fe53437eaf163e696514468da6cfd371f12f48fad71ab", + "eligible": 940 + }, + "protocols": { + "final": { + "num_scenarios": 500, + "num_stages": 24, + "seed": 1990704154, + "sha256": "b992e8024e6ac66abd9958122d30d976387014df47160359971f4eec69c6db1a" + }, + "screening": { + "excludes": "final", + "num_scenarios": 32, + "num_stages": 24, + "seed": 473149067, + "sha256": "90dc129583053c842b7c3318431ada4b5c5d5fdfe231d7b0a634fb7696a192cb" + } + }, + "regions": { + "corridors": [ + 38, + 40, + 81, + 85, + 89, + 133, + 150, + 156, + 158, + 258, + 264, + 356, + 395, + 398, + 404, + 455, + 498, + 500, + 554, + 569, + 574, + 577, + 578, + 587, + 590, + 639, + 640, + 659, + 753, + 756, + 802, + 834, + 850, + 938, + 1015, + 1187, + 1193, + 1257, + 1259, + 1319, + 1322, + 1331, + 1349, + 1370, + 1373, + 1440, + 1473, + 1486, + 1491, + 1500, + 1591, + 1675, + 1686, + 1772, + 1777, + 1785, + 1799, + 1837, + 1849, + 1850, + 1851, + 1853, + 1856, + 1877 + ], + "count": 6, + "demand_pu": [ + 236.39500000000007, + 211.47599999999994, + 135.718, + 117.94400000000003, + 75.19400000000002, + 67.54399999999997 + ], + "demand_share": [ + 0.27999895768065, + 0.25048355326666427, + 0.16075170176400702, + 0.1396992198002774, + 0.08906381955556926, + 0.08000274793283195 + ], + "digest": "b48b567bf11e345470d0ad431e7d49f698e466d773594601c4f85d31f55cb506", + "dispersion": 0.22034708427351785, + "effective_regions": 4.97930570615907, + "share_cap": 0.28, + "single_bus_exception": false, + "sizes": [ + 181, + 241, + 185, + 142, + 106, + 85 + ], + "sweeps": 15, + "unconstrained_dispersion": 0.2637537213697582, + "unconstrained_share": [ + 0.8078188164700668, + 0.10197436605071122, + 0.0613665517351656, + 0.013091767927596705, + 0.008261565303083963, + 0.007486932513375445 + ] + }, + "support": { + "sha256": "163482369eb7aaad69d16ec5eff2e7663417bf03de49b57fd8c2491a2affe440" + }, + "verification": { + "retreats": 0, + "stage_atom_checked": 144, + "stage_atom_failures": 0 + } + }, + { + "artifacts": { + "batteries.json": "cc3eb1a7f10d500fcd5879ddf05ceecb545d04229ef9b9eefb3224a147e2881d", + "demand.json": "b09166feb2a70673dd2a4df609480f696440a8b5f2d17518fe26a21293b0e4cd", + "network.json": "2e52a8b42b8cd063c38534de5c4899683e5476f1b98f4838d1cc4bdf93edc32f" + }, + "battery": { + "digest": "0dfa35debf7111a5ec5de7bf254a300f0c2a480eb62dc3cdbb3c381d1f9935be", + "energy_budget_puh": 164.47975005000006, + "power_budget_pu": 20.559968756250008, + "power_max_pu": 0.22023386506918285, + "power_min_pu": 0.012910414568437821 + }, + "case": "pglib_opf_case2383wp_k", + "counts": { + "battery": 240, + "branch": 2896, + "bus": 2383, + "eligible_bus": 1817, + "gen": 327, + "load": 1826 + }, + "kappa_case": 0.8371875, + "kappa_evaluations": 15, + "kappa_max": 0.88125, + "kappa_retreats": 0, + "network_sha256": "42681376fd85e80db3f6bc799c0c8fc4d2de5d5725a8b3d40b125ad15d8f260d", + "nominal_demand_pu": 245.58380000000008, + "peak_demand_pu": 205.59968756250007, + "placement": { + "algorithm": "sha256-exponential-key weighted sampling without replacement", + "buses": [ + 18, + 30, + 43, + 57, + 63, + 104, + 111, + 126, + 127, + 131, + 180, + 183, + 184, + 185, + 187, + 189, + 192, + 212, + 215, + 224, + 239, + 267, + 271, + 282, + 285, + 286, + 290, + 294, + 299, + 313, + 323, + 326, + 330, + 331, + 345, + 350, + 365, + 366, + 376, + 381, + 388, + 396, + 407, + 413, + 415, + 418, + 434, + 440, + 455, + 457, + 460, + 471, + 482, + 485, + 491, + 493, + 497, + 501, + 506, + 515, + 525, + 529, + 538, + 544, + 553, + 567, + 575, + 583, + 603, + 637, + 638, + 639, + 642, + 649, + 664, + 665, + 678, + 696, + 711, + 713, + 715, + 745, + 746, + 749, + 754, + 766, + 788, + 798, + 803, + 804, + 814, + 831, + 861, + 878, + 892, + 908, + 911, + 912, + 929, + 942, + 943, + 945, + 959, + 963, + 980, + 1004, + 1029, + 1037, + 1053, + 1066, + 1117, + 1118, + 1136, + 1155, + 1175, + 1190, + 1195, + 1198, + 1201, + 1229, + 1240, + 1287, + 1289, + 1290, + 1301, + 1309, + 1311, + 1322, + 1369, + 1381, + 1386, + 1393, + 1416, + 1429, + 1434, + 1438, + 1452, + 1476, + 1478, + 1481, + 1487, + 1505, + 1516, + 1518, + 1533, + 1536, + 1537, + 1538, + 1544, + 1565, + 1580, + 1587, + 1596, + 1602, + 1614, + 1639, + 1684, + 1688, + 1699, + 1701, + 1707, + 1709, + 1710, + 1712, + 1718, + 1744, + 1749, + 1750, + 1758, + 1767, + 1785, + 1795, + 1799, + 1800, + 1815, + 1829, + 1845, + 1875, + 1895, + 1901, + 1904, + 1916, + 1947, + 1962, + 1968, + 1977, + 1981, + 1998, + 2007, + 2010, + 2011, + 2012, + 2018, + 2027, + 2047, + 2050, + 2051, + 2055, + 2058, + 2097, + 2107, + 2110, + 2122, + 2131, + 2136, + 2137, + 2141, + 2160, + 2185, + 2197, + 2202, + 2206, + 2211, + 2225, + 2234, + 2235, + 2237, + 2264, + 2270, + 2279, + 2284, + 2292, + 2293, + 2295, + 2304, + 2306, + 2307, + 2308, + 2316, + 2336, + 2348, + 2351, + 2352, + 2354, + 2360, + 2370, + 2372, + 2373, + 2374, + 2383 + ], + "count": 240, + "digest": "d0f4be32910813a50224c3b46bf9cd32b13ea0ad4cf7b0fed14d66ed49bc15d3", + "eligible": 1817 + }, + "protocols": { + "final": { + "num_scenarios": 500, + "num_stages": 24, + "seed": 1271152573, + "sha256": "dfda1f1f8173f636ebcddcaa406fc4d6dbc28d2fcea8e14cd311b725d6c1ba49" + }, + "screening": { + "excludes": "final", + "num_scenarios": 32, + "num_stages": 24, + "seed": 1553436292, + "sha256": "727280e639f0a0122a93893d58951c12e2d99adac9ddfc32fe4583dc09d4af9b" + } + }, + "regions": { + "corridors": [ + 10, + 11, + 37, + 38, + 48, + 51, + 52, + 60, + 61, + 148, + 187, + 189, + 264, + 344, + 460, + 462, + 509, + 549, + 558, + 566, + 667, + 680, + 688, + 698, + 720, + 723, + 731, + 758, + 839, + 956, + 1085, + 1095, + 1155, + 1187, + 1188, + 1250, + 1265, + 1323, + 1377, + 1483, + 1574, + 1648, + 1666, + 1728, + 1746, + 1834, + 1925, + 2109, + 2279, + 2303, + 2309, + 2321, + 2413, + 2428, + 2488, + 2497, + 2577, + 2614, + 2654, + 2673, + 2797, + 2815, + 2828, + 2868 + ], + "count": 6, + "demand_pu": [ + 60.747499999999974, + 57.23100000000002, + 41.34199999999997, + 39.39930000000003, + 25.859099999999998, + 21.2254 + ], + "demand_share": [ + 0.24713766195302508, + 0.23283156559913726, + 0.16819071106567282, + 0.16028726918121458, + 0.10520198385463556, + 0.08635080834631452 + ], + "digest": "6985ce2ddcc9be1e285c08de20a919889836c8c7229c92f8c235fe0bf48f048e", + "dispersion": 0.5150656743339495, + "effective_regions": 5.325051660926274, + "share_cap": 0.28, + "single_bus_exception": false, + "sizes": [ + 487, + 464, + 267, + 301, + 178, + 120 + ], + "sweeps": 14, + "unconstrained_dispersion": 0.5970870672653886, + "unconstrained_share": [ + 0.34926240102390427, + 0.2366569665380142, + 0.22720635887980783, + 0.1715352416536243, + 0.011132026575613197, + 0.004207005329036147 + ] + }, + "support": { + "sha256": "03fbb135e6b7413526c8a23662d604a44cdbf7661ea87f607e7ce7fa9ebfd472" + }, + "verification": { + "retreats": 0, + "stage_atom_checked": 144, + "stage_atom_failures": 0 + } + }, + { + "artifacts": { + "batteries.json": "3c7b333f557b8c4c02eaa6c2e0f3819dfbe2c6d6e7b5fcc0a01a3b919bbd9a55", + "demand.json": "2c39bc6cfdeaf340d1dc17811b487a35fe0a1ca9d975190c53102fd8c9db9210", + "network.json": "836e69e4ff0ec961b0fae3f985c4f3b36ec0ba29388d43146e9cf002268ef87b" + }, + "battery": { + "digest": "39befc63f04b5c0da314c7c62f14a78d7b98189ac747b3ba2d19cc01be4a36ec", + "energy_budget_puh": 1017.0077577907491, + "power_budget_pu": 127.12596972384364, + "power_max_pu": 6.3786433128420565, + "power_min_pu": 0.20186778110742165 + }, + "case": "pglib_opf_case240_pserc", + "counts": { + "battery": 48, + "branch": 448, + "bus": 240, + "eligible_bus": 137, + "gen": 143, + "load": 139 + }, + "kappa_case": 0.8817187499999999, + "kappa_evaluations": 14, + "kappa_max": 0.9281249999999999, + "kappa_retreats": 0, + "network_sha256": "55ac4949ffc21d1b02b502dd4731ba0cb28a0be8c3842e31c69bc6d755ba242e", + "nominal_demand_pu": 1441.7972819999989, + "peak_demand_pu": 1271.2596972384363, + "placement": { + "algorithm": "sha256-exponential-key weighted sampling without replacement", + "buses": [ + 1003, + 1004, + 1101, + 1301, + 1303, + 1401, + 1402, + 2000, + 2203, + 2403, + 2405, + 2406, + 2407, + 2409, + 2410, + 2411, + 2502, + 2503, + 2604, + 2615, + 2618, + 3103, + 3202, + 3204, + 3302, + 3304, + 3401, + 3806, + 3907, + 3917, + 3921, + 3922, + 4010, + 4102, + 4104, + 4201, + 4202, + 4203, + 5001, + 5002, + 6104, + 6201, + 6502, + 6510, + 7001, + 8003, + 8004, + 8005 + ], + "count": 48, + "digest": "f8a1353e84b14b8e572b4a2f471c97c7209856cfff78b9a36f68e3809e1949ce", + "eligible": 137 + }, + "protocols": { + "final": { + "num_scenarios": 500, + "num_stages": 24, + "seed": 504861337, + "sha256": "ec32b041c8a785dd0bf7bfe15eeff67145553002b0fe40a4bcaa7ed7b016a451" + }, + "screening": { + "excludes": "final", + "num_scenarios": 32, + "num_stages": 24, + "seed": 2046122276, + "sha256": "f38a9069cb79e792f5436485bf257195edb145db1e24bfaab72fd3eecbb41af5" + } + }, + "regions": { + "corridors": [ + 7, + 8, + 21, + 43, + 125, + 126, + 131, + 132, + 145, + 152, + 153, + 160, + 177, + 180, + 181, + 182, + 184, + 186, + 187, + 188, + 191, + 193, + 194, + 196, + 201, + 205, + 216, + 217, + 219, + 220, + 223, + 224, + 225, + 228, + 229, + 231, + 234, + 235, + 236, + 237, + 246, + 250, + 253, + 270, + 272, + 275, + 282, + 283, + 284, + 291, + 293, + 298, + 299, + 300, + 301, + 302, + 317, + 323, + 325, + 329, + 363, + 364, + 375, + 376 + ], + "count": 6, + "demand_pu": [ + 416.67905699999994, + 415.110027, + 222.62192499999998, + 163.013217, + 147.10294299999998, + 123.64749600000002 + ], + "demand_share": [ + 0.2799933816908514, + 0.2789390498056893, + 0.1495939490409212, + 0.10953903519114136, + 0.09884790170110844, + 0.08308668257028823 + ], + "digest": "afa9f80a6b67b9f5a3feefe330a3544f28124a00082c592a036b9c13f1877747", + "dispersion": 0.2892330289299731, + "effective_regions": 4.824980081218391, + "share_cap": 0.28, + "single_bus_exception": false, + "sizes": [ + 33, + 30, + 20, + 27, + 18, + 9 + ], + "sweeps": 9, + "unconstrained_dispersion": 0.2857898172400244, + "unconstrained_share": [ + 0.4471658271376366, + 0.32134620232901223, + 0.152275501209396, + 0.029838992051379933, + 0.026509396328152118, + 0.02286408094442328 + ] + }, + "support": { + "sha256": "7872541579c70ebeccd2b018c588a2398655ace45232e9d918bc7a5097ad2429" + }, + "verification": { + "retreats": 0, + "stage_atom_checked": 144, + "stage_atom_failures": 0 + } + }, + { + "artifacts": { + "batteries.json": "16308b24534cd04fadf235ea2eed8859bfb7ed500c0bfb8a47999839975ed546", + "demand.json": "f71894aec0405e06947e4cd315f90a9ae1bd45905b7d26a829fd0cb2d4aab0f1", + "network.json": "ddb075fe8f20a1f10fc8c76d352f1c8acc3e2e59af42e800979746646a5bcc07" + }, + "battery": { + "digest": "f0d49ebeac80f02e030b7f7031c58e55a6b17d36d9c79373c10ef1029193c296", + "energy_budget_puh": 155.05005515624998, + "power_budget_pu": 19.381256894531248, + "power_max_pu": 0.7930265380738565, + "power_min_pu": 0.03356726087085107 + }, + "case": "pglib_opf_case300_ieee", + "counts": { + "battery": 60, + "branch": 411, + "bus": 300, + "eligible_bus": 191, + "gen": 69, + "load": 201 + }, + "kappa_case": 0.8238281249999999, + "kappa_evaluations": 15, + "kappa_max": 0.8671875, + "kappa_retreats": 0, + "network_sha256": "e4520e1d6b832f34ffc68bb23fe34b1544e1aa5ddc9a2a1da50f35d5de8c7ecd", + "nominal_demand_pu": 235.25849999999997, + "peak_demand_pu": 193.81256894531245, + "placement": { + "algorithm": "sha256-exponential-key weighted sampling without replacement", + "buses": [ + 1, + 2, + 5, + 6, + 9, + 10, + 11, + 13, + 17, + 20, + 21, + 33, + 47, + 49, + 59, + 61, + 71, + 73, + 76, + 80, + 90, + 97, + 99, + 102, + 108, + 120, + 121, + 122, + 124, + 125, + 127, + 135, + 137, + 138, + 139, + 155, + 167, + 170, + 171, + 173, + 182, + 188, + 191, + 192, + 209, + 211, + 220, + 222, + 223, + 224, + 225, + 227, + 228, + 231, + 232, + 233, + 234, + 235, + 319, + 526 + ], + "count": 60, + "digest": "3a61af8bf3bb026222e35de070ab25eafd3d026182f175fd5f1868c529fdaee2", + "eligible": 191 + }, + "protocols": { + "final": { + "num_scenarios": 500, + "num_stages": 24, + "seed": 907620839, + "sha256": "580c71f45283942545e6162f01f9d0dae789cb9c4910ef47f4755fcc876d475a" + }, + "screening": { + "excludes": "final", + "num_scenarios": 32, + "num_stages": 24, + "seed": 131546072, + "sha256": "c2517d8eb172e2e9135ea002b48d541be4fc4cf25975be08521fa3e95169f7ac" + } + }, + "regions": { + "corridors": [ + 49, + 71, + 80, + 81, + 82, + 84, + 85, + 87, + 89, + 90, + 93, + 94, + 97, + 99, + 100, + 101, + 102, + 104, + 105, + 106, + 107, + 110, + 111, + 112, + 115, + 119, + 128, + 133, + 138, + 139, + 140, + 141, + 143, + 145, + 146, + 147, + 149, + 159, + 160, + 167, + 170, + 171, + 172, + 178, + 179, + 191, + 192, + 203, + 204, + 205, + 220, + 221, + 227, + 232, + 233, + 249, + 272, + 274, + 291, + 292, + 307, + 356, + 379, + 403 + ], + "count": 6, + "demand_pu": [ + 66.77000000000001, + 66.69700000000002, + 33.789, + 32.95100000000001, + 19.167400000000008, + 19.102099999999997 + ], + "demand_share": [ + 0.27998565896430044, + 0.2796795491379654, + 0.14168691674022385, + 0.13817294366530872, + 0.08037437651089312, + 0.08010055498130839 + ], + "digest": "2280ae1068bd7b1136e23d0214e3c8bc86f87034c20e4da41546d397a37f502a", + "dispersion": 0.18696201321127232, + "effective_regions": 4.79258406715442, + "share_cap": 0.28, + "single_bus_exception": false, + "sizes": [ + 34, + 27, + 37, + 38, + 44, + 11 + ], + "sweeps": 6, + "unconstrained_dispersion": 0.23664724983767427, + "unconstrained_share": [ + 0.6152660744350074, + 0.3471704759169142, + 0.02808662488756753, + 0.0038578224688805805, + 0.003530746216084183, + 0.002088256075546227 + ] + }, + "support": { + "sha256": "41f04864f56746b44487fab397db8f6960e6f9c975add20ba92df35468acf6bb" + }, + "verification": { + "retreats": 0, + "stage_atom_checked": 144, + "stage_atom_failures": 0 + } + }, + { + "artifacts": { + "batteries.json": "fb4a2f8e20ac4376f3a03e503a21aaf8c3f30dd291758fcc747dae7727c3d5e8", + "demand.json": "247001f91eacacc7b855bc77eae81f1a73c033b7c0de37cfab55ce78079bf21b", + "network.json": "296796946dfb593a678cde3e88f877f998ee3883949f9400bb2631450fe2469e" + }, + "battery": { + "digest": "bca6b83944879a2c5effd45d997e6939cc8707ff5d0d01dbb82b02b16023de43", + "energy_budget_puh": 153.22479287654912, + "power_budget_pu": 19.15309910956864, + "power_max_pu": 0.5283031751539662, + "power_min_pu": 0.047436788572256555 + }, + "case": "pglib_opf_case500_goc", + "counts": { + "battery": 100, + "branch": 733, + "bus": 500, + "eligible_bus": 281, + "gen": 224, + "load": 281 + }, + "kappa_case": 1.0776562499999998, + "kappa_evaluations": 10, + "kappa_max": 1.134375, + "kappa_retreats": 0, + "network_sha256": "4698ac3c5b4e68b759d16205a9e545ab4ce4979cba6dd217bdcceba0089afca5", + "nominal_demand_pu": 177.72920733832004, + "peak_demand_pu": 191.5309910956864, + "placement": { + "algorithm": "sha256-exponential-key weighted sampling without replacement", + "buses": [ + 4, + 5, + 12, + 13, + 15, + 18, + 24, + 31, + 32, + 35, + 37, + 38, + 42, + 45, + 46, + 47, + 48, + 53, + 57, + 65, + 67, + 74, + 76, + 86, + 89, + 92, + 99, + 101, + 105, + 107, + 109, + 110, + 111, + 112, + 113, + 114, + 120, + 122, + 123, + 125, + 132, + 134, + 138, + 139, + 143, + 148, + 150, + 153, + 155, + 157, + 158, + 163, + 165, + 166, + 170, + 171, + 172, + 174, + 175, + 177, + 181, + 183, + 186, + 187, + 189, + 192, + 194, + 195, + 196, + 197, + 199, + 200, + 207, + 209, + 213, + 219, + 221, + 224, + 233, + 235, + 236, + 238, + 242, + 246, + 248, + 251, + 254, + 255, + 256, + 257, + 258, + 260, + 271, + 279, + 294, + 296, + 315, + 333, + 384, + 397 + ], + "count": 100, + "digest": "d80591d10fe0e3e51914b4a216c28b6cf27f42cf51b52bdbce39e11bf77fca53", + "eligible": 281 + }, + "protocols": { + "final": { + "num_scenarios": 500, + "num_stages": 24, + "seed": 2140516806, + "sha256": "29c9ee37467a3c0a17554951dd8801dbcbf15fa43d405759a873c4ebdf3560b2" + }, + "screening": { + "excludes": "final", + "num_scenarios": 32, + "num_stages": 24, + "seed": 866645167, + "sha256": "fb7185b9abd31c5a16212afafaede2a248709ba5d8779989b876ecd0baafab3a" + } + }, + "regions": { + "corridors": [ + 21, + 22, + 29, + 33, + 43, + 60, + 61, + 95, + 107, + 114, + 116, + 119, + 132, + 138, + 173, + 188, + 194, + 203, + 209, + 212, + 254, + 262, + 285, + 290, + 293, + 303, + 309, + 310, + 313, + 315, + 341, + 342, + 377, + 378, + 383, + 386, + 390, + 400, + 401, + 402, + 409, + 410, + 418, + 425, + 426, + 427, + 434, + 435, + 447, + 452, + 456, + 462, + 463, + 466, + 498, + 502, + 505, + 511, + 512, + 516, + 524, + 538, + 539, + 733 + ], + "count": 6, + "demand_pu": [ + 49.70586711132, + 41.595525289, + 31.717166730000006, + 21.740756624, + 18.75049066, + 14.219400924000002 + ], + "demand_share": [ + 0.2796719113066284, + 0.23403877118418698, + 0.1784578190889253, + 0.12232517631508334, + 0.105500333573801, + 0.08000598853137501 + ], + "digest": "88e9d5dc24589f9a4c5a1e00c22aa9037221e63903cc8772cee4f469948e7ab5", + "dispersion": 0.3843555352629458, + "effective_regions": 5.067590382059831, + "share_cap": 0.28, + "single_bus_exception": false, + "sizes": [ + 78, + 57, + 52, + 43, + 22, + 29 + ], + "sweeps": 7, + "unconstrained_dispersion": 0.42873561408078653, + "unconstrained_share": [ + 0.6176080297560258, + 0.10865741550987183, + 0.1043210898066185, + 0.0920725698666399, + 0.06283096904125064, + 0.0145099260195934 + ] + }, + "support": { + "sha256": "2ed9da2e3837a8e7c0571e02f7e87a7f43957fa3071746447cf302e17ddbe1aa" + }, + "verification": { + "retreats": 0, + "stage_atom_checked": 144, + "stage_atom_failures": 0 + } + }, + { + "artifacts": { + "batteries.json": "c5ac6ec9a0e51f3def6b0586301980f2d4fa1850e167ae11e9cf3c988e4a7cc1", + "demand.json": "a42db78a0e2ba22dbd456dc1bd255860f5e7df3b9cc61de0dc560069980269dc", + "network.json": "f90f01476c09c44a05e74e23aab520eb03f7c50cdf71431fbd8a1fd92c6fc871" + }, + "battery": { + "digest": "b960978584853da92024e3e516378e7c09c5671c2d7333c9fe0f084cdbdb7817", + "energy_budget_puh": 101.28054499999996, + "power_budget_pu": 12.660068124999995, + "power_max_pu": 0.2625462535413682, + "power_min_pu": 0.0042210779778277885 + }, + "case": "pglib_opf_case588_sdet", + "counts": { + "battery": 118, + "branch": 686, + "bus": 588, + "eligible_bus": 371, + "gen": 167, + "load": 379 + }, + "kappa_case": 1.1875, + "kappa_evaluations": 1, + "kappa_max": 1.25, + "kappa_retreats": 0, + "network_sha256": "a4c991f3f18b9cda681974cd7e0b29a47fa88006ae799b58c780ac5f33a332be", + "nominal_demand_pu": 106.61109999999996, + "peak_demand_pu": 126.60068124999995, + "placement": { + "algorithm": "sha256-exponential-key weighted sampling without replacement", + "buses": [ + 1, + 5, + 15, + 17, + 20, + 26, + 28, + 32, + 40, + 53, + 57, + 58, + 59, + 76, + 82, + 88, + 91, + 93, + 96, + 97, + 102, + 110, + 111, + 118, + 123, + 124, + 125, + 131, + 136, + 140, + 142, + 150, + 153, + 159, + 160, + 161, + 162, + 163, + 176, + 179, + 181, + 183, + 184, + 185, + 189, + 191, + 193, + 194, + 198, + 199, + 208, + 210, + 214, + 217, + 219, + 221, + 224, + 230, + 249, + 260, + 268, + 276, + 286, + 293, + 296, + 298, + 336, + 354, + 360, + 362, + 365, + 366, + 374, + 376, + 380, + 386, + 389, + 392, + 393, + 406, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 416, + 420, + 423, + 425, + 430, + 436, + 455, + 456, + 458, + 459, + 469, + 474, + 519, + 529, + 537, + 538, + 540, + 544, + 546, + 548, + 550, + 551, + 552, + 555, + 559, + 560, + 566, + 572, + 573, + 577, + 578 + ], + "count": 118, + "digest": "a4aaf68efd837c7b2a872bc6a9778d94a0be4866e9ec50c8a7e8e3b394be2f54", + "eligible": 371 + }, + "protocols": { + "final": { + "num_scenarios": 500, + "num_stages": 24, + "seed": 655790276, + "sha256": "9115e685ce631ba604998ef5e5bf1ef9a43dd5abc68d7eba0de4447db534ef50" + }, + "screening": { + "excludes": "final", + "num_scenarios": 32, + "num_stages": 24, + "seed": 1711235758, + "sha256": "f43c020c30fbd5b68c3032cff22851f8b9787f3557f2fdb06a9edea28daa78ff" + } + }, + "regions": { + "corridors": [ + 42, + 44, + 46, + 102, + 122, + 126, + 133, + 170, + 178, + 183, + 185, + 186, + 190, + 205, + 217, + 219, + 226, + 227, + 229, + 247, + 250, + 252, + 253, + 254, + 272, + 274, + 279, + 284, + 285, + 312, + 321, + 357, + 390, + 397, + 427, + 440, + 504, + 517, + 538, + 539, + 543, + 550, + 556, + 561, + 567, + 568, + 569, + 571, + 581, + 583, + 584, + 589, + 593, + 595, + 596, + 597, + 620, + 649, + 650, + 652, + 660, + 673, + 681, + 683 + ], + "count": 6, + "demand_pu": [ + 25.2746, + 22.8033, + 17.981800000000003, + 16.7106, + 16.2694, + 8.6169 + ], + "demand_share": [ + 0.23477055749484935, + 0.21181516042676435, + 0.1670292392663339, + 0.1552213240990334, + 0.15112310810484447, + 0.0800406106081745 + ], + "digest": "1a2b47ccfb37ac23178b437526dca82c4ccb9da5400696d3038b0466bb2bf57d", + "dispersion": 0.3399688979111372, + "effective_regions": 5.518154843922105, + "share_cap": 0.28, + "single_bus_exception": false, + "sizes": [ + 19, + 47, + 59, + 92, + 131, + 23 + ], + "sweeps": 5, + "unconstrained_dispersion": 0.338898010986567, + "unconstrained_share": [ + 0.23477055749484935, + 0.21181516042676435, + 0.1670292392663339, + 0.1552213240990334, + 0.15434074641034548, + 0.07682297230267347 + ] + }, + "support": { + "sha256": "512ecad47f26aeae812c61a4d89c76cad86c2897d216ae9426977dbf75115616" + }, + "verification": { + "retreats": 0, + "stage_atom_checked": 144, + "stage_atom_failures": 0 + } + }, + { + "artifacts": { + "batteries.json": "def93afec18fbb5c745101af8e47917846d79eb2a9101343f043961424c6f77a", + "demand.json": "a970e77c3d2868d2146bb537a7a5eb267c2a7a5abc008cb8935fd53834fc863e", + "network.json": "1e6fa2d22de83f964ff323584a4019c3757bc0c9655cf12a47f32c4a9718f7c8" + }, + "battery": { + "digest": "080ec58e2f864495bb0413626fd8f2bb30e9c4b5814d14dbc5c128d6eb8af28a", + "energy_budget_puh": 112.14001091250003, + "power_budget_pu": 14.017501364062504, + "power_max_pu": 0.19289651199232657, + "power_min_pu": 0.003993007133630577 + }, + "case": "pglib_opf_case793_goc", + "counts": { + "battery": 159, + "branch": 913, + "bus": 793, + "eligible_bus": 503, + "gen": 214, + "load": 507 + }, + "kappa_case": 1.0620703125, + "kappa_evaluations": 10, + "kappa_max": 1.11796875, + "kappa_retreats": 0, + "network_sha256": "bb070579a5095543a2afb5534f1d3b294a12749a505aa934dec776eb19c02bd0", + "nominal_demand_pu": 131.98280000000003, + "peak_demand_pu": 140.17501364062502, + "placement": { + "algorithm": "sha256-exponential-key weighted sampling without replacement", + "buses": [ + 20, + 28, + 36, + 54, + 58, + 64, + 75, + 77, + 81, + 89, + 97, + 99, + 101, + 108, + 112, + 118, + 129, + 131, + 132, + 134, + 137, + 142, + 145, + 152, + 153, + 168, + 171, + 173, + 191, + 195, + 208, + 214, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 229, + 231, + 235, + 236, + 243, + 245, + 248, + 249, + 251, + 252, + 253, + 254, + 257, + 274, + 277, + 279, + 294, + 298, + 303, + 304, + 308, + 313, + 331, + 336, + 342, + 345, + 348, + 351, + 355, + 363, + 367, + 377, + 378, + 381, + 387, + 392, + 398, + 401, + 405, + 413, + 417, + 441, + 443, + 447, + 454, + 457, + 460, + 477, + 480, + 482, + 484, + 486, + 487, + 488, + 489, + 494, + 497, + 498, + 500, + 501, + 503, + 506, + 511, + 512, + 514, + 520, + 521, + 523, + 524, + 527, + 534, + 541, + 542, + 547, + 550, + 553, + 579, + 581, + 586, + 593, + 599, + 600, + 604, + 610, + 617, + 626, + 627, + 630, + 631, + 635, + 641, + 642, + 645, + 647, + 649, + 657, + 667, + 674, + 675, + 676, + 678, + 679, + 683, + 684, + 688, + 689, + 690, + 698, + 700, + 702, + 707, + 711, + 720, + 740, + 749, + 751, + 762, + 780, + 781 + ], + "count": 159, + "digest": "ff0736165167fc129018428e7950345c68d0c242bb1bbc863bb9efea83e5e409", + "eligible": 503 + }, + "protocols": { + "final": { + "num_scenarios": 500, + "num_stages": 24, + "seed": 10432006, + "sha256": "afb76107757abcda55945ea17dce03c06aea7e6d733134cfaf995c70a3db3eb5" + }, + "screening": { + "excludes": "final", + "num_scenarios": 32, + "num_stages": 24, + "seed": 1605791441, + "sha256": "bc830a6b6304b7c35bf6b93499f5b880c926765c3dac77310cb1b445864c74dc" + } + }, + "regions": { + "corridors": [ + 23, + 96, + 104, + 125, + 130, + 140, + 144, + 150, + 169, + 188, + 203, + 209, + 215, + 218, + 219, + 220, + 222, + 224, + 231, + 238, + 251, + 253, + 330, + 340, + 348, + 349, + 356, + 362, + 367, + 376, + 382, + 391, + 395, + 398, + 399, + 402, + 405, + 412, + 415, + 418, + 423, + 431, + 434, + 436, + 437, + 439, + 442, + 485, + 562, + 573, + 670, + 673, + 677, + 680, + 686, + 690, + 694, + 698, + 705, + 716, + 735, + 744, + 755, + 852 + ], + "count": 6, + "demand_pu": [ + 36.59234999999999, + 26.579069999999984, + 23.4803, + 16.432589999999983, + 15.272560000000004, + 13.823730000000005 + ], + "demand_share": [ + 0.27683601073077285, + 0.20108147489117154, + 0.17763801949756625, + 0.12431922687595598, + 0.1155431281141106, + 0.10458213989042271 + ], + "digest": "c048efd9fb8d90fc320c8fd389b370fd725e981bbfe9258848502f01dd10cf1a", + "dispersion": 0.4575205489371816, + "effective_regions": 5.308697833704804, + "share_cap": 0.28, + "single_bus_exception": false, + "sizes": [ + 96, + 173, + 28, + 125, + 53, + 28 + ], + "sweeps": 6, + "unconstrained_dispersion": 0.4971951036700998, + "unconstrained_share": [ + 0.41967467238006173, + 0.20336516856482714, + 0.17763801949756625, + 0.12431922687595598, + 0.05460521438093034, + 0.020397698300658344 + ] + }, + "support": { + "sha256": "cfe6aac5690e50b524d5856291993365cbb11a73acfe8000b8561f9b5601b0fd" + }, + "verification": { + "retreats": 0, + "stage_atom_checked": 144, + "stage_atom_failures": 0 + } + }, + { + "artifacts": { + "batteries.json": "c3855131854e197fd36638a1ec43d13af4b9d651e346c0748f2f9b7590bdb5e2", + "demand.json": "462cd27c15dd09bb3949b125a7efecc41677b7b9c102356583b9e258e72f6de1", + "network.json": "3008f8f8453c37e28efdc3deb12cbb5595f1663ed49fc3b90403d4b7a1f90d0a" + }, + "battery": { + "digest": "76dafcaed3eb9f31a7a69a0b8ad2a30d4a7f6b410f5420973ebb89c9bea45dd7", + "energy_budget_puh": 537.9018203750002, + "power_budget_pu": 67.23772754687502, + "power_max_pu": 0.6893939841181314, + "power_min_pu": 0.02521692280586277 + }, + "case": "pglib_opf_case1354_pegase", + "counts": { + "battery": 240, + "branch": 1991, + "bus": 1354, + "eligible_bus": 621, + "gen": 260, + "load": 673 + }, + "kappa_case": 0.9203125, + "kappa_evaluations": 13, + "kappa_max": 0.96875, + "kappa_retreats": 0, + "network_sha256": "0d83e4fec87e37090ce671ba0e5452c1c52de4243074283eee682b3b4a708c9b", + "nominal_demand_pu": 730.5967000000003, + "peak_demand_pu": 672.3772754687502, + "placement": { + "algorithm": "sha256-exponential-key weighted sampling without replacement", + "buses": [ + 10, + 21, + 26, + 59, + 118, + 171, + 174, + 207, + 216, + 280, + 305, + 333, + 346, + 408, + 455, + 513, + 594, + 608, + 641, + 658, + 678, + 707, + 747, + 772, + 883, + 905, + 908, + 953, + 980, + 1026, + 1035, + 1081, + 1129, + 1156, + 1159, + 1179, + 1183, + 1249, + 1265, + 1301, + 1380, + 1398, + 1486, + 1541, + 1562, + 1592, + 1607, + 1625, + 1767, + 1813, + 1860, + 1866, + 1917, + 1923, + 1965, + 2019, + 2057, + 2089, + 2128, + 2166, + 2252, + 2286, + 2288, + 2327, + 2360, + 2377, + 2432, + 2526, + 2535, + 2558, + 2563, + 2591, + 2598, + 2629, + 2654, + 2676, + 2732, + 2848, + 2898, + 2940, + 2968, + 3021, + 3037, + 3072, + 3083, + 3121, + 3145, + 3200, + 3221, + 3344, + 3377, + 3391, + 3499, + 3526, + 3613, + 3643, + 3645, + 3657, + 3707, + 3718, + 3758, + 3760, + 3834, + 3866, + 3929, + 3975, + 3994, + 4032, + 4103, + 4144, + 4185, + 4189, + 4239, + 4300, + 4313, + 4314, + 4324, + 4353, + 4426, + 4505, + 4511, + 4562, + 4656, + 4674, + 4683, + 4710, + 4738, + 4747, + 4787, + 4829, + 4831, + 4867, + 4885, + 4936, + 4939, + 4942, + 4950, + 4951, + 5003, + 5049, + 5106, + 5213, + 5256, + 5286, + 5317, + 5400, + 5410, + 5419, + 5420, + 5441, + 5469, + 5525, + 5574, + 5691, + 5720, + 5735, + 5764, + 5853, + 5957, + 6053, + 6071, + 6101, + 6110, + 6151, + 6178, + 6246, + 6357, + 6382, + 6416, + 6478, + 6495, + 6510, + 6630, + 6639, + 6691, + 6791, + 6828, + 6846, + 6891, + 6909, + 6926, + 6952, + 7050, + 7069, + 7070, + 7129, + 7132, + 7226, + 7256, + 7273, + 7342, + 7380, + 7473, + 7579, + 7624, + 7626, + 7640, + 7700, + 7752, + 7770, + 7775, + 7809, + 7895, + 7905, + 7937, + 7955, + 7972, + 7982, + 8057, + 8180, + 8293, + 8439, + 8448, + 8494, + 8497, + 8651, + 8653, + 8669, + 8689, + 8691, + 8704, + 8707, + 8732, + 8748, + 8788, + 8808, + 8809, + 8825, + 8843, + 8853, + 8854, + 8874, + 8893, + 9018, + 9019, + 9021, + 9045, + 9130, + 9203, + 9231 + ], + "count": 240, + "digest": "8c41eb42454a6db54ceaa6aa2a6a29e7a06a7c24fe2081333a6a2ca6e780dc84", + "eligible": 621 + }, + "protocols": { + "final": { + "num_scenarios": 500, + "num_stages": 24, + "seed": 795941078, + "sha256": "064233cdf608bf555c4c6482141a235d3a358d7f50b0178b61fa8b68d7f9515f" + }, + "screening": { + "excludes": "final", + "num_scenarios": 32, + "num_stages": 24, + "seed": 1023704750, + "sha256": "486b17892ce1a515945e353e6442b18eb96d3a4be4879ae696d4585e73c1a5a3" + } + }, + "regions": { + "corridors": [ + 212, + 247, + 250, + 251, + 253, + 255, + 299, + 491, + 492, + 494, + 498, + 499, + 523, + 524, + 527, + 536, + 615, + 672, + 694, + 695, + 696, + 697, + 706, + 713, + 716, + 721, + 733, + 736, + 787, + 855, + 856, + 857, + 872, + 897, + 914, + 942, + 1005, + 1006, + 1009, + 1018, + 1019, + 1020, + 1038, + 1086, + 1147, + 1148, + 1150, + 1213, + 1226, + 1248, + 1264, + 1287, + 1288, + 1361, + 1421, + 1438, + 1451, + 1579, + 1638, + 1678, + 1754, + 1825, + 1826, + 1868 + ], + "count": 6, + "demand_pu": [ + 207.60800000000015, + 207.36730000000003, + 116.14960000000006, + 88.70859999999999, + 62.263900000000014, + 59.36269999999998 + ], + "demand_share": [ + 0.27999888328448164, + 0.2796742535437847, + 0.1566498318655313, + 0.11964042299781197, + 0.08397471421590992, + 0.08006189409248045 + ], + "digest": "3dd1185169fc4ee8e5b06d4007dc40c10f355c76f2dcbebea8af9479dc0317e1", + "dispersion": 0.25191808777795155, + "effective_regions": 4.786252590935108, + "share_cap": 0.28, + "single_bus_exception": false, + "sizes": [ + 222, + 116, + 113, + 70, + 47, + 53 + ], + "sweeps": 7, + "unconstrained_dispersion": 0.2902143589632836, + "unconstrained_share": [ + 0.6700181169559898, + 0.1202670244831785, + 0.11964042299781197, + 0.07370592159982713, + 0.009687372253746355, + 0.006681141709445996 + ] + }, + "support": { + "sha256": "dadc8cb29b2ef9ad0db9e04caf6908ba07a88c1991b0ee032f473bf1b83d45f2" + }, + "verification": { + "retreats": 0, + "stage_atom_checked": 144, + "stage_atom_failures": 0 + } + }, + { + "artifacts": { + "batteries.json": "ab965cf8052d351958eb6168792cf13a0ad7e3cd96651154c7cc64ff50b2abe5", + "demand.json": "dfee214e7eef1f9d25afa303bb81973b20faeb48ee15355d472267e157bb2dd7", + "network.json": "ccd0c31ba1e6cd862f2600c8cf29ba0041b5cef6a53fdecfd0a8904e354b3253" + }, + "battery": { + "digest": "a399dcb321cc1eaa3a85aaed3c8417529e68cf80e41709fa36c07fd7c1635ad9", + "energy_budget_puh": 287.98747422024024, + "power_budget_pu": 35.99843427753003, + "power_max_pu": 0.410437406270644, + "power_min_pu": 0.02670081554590348 + }, + "case": "pglib_opf_case2000_goc", + "counts": { + "battery": 240, + "branch": 3639, + "bus": 2000, + "eligible_bus": 1010, + "gen": 384, + "load": 1010 + }, + "kappa_case": 1.0917578124999998, + "kappa_evaluations": 10, + "kappa_max": 1.14921875, + "kappa_retreats": 0, + "network_sha256": "3bdcedc723e36b8bd1711265704c38e19027120a13e40e5c1b7a77069f54bade", + "nominal_demand_pu": 329.72912000599985, + "peak_demand_pu": 359.9843427753003, + "placement": { + "algorithm": "sha256-exponential-key weighted sampling without replacement", + "buses": [ + 3, + 5, + 6, + 7, + 11, + 13, + 16, + 21, + 27, + 30, + 45, + 75, + 92, + 95, + 99, + 108, + 128, + 140, + 145, + 162, + 163, + 167, + 169, + 179, + 199, + 204, + 206, + 213, + 225, + 226, + 229, + 236, + 237, + 241, + 245, + 246, + 247, + 255, + 259, + 262, + 267, + 270, + 282, + 285, + 286, + 287, + 290, + 295, + 298, + 302, + 303, + 315, + 320, + 330, + 336, + 339, + 346, + 356, + 357, + 378, + 384, + 388, + 402, + 414, + 423, + 432, + 436, + 455, + 463, + 468, + 475, + 480, + 484, + 490, + 491, + 507, + 607, + 624, + 627, + 629, + 633, + 634, + 635, + 649, + 652, + 654, + 656, + 659, + 664, + 667, + 672, + 681, + 697, + 701, + 704, + 707, + 709, + 738, + 742, + 754, + 756, + 761, + 762, + 764, + 767, + 774, + 777, + 778, + 788, + 789, + 792, + 805, + 807, + 820, + 822, + 826, + 828, + 831, + 832, + 834, + 838, + 852, + 854, + 859, + 862, + 865, + 869, + 870, + 871, + 884, + 898, + 899, + 908, + 914, + 927, + 935, + 947, + 959, + 976, + 978, + 980, + 992, + 1033, + 1041, + 1047, + 1062, + 1064, + 1071, + 1084, + 1085, + 1088, + 1096, + 1097, + 1113, + 1123, + 1138, + 1140, + 1143, + 1148, + 1149, + 1156, + 1159, + 1163, + 1176, + 1186, + 1193, + 1199, + 1204, + 1491, + 1500, + 1503, + 1518, + 1523, + 1524, + 1526, + 1530, + 1538, + 1552, + 1555, + 1556, + 1561, + 1565, + 1569, + 1576, + 1577, + 1578, + 1583, + 1584, + 1586, + 1588, + 1592, + 1599, + 1604, + 1605, + 1606, + 1608, + 1610, + 1628, + 1629, + 1640, + 1641, + 1642, + 1648, + 1651, + 1653, + 1656, + 1664, + 1667, + 1669, + 1677, + 1678, + 1687, + 1696, + 1697, + 1703, + 1710, + 1717, + 1720, + 1730, + 1733, + 1742, + 1746, + 1748, + 1755, + 1767, + 1772, + 1778, + 1779, + 1780, + 1781, + 1784, + 1785, + 1787, + 1790, + 1829, + 1833, + 1837, + 1841, + 1846, + 1854 + ], + "count": 240, + "digest": "8d3b59e4c862d424acf88d23d879624322fafb07b8860fbd30d97420be9b6302", + "eligible": 1010 + }, + "protocols": { + "final": { + "num_scenarios": 500, + "num_stages": 24, + "seed": 130404710, + "sha256": "1e0c76896159f6dc875d037f4beda627a1ef267b53a2f8a974d0f1ddae579e1b" + }, + "screening": { + "excludes": "final", + "num_scenarios": 32, + "num_stages": 24, + "seed": 99727030, + "sha256": "5628d0fb58fbb94a38e0a3712dc1e1eeb934959c057a53b64a2a9d51d364faf3" + } + }, + "regions": { + "corridors": [ + 558, + 566, + 696, + 737, + 739, + 740, + 755, + 797, + 855, + 891, + 892, + 893, + 951, + 991, + 992, + 1042, + 1072, + 1099, + 1103, + 1104, + 1123, + 1124, + 1144, + 1147, + 1168, + 1169, + 1175, + 1178, + 1180, + 1183, + 1185, + 1186, + 1496, + 1505, + 1507, + 1509, + 1511, + 1515, + 1517, + 1518, + 1752, + 1763, + 1793, + 1800, + 1812, + 1814, + 1816, + 1820, + 1822, + 1827, + 1838, + 1865, + 1878, + 1927, + 1932, + 1943, + 1979, + 1992, + 1995, + 2015, + 2048, + 2072, + 2074, + 2075 + ], + "count": 6, + "demand_pu": [ + 92.32391831009997, + 92.250487199, + 65.82313664889998, + 26.568426782999996, + 26.382714007999997, + 26.380437057000005 + ], + "demand_share": [ + 0.2799992864094624, + 0.27977658508693853, + 0.199627914718913, + 0.08057652530815763, + 0.08001329699821455, + 0.080006391478314 + ], + "digest": "c90cf8d0471875eba5d2ef849df2c533491f40ed8a5e2a131b992f582bd4a701", + "dispersion": 0.1389876666613602, + "effective_regions": 4.633457185050667, + "share_cap": 0.28, + "single_bus_exception": false, + "sizes": [ + 338, + 197, + 188, + 105, + 105, + 77 + ], + "sweeps": 10, + "unconstrained_dispersion": 0.12661299284635213, + "unconstrained_share": [ + 0.5492041578120396, + 0.2903165222933848, + 0.05470939320637421, + 0.04754150857441636, + 0.0429705435896659, + 0.015257874524119842 + ] + }, + "support": { + "sha256": "c6ec8360619dcdd0074196da0fc8fcb09248990b5da2f8f6dae851aca519c06d" + }, + "verification": { + "retreats": 0, + "stage_atom_checked": 144, + "stage_atom_failures": 0 + } + } + ], + "command": "julia --project=. battery_portfolio.jl --case --out ", + "digest": "11c2f58fabbac489812d86fa2aef95833c54acaac12347337e54940a29ccb1d9", + "horizon": 24, + "panel": { + "accepted": [ + "pglib_opf_case118_ieee", + "pglib_opf_case1951_rte", + "pglib_opf_case2383wp_k", + "pglib_opf_case240_pserc", + "pglib_opf_case300_ieee", + "pglib_opf_case500_goc", + "pglib_opf_case588_sdet", + "pglib_opf_case793_goc", + "pglib_opf_case1354_pegase", + "pglib_opf_case2000_goc" + ], + "primary": [ + "pglib_opf_case118_ieee", + "pglib_opf_case162_ieee_dtc", + "pglib_opf_case179_goc", + "pglib_opf_case200_activ", + "pglib_opf_case240_pserc", + "pglib_opf_case300_ieee", + "pglib_opf_case500_goc", + "pglib_opf_case588_sdet", + "pglib_opf_case793_goc", + "pglib_opf_case1354_pegase", + "pglib_opf_case1888_rte", + "pglib_opf_case2000_goc" + ], + "replacement_rule": "a primary case is replaced only when it is unavailable from the pinned PGLib version or when its unmodified base ACP fails at demand level 0.5; a SOC, DC or method failure is never a reason to replace a case", + "replacements": [ + { + "dropped": "pglib_opf_case162_ieee_dtc", + "promoted": "pglib_opf_case1951_rte", + "reason": "the unmodified base ACP clears the gate at no level of [0.5, 1.25]; the conservative level 0.5 fails" + }, + { + "dropped": "pglib_opf_case179_goc", + "promoted": "pglib_opf_case2312_goc", + "reason": "the unmodified base ACP clears the gate at no level of [0.5, 1.25]; the conservative level 0.5 fails" + }, + { + "dropped": "pglib_opf_case2312_goc", + "promoted": "pglib_opf_case2383wp_k", + "reason": "the unmodified base ACP clears the gate at no level of [0.5, 1.25]; the conservative level 0.5 fails" + }, + { + "dropped": "pglib_opf_case200_activ", + "promoted": "pglib_opf_case2736sp_k", + "reason": "the unmodified base ACP clears the gate at no level of [0.5, 1.25]; the conservative level 0.5 fails" + }, + { + "dropped": "pglib_opf_case2736sp_k", + "promoted": "", + "reason": "the unmodified base ACP clears the gate at no level of [0.5, 1.25]; the conservative level 0.5 fails" + }, + { + "dropped": "pglib_opf_case1888_rte", + "promoted": "", + "reason": "the unmodified base ACP clears the gate at no level of [0.5, 1.25]; the conservative level 0.5 fails" + } + ], + "reserve": [ + "pglib_opf_case1951_rte", + "pglib_opf_case2312_goc", + "pglib_opf_case2383wp_k", + "pglib_opf_case2736sp_k" + ], + "unfilled": [ + { + "last_candidate": "pglib_opf_case2736sp_k", + "reason": "the preregistered reserve list is exhausted", + "slot": "pglib_opf_case200_activ" + }, + { + "last_candidate": "pglib_opf_case1888_rte", + "reason": "the preregistered reserve list is exhausted", + "slot": "pglib_opf_case1888_rte" + } + ] + }, + "profile": [ + 0.72, + 0.68, + 0.65, + 0.64, + 0.66, + 0.72, + 0.8, + 0.88, + 0.94, + 0.98, + 1.0, + 0.99, + 0.97, + 0.95, + 0.94, + 0.96, + 1.0, + 1.0, + 0.98, + 0.94, + 0.9, + 0.84, + 0.79, + 0.75 + ], + "protocols": { + "algorithm": "stage-major StableRNG draw from the frozen support; the screening protocol is drawn from an independent seed and repaired against the final protocol's columns, so the two panels are disjoint by construction", + "final_scenarios": 500, + "num_stages": 24, + "screening_scenarios": 32, + "seed_rule": "SHA256(\"battery_storage_opf/portfolio/1\\nprotocol/\\n20260814\\n\\nseed\\n\") reduced into 1:2^31-1" + }, + "regions": { + "algorithm": "demand-BALANCED assignment over unit-norm PTDF sensitivity signatures on the highest-reach rated corridors: farthest-point initialization, then Lloyd sweeps whose assignment step is a HiGHS integer program minimizing demand-weighted signature distance subject to per-region demand-share bounds; regions relabelled by descending demand", + "balance_iterations": 20, + "count": 6, + "high": 1.15, + "low": 0.97, + "max_corridors": 64, + "min_effective_regions": 4.5, + "modes": [ + 1.15, + 0.97 + ], + "probabilities": [ + 0.16666666666666666, + 0.16666666666666666, + 0.16666666666666666, + 0.16666666666666666, + 0.16666666666666666, + 0.16666666666666666 + ], + "share_max": 0.28, + "share_min": 0.08, + "support_mean": 1.0 + }, + "schema": "battery_storage_opf/portfolio/1", + "seed": 20260814, + "stage_hours": 1.0, + "versions": { + "Clarabel": "0.11.1", + "Ipopt": "1.15.0", + "JuMP": "1.31.1", + "PGLib": "0.2.2", + "PowerModels": "0.21.6", + "SDDP": "1.14.0", + "StableRNGs": "1.0.4", + "julia": "1.12.5" + } +} \ No newline at end of file diff --git a/examples/BatteryStorageOPF/battery_reachable_policy.jl b/examples/BatteryStorageOPF/battery_reachable_policy.jl new file mode 100644 index 0000000..5042391 --- /dev/null +++ b/examples/BatteryStorageOPF/battery_reachable_policy.jl @@ -0,0 +1,642 @@ +# battery_reachable_policy.jl +# +# The strict storage policies of this study: a recurrent encoder over the +# observed demand history, a head, and a differentiable affine map from the +# head's bounded output into the battery-dynamic one-stage reachable interval. +# +# TWO ARCHITECTURES, ONE FEASIBILITY LAYER. +# `:tsddr_nonlinear` is the original: an LSTM encoder and a nonlinear head whose +# output activation is bounded. `:tsldr_recurrent_linear` is a structured +# recurrent parameterization of a TIME-SERIES LINEAR DECISION RULE for the +# storage-state targets: every trainable map in its encoder, its recurrent +# update and its output head is affine, so its RAW target is an affine causal +# function of the observed demand history (see [`raw_target_step`](@ref)). Both +# emit that raw target into the SAME strict feasibility layer, +# [`feasible_target`](@ref), which is what makes every target reachable by +# construction in both. The recourse variables of the stage problem are NOT +# decision rules in either architecture: they are optimized by the stage ACP. +# +# Every target this policy emits is reachable BY CONSTRUCTION, which is what +# makes the hard target equality of the stage problem well posed. There is no +# target slack and no target penalty anywhere in this file or in the model it +# feeds. +# +# THE GRADIENT THAT MUST NOT BE TRUNCATED. +# The emitted target is +# +# x̂_t = l_t(e_{t-1}) + (u_t(e_{t-1}) − l_t(e_{t-1})) ⊙ y_t , +# +# and BOTH endpoints depend on the incoming energy with slope α wherever the +# energy bound is not the binding term. In strict mode the incoming energy IS +# the previous stage's emitted target, so +# +# ∂x̂_t/∂e_{t-1} = α (1 − y_t) on coordinates whose lower bound is the +# power-limited one, plus α y_t on those whose +# upper bound is the power-limited one, +# +# is exactly the term that couples the stages. Declaring the reachable bounds +# nondifferentiable truncates the adjoint recursion at EVERY stage, not only +# where a bound binds, and the error compounds with the horizon. The identical +# defect was measured on the hydro study's policy: it left the applied update at +# cosine 0.67 and 6 % of the correct magnitude against finite differences. The +# bounds here are therefore fully differentiable, and only the CONSTANT metadata +# adapters — which merely move frozen numbers onto the right device — are hidden +# from the AD tape. + +using Flux +using Zygote +import DecisionRulesExa: load_stateconditioned_policy! + +""" + stretchedsigmoid(x) -> y ∈ [0, 1 − 1e-3] + +Boundary-attaining squashing function: `clamp((σ(x) − 0.03)/0.94, 0, 1 − 1e-3)`. + +# Notes +A plain sigmoid reaches 0 and 1 only in the limit, so a policy squashed by it +can never place a target exactly at an endpoint of the reachable interval — +which is where an optimal storage decision very often is (charge as hard as +possible, or discharge as hard as possible). The gentle 6.4 % stretch attains +exactly 0 for ``\\sigma(x) \\le 0.03`` while keeping the interior mapping close +to the sigmoid's shape. + +The upper end stops a hair short of 1 on purpose. An exact upper endpoint forces +the charge control to sit exactly at its bound with the discharge control +exactly at zero — a measure-zero face that an interior-point solver cannot +converge into once the strict equality pins the state there. The lower endpoint +has no such problem, because the discharge control retains a strict interior +there, so 0 is attained exactly. +""" +function stretchedsigmoid(x::Real) + T = float(typeof(x)) + return clamp((NNlib.sigmoid(x) - T(0.03)) / T(0.94), zero(T), one(T) - T(1e-3)) +end + +"Activations whose range lies inside [0,1], so the affine map into the reachable interval stays feasible." +const BOUNDED_ACTIVATIONS = (NNlib.sigmoid, NNlib.sigmoid_fast, NNlib.hardsigmoid, stretchedsigmoid) + +raw""" +The two strict storage-target architectures of this study, as stable identifiers. + +- `:tsddr_nonlinear` — an LSTM encoder over the observed demand and a nonlinear + head that also reads the incoming energy. Its raw target is a nonlinear + function of the history AND of the state. +- `:tsldr_recurrent_linear` — a structured recurrent parameterization of a + time-series LINEAR decision rule for the storage-state targets: + + ```math + h_t = A h_{t-1} + B \xi_t + b, \qquad z_t = C h_t + D \xi_t + d, + ``` + + with ``\xi_t = [\text{context}_t; \text{observation}_t]`` the stage's + deterministic clock features concatenated with the realized per-bus active + demand. Unrolled from ``h_0 = 0`` this is + + ```math + z_t = \sum_{k=1}^{t} C A^{t-k} B\, \xi_k + D \xi_t + + \Big(\sum_{j=0}^{t-1} C A^{j} b\Big) + d, + ``` + + an AFFINE, CAUSAL function of the observed history — which is what makes the + name accurate. The trainable map does not read the incoming energy at all: the + state enters only through the shared feasibility layer, whose interval + endpoints are functions of ``e_{t-1}``. Reading the state in the head would + make the raw target a nonlinear function of the history, because the incoming + energy is the PREVIOUS stage's squashed target. + +Neither architecture parameterizes the stage's recourse variables. Every +dispatch decision — generation, charge/discharge split, voltages, the two nodal +recourse injections — is optimized by the stage ACP problem; only the outgoing +storage-state target follows a decision rule. +""" +const BATTERY_ARCHITECTURES = (:tsddr_nonlinear, :tsldr_recurrent_linear) + +""" + BatteryReachablePolicy + +A strict, state-conditioned battery policy. + +# Fields +- `encoder`: recurrent chain over `[context_t; observation_t]`. +- `combiner`: feed-forward head; see [`_head_input`](@ref) for what it reads. +- `state`: the encoder's recurrent state, threaded across stages explicitly. +- `architecture::Symbol`: one of [`BATTERY_ARCHITECTURES`](@ref). +- `n_context::Int`: context rows prepended before the observation. +- `n_observation::Int`: observation rows (the observed demand). +- `n_battery::Int`: number of batteries, i.e. the output width. +- `energy_min`, `energy_max`, `charge_gain`, `discharge_drop`, `alpha`: + per-battery reachability metadata (see [`reachable_bounds`](@ref)). + +# Notes +In `:tsddr_nonlinear` the incoming energy enters TWICE: as an input to the head, +and inside the reachable bounds. Only the second of those couples the stages, +and it is the one an earlier generation of this code got wrong. In +`:tsldr_recurrent_linear` only the second path exists, by design. + +The encoder is recurrent over the observed UNCERTAINTY only; the state does not +enter the recurrent chain. Flux ≥ 0.16 recurrent cells are stateless, so the +state is threaded by hand here — calling the `LSTM` wrapper directly would +silently restart from `initialstates` every stage and produce a MEMORYLESS +encoder that trains, reduces loss, and answers a different question. +""" +mutable struct BatteryReachablePolicy{E,C,RS,V} + encoder::E + combiner::C + state::RS + architecture::Symbol + n_context::Int + n_observation::Int + n_battery::Int + energy_min::V + energy_max::V + charge_gain::V # η^{ch} Δt \overline p^{ch} + discharge_drop::V # Δt \overline p^{dis} / η^{dis} + alpha::V # α, the per-stage retention factor +end + +Flux.@layer BatteryReachablePolicy trainable=(encoder, combiner) + +""" + _adapt_metadata(x, ref) -> AbstractVector + +Return the frozen metadata vector `x` with `ref`'s element type and device. + +# Notes +The returned VALUES are `x`, frozen policy metadata; `ref` contributes only an +element type and a device family. The map is therefore constant in both +arguments and the `Zygote.@nograd` declaration below is EXACT rather than an +approximation. It is needed because the device adaptation goes through +`similar` + `copyto!` and Zygote refuses to differentiate array mutation — +without it the (fully differentiable) reachable bounds could not be traced at +all. This is the ONLY thing hidden from the tape in this file. +""" +function _adapt_metadata(x::AbstractVector, ref::AbstractArray) + typeof(x) === typeof(ref) && return x + y = similar(ref, length(x)) + copyto!(y, convert.(eltype(ref), x)) + return y +end +Zygote.@nograd _adapt_metadata + +""" + reachable_bounds(policy, e_prev, ref) -> (lower, upper) + +Vectorized one-stage reachable interval for every battery. + +# Arguments +- `policy::BatteryReachablePolicy`: carries the frozen reachability metadata. +- `e_prev`: incoming energy, a vector (one scenario) or a matrix (batched, + batteries × scenarios). +- `ref`: array supplying the working element type and device. + +# Returns +- `(lower, upper)`, broadcast-compatible with `e_prev`. + +# Notes +This is the vectorized form of `reachable_interval` in the shared case contract: + +```math +\\underline r = \\max\\{\\underline e,\\; \\alpha e_{t-1} - \\Delta t\\, + \\overline p^{dis}/\\eta^{dis}\\}, +\\qquad +\\overline r = \\min\\{\\overline e,\\; \\alpha e_{t-1} + \\eta^{ch}\\Delta t\\, + \\overline p^{ch}\\}. +``` + +DIFFERENTIABLE in `e_prev`, and that is load-bearing — see the note at the top +of this file. `max`/`min` are subdifferentiable and Zygote's pullback selects the +active branch, which is the correct one-sided derivative away from the kink; the +gradient gate measures the distance to the nearest kink before it differences. + +`upper` is finally clamped from below by `lower`. The two can only cross when +the battery's own bounds are inconsistent with its power ratings, which the case +verifier rejects; the clamp keeps the affine map well defined rather than +papering over data that got that far. +""" +function reachable_bounds(policy::BatteryReachablePolicy, e_prev, ref) + e_min = _adapt_metadata(policy.energy_min, ref) + e_max = _adapt_metadata(policy.energy_max, ref) + gain = _adapt_metadata(policy.charge_gain, ref) + drop = _adapt_metadata(policy.discharge_drop, ref) + α = _adapt_metadata(policy.alpha, ref) + + decayed = α .* e_prev + lower = max.(e_min, decayed .- drop) + upper = min.(e_max, decayed .+ gain) + return lower, max.(upper, lower) +end + +# Row slice that behaves for a vector input (one scenario) and for a matrix +# input (features × scenarios). Plain `input[r]` on a matrix does LINEAR +# indexing and would silently corrupt a batched call. +_row_slice(input::AbstractVector, r) = input[r] +_row_slice(input::AbstractMatrix, r) = input[r, :] + +""" + policy_step(policy, state, input) -> (target, new_state) + +Advance the policy by one stage, PURELY: nothing is mutated. + +# Arguments +- `policy::BatteryReachablePolicy`: the trainable policy. +- `state`: the encoder's recurrent state entering this stage. +- `input`: the concatenation `[context_t; observation_t; e_{t-1}]`, either as a + vector (one scenario) or as a matrix whose columns are scenarios. + +# Returns +- `target`: the outgoing-energy target ``\\hat e_t``, guaranteed to lie in the + one-stage reachable interval. +- `new_state`: the encoder state to carry into stage `t+1`. + +# Notes +This is the form the TRAINER uses. Threading the recurrent state through the +call signature — rather than through a mutable field — keeps the multistage +rollout a pure function of the parameters, which is what lets automatic +differentiation traverse the whole recurrent chain without meeting a mutation it +must either refuse or silently drop. + +The encoder consumes `[context_t; observation_t]` and advances by exactly one +step. What the head consumes depends on the architecture — see +[`_head_input`](@ref) — and its output goes through [`feasible_target`](@ref), +the feasibility layer both architectures share, which maps it affinely into the +interval returned by [`reachable_bounds`](@ref). + +`input` carries the incoming energy in both architectures even though the linear +one's head does not read it: it is what the reachable interval is computed from, +and that path is the one that couples the stages. +""" +function policy_step(m::BatteryReachablePolicy, state, input) + o_end = m.n_context + m.n_observation + encoder_input = _row_slice(input, 1:o_end) + e_prev = _row_slice(input, (o_end + 1):size(input, 1)) + + # Cast to the encoder's precision for type stability (mixed precision here + # has previously provoked Zygote codegen failures rather than a slowdown). + T = DecisionRulesExa._state_eltype(state) + ξ = T.(encoder_input) + h, new_state = DecisionRulesExa._step_encoder(m.encoder, ξ, state) + + z = m.combiner(_head_input(m, h, ξ, e_prev)) + return feasible_target(m, z, e_prev), new_state +end + +""" + _head_input(policy, h, ξ, e_prev) -> AbstractArray + +The head's input, which is where the two architectures differ. + +# Notes +`:tsddr_nonlinear` reads `[h_t; e_{t-1}]` — the encoding together with the +incoming state, as it always has. + +`:tsldr_recurrent_linear` reads `[h_t; ξ_t]`: the encoding together with the +CURRENT observation, giving the direct feedthrough term ``D \\xi_t`` of the +decision rule. It deliberately does NOT read the incoming energy. The incoming +energy is the previous stage's squashed target, so a head that read it would +make the raw target a nonlinear function of the observed history and the word +"linear" in the architecture's name would be false. The state still reaches the +emitted target — through the reachable interval, in the feasibility layer, which +is exactly where a decision rule with feasibility restoration puts it. +""" +_head_input(m::BatteryReachablePolicy, h, ξ, e_prev) = + m.architecture === :tsldr_recurrent_linear ? vcat(h, ξ) : vcat(h, e_prev) + +""" + _bounded_fraction(policy, z) -> y ∈ [0, 1 − 1e-3] + +The squashing step of the feasibility layer. + +# Notes +The composite map from the head's PRE-ACTIVATION output to the emitted target is +the same in both architectures: + +```math +\\hat e_t = \\underline r_t(e_{t-1}) + + (\\overline r_t(e_{t-1}) - \\underline r_t(e_{t-1}))\\, s(z_t), +``` + +with ``s`` the bounded, boundary-attaining [`stretchedsigmoid`](@ref). Where the +two differ is only WHICH SIDE of the head boundary ``s`` is applied on, and that +follows from what each architecture has to promise: + +- `:tsddr_nonlinear` applies its bounded activation as the head's own output + activation, because its head is nonlinear anyway and always has. Here `z` has + already been squashed and this step is the identity. +- `:tsldr_recurrent_linear` may not: an activation on the output head would be a + trainable nonlinearity in the map that is required to be affine. Its head is + affine end to end and `s` is applied HERE, in the feasibility layer, which is + not part of the trainable history map and carries no parameters. + +The squashing for the linear architecture is fixed to `stretchedsigmoid` rather +than configurable, because it belongs to the feasibility layer and not to the +head; the constructor rejects any other choice rather than silently ignoring it. +""" +_bounded_fraction(m::BatteryReachablePolicy, z) = + m.architecture === :tsldr_recurrent_linear ? stretchedsigmoid.(z) : z + +""" + feasible_target(policy, z, e_prev) -> AbstractArray + +The strict reachable-target feasibility layer, shared by both architectures. + +# Arguments +- `z`: the head's raw output. Affine in the observed demand history for + `:tsldr_recurrent_linear`; already bounded in `[0, 1−1e-3]` for + `:tsddr_nonlinear`. +- `e_prev`: the incoming energy, whose reachable interval this maps into. + +# Notes +The fraction returned by [`_bounded_fraction`](@ref) lies in `[0, 1−1e-3]`, so +the image of the affine map below is inside the interval +[`reachable_bounds`](@ref) returns and the stage problem's hard target equality +is ALWAYS attainable. There is no target slack, no target penalty and no +projection that could silently move a target: a target this returns is reachable +by construction, not by repair. + +Both endpoints depend differentiably on `e_prev`, which is the term that couples +consecutive stages — see the note at the top of this file. +""" +function feasible_target(m::BatteryReachablePolicy, z, e_prev) + y = _bounded_fraction(m, z) + lower, upper = reachable_bounds(m, e_prev, y) + return lower .+ (upper .- lower) .* y +end + +""" + raw_target_step(policy, state, observation) -> (z, new_state) + +Advance the LINEAR decision rule by one stage and return its RAW target, before +the feasibility layer. + +# Arguments +- `observation`: ``\\xi_t = [\\text{context}_t; \\text{observation}_t]`` alone — + no incoming energy, because the rule does not read one. + +# Returns +- `z`: ``z_t = C h_t + D \\xi_t + d``, affine in ``\\xi_1,\\ldots,\\xi_t``. +- `new_state`: ``h_t``. + +# Notes +Defined only for `:tsldr_recurrent_linear`. For `:tsddr_nonlinear` a "raw target +as a function of the observed history" does not exist as a separate object: that +head reads the incoming energy, so its output depends on the whole feedback loop +and calling this would return something whose name would be wrong. It therefore +raises rather than returning a plausible number. + +This is the map the causality, history, affinity and explicit-unrolling gates +are stated about, so it is a first-class function rather than something a test +reconstructs from the layers — a test that rebuilt the map would be checking its +own arithmetic. +""" +function raw_target_step(m::BatteryReachablePolicy, state, observation) + m.architecture === :tsldr_recurrent_linear || throw(ArgumentError( + "raw_target_step is defined for :tsldr_recurrent_linear; architecture :$(m.architecture) " * + "reads the incoming energy, so it has no raw target that is a function of the history alone")) + T = DecisionRulesExa._state_eltype(state) + ξ = T.(observation) + h, new_state = DecisionRulesExa._step_encoder(m.encoder, ξ, state) + return m.combiner(vcat(h, ξ)), new_state +end + +""" + policy_activations(policy) -> Vector{Function} + +Every function-valued field reachable inside the policy's trainable layers. + +# Notes +The activation audit's first half. A layer stores its activation in an ordinary +field, so collecting every `Function` in the trainable tree finds all of them +without a hard-coded list of layer types — including one introduced by a future +refactor, which a hard-coded list would silently miss. + +It is only half the audit, and the weaker half. `Flux.LSTMCell` has no +activation FIELD at all: its sigmoid gates and its `tanh` are written into the +cell's forward pass, so an audit that only read fields would pronounce an LSTM +encoder linear. [`policy_recurrent_cells`](@ref) is the other half, and it is the +one that matters. +""" +policy_activations(m::BatteryReachablePolicy) = + _collect_activations!(Function[], (m.encoder, m.combiner)) + +# Recurse into anything that is not a leaf, collecting function-valued fields. +# Numbers, arrays, symbols and strings are leaves and terminate the walk; a +# `bias` of `false` is a `Bool` and lands there rather than being mistaken for +# something structural. +function _collect_activations!(out::Vector{Function}, x) + x isa Function && (push!(out, x); return out) + (x isa AbstractArray || x isa Number || x isa Symbol || + x isa AbstractString || x === nothing) && return out + if x isa Tuple || x isa NamedTuple + for v in x + _collect_activations!(out, v) + end + return out + end + for f in fieldnames(typeof(x)) + _collect_activations!(out, getfield(x, f)) + end + return out +end + +""" + policy_recurrent_cells(policy) -> Vector + +The underlying recurrent CELL of every layer of the policy's encoder. + +# Notes +The decisive half of the activation audit: what makes an LSTM nonlinear is its +cell type, not a field. `Flux.RNNCell` is the only stock Flux cell whose whole +update is `σ.(Wi*x + Wh*h + b)` with `σ` a settable field, so "every encoder cell +is an `RNNCell` and every one of their `σ` is `identity`" is the statement that +actually establishes an affine recurrence. +""" +policy_recurrent_cells(m::BatteryReachablePolicy) = + m.encoder isa Flux.Chain ? + [DecisionRulesExa._as_cell(l) for l in m.encoder.layers] : + [DecisionRulesExa._as_cell(m.encoder)] + +""" + (policy::BatteryReachablePolicy)(input) -> target + +Evaluate the policy, advancing its own recurrent state in place. + +# Notes +The stateful convenience form of [`policy_step`](@ref), for evaluation and +interactive use. Call `Flux.reset!(policy)` at scenario boundaries: failing to +do so leaks one scenario's demand history into the next, and a `reset!` that +silently no-ops leaves the encoder memoryless — a defect that trains, reduces +loss, and answers a different question. The regression tests check that the +state actually changes across a call and actually returns to its initial value +on reset. +""" +function (m::BatteryReachablePolicy)(input) + target, new_state = policy_step(m, m.state, input) + m.state = new_state + return target +end + +""" + Flux.reset!(policy::BatteryReachablePolicy) + +Restore the encoder's recurrent state to `Flux.initialstates`. + +# Notes +The state is re-derived from the (possibly device-moved) encoder weights on +every reset, so it always matches the encoder's device and element type. The +head is feed-forward and carries no state. +""" +function Flux.reset!(m::BatteryReachablePolicy) + m.state = DecisionRulesExa._init_recurrent_state(m.encoder) + return nothing +end + +""" + load_stateconditioned_policy!(policy::BatteryReachablePolicy, state) + +Load checkpointed Flux parameters into a policy, keeping the case's frozen +reachability metadata. + +# Notes +A checkpoint carries the trainable encoder and head only. Reachability metadata +comes from the case, never from a checkpoint: a checkpoint that could override a +battery's rating would let a stale file silently redefine the problem. + +The recurrent state is reset after loading so the next rollout starts from the +loaded weights' own initial state. + +An architecture mismatch is caught here as well as by the checkpoint metadata: +`Flux.loadmodel!` compares the two structures, and an `LSTMCell` and an +`RNNCell` of the same declared width carry `Wi` blocks of different shape. That +is a structural accident, not a guarantee — the guarantee is the explicit +architecture check in `load_checkpoint!`. +""" +function load_stateconditioned_policy!(policy::BatteryReachablePolicy, state) + Flux.loadmodel!(policy, state) + Flux.reset!(policy) + return policy +end + +""" + _battery_policy_head(input_dim, output_dim, hidden; hidden_activation, + output_activation) -> Flux.Dense or Flux.Chain + +The target head, built so that the hidden and the OUTPUT activation can differ. + +# Notes +`DecisionRulesExa._dense_policy_head` deliberately applies one activation at +every layer including the output, which is what a bounded nonlinear head wants. +The linear architecture needs `identity` everywhere, and stating that as two +separate arguments — rather than as one activation that happens to be +`identity` — is what makes the audit's claim about the OUTPUT head checkable +independently of the hidden layers. + +The layer construction order is identical to the shared helper's, so a head +built here from the same random stream has the same parameters as one built +there. +""" +function _battery_policy_head(input_dim::Int, output_dim::Int, hidden::AbstractVector{Int}; + hidden_activation, output_activation) + isempty(hidden) && return Flux.Dense(input_dim => output_dim, output_activation) + layers = Any[Flux.Dense(input_dim => hidden[1], hidden_activation)] + for i in 1:(length(hidden) - 1) + push!(layers, Flux.Dense(hidden[i] => hidden[i + 1], hidden_activation)) + end + push!(layers, Flux.Dense(hidden[end] => output_dim, output_activation)) + return Flux.Chain(layers...) +end + +""" + battery_reachable_policy(case, encoder_layers; n_observation, n_context=0, + head_layers=Int[], activation=stretchedsigmoid, + encoder_type=nothing, + architecture=:tsddr_nonlinear) + -> BatteryReachablePolicy + +Construct a strict reachable policy for a frozen case. + +# Arguments +- `case::BatteryCase`: supplies the batteries and the stage duration. +- `encoder_layers::AbstractVector{Int}`: recurrent encoder widths. + +# Keywords +- `n_observation::Int`: width of the per-stage observation. +- `n_context::Int`: deterministic context rows prepended to the observation. +- `head_layers::AbstractVector{Int}`: hidden widths of the head. +- `activation`: must be `[0,1]`-bounded; see [`BOUNDED_ACTIVATIONS`](@ref). It is + the head's output activation for `:tsddr_nonlinear` and the feasibility + layer's squashing for `:tsldr_recurrent_linear`, which is why the latter + accepts only `stretchedsigmoid`. +- `encoder_type`: recurrent layer constructor, or `nothing` for the + architecture's own — `Flux.LSTM` for `:tsddr_nonlinear`, and for + `:tsldr_recurrent_linear` a `Flux.RNN` with `identity`, whose cell update is + exactly ``h_t = A h_{t-1} + B \\xi_t + b``. +- `architecture::Symbol`: one of [`BATTERY_ARCHITECTURES`](@ref). + +# Returns +- A [`BatteryReachablePolicy`](@ref) whose reachability metadata is derived from + the case at CONSTRUCTION, so the policy and the model it feeds cannot disagree + about the battery. + +# Notes +`:tsldr_recurrent_linear` rejects an explicit `encoder_type` rather than +accepting one and hoping it is affine. The whole claim the architecture makes is +about which maps are affine, and a caller who could pass `Flux.GRU` and still +get a policy that called itself linear would make the name meaningless. + +Its head layers compose affinely, so `head_layers` widths are a reparameterization +rather than extra capacity — a rank restriction if a width is narrow. They are +accepted so that the two architectures can be given the same shape arguments. +""" +function battery_reachable_policy(case::BatteryCase, encoder_layers::AbstractVector{Int}; + n_observation::Int, + n_context::Int = 0, + head_layers::AbstractVector{Int} = Int[], + activation = stretchedsigmoid, + encoder_type = nothing, + architecture::Symbol = :tsddr_nonlinear) + architecture in BATTERY_ARCHITECTURES || throw(ArgumentError( + "architecture must be one of $BATTERY_ARCHITECTURES, got :$architecture")) + any(a -> activation === a, BOUNDED_ACTIVATIONS) || throw(ArgumentError( + "the target head needs a [0,1]-bounded activation so targets stay inside the reachable interval")) + n_context >= 0 || throw(ArgumentError("n_context must be nonnegative")) + n_observation >= 1 || throw(ArgumentError("n_observation must be positive")) + + linear = architecture === :tsldr_recurrent_linear + if linear + encoder_type === nothing || throw(ArgumentError( + ":tsldr_recurrent_linear builds its own affine recurrence; encoder_type is not selectable")) + activation === stretchedsigmoid || throw(ArgumentError( + ":tsldr_recurrent_linear squashes in the feasibility layer, which is fixed to stretchedsigmoid")) + end + cell = encoder_type === nothing ? + (linear ? (p -> Flux.RNN(p, identity)) : Flux.LSTM) : encoder_type + + batteries = sort(collect(case.batteries); by = b -> b.index) + nBat = length(batteries) + Δt = stage_hours(case) + + sizes = vcat(n_context + n_observation, collect(encoder_layers)) + layers = [cell(sizes[i] => sizes[i + 1]) for i in 1:length(encoder_layers)] + encoder = Flux.Chain(layers...) + width = isempty(encoder_layers) ? n_context + n_observation : encoder_layers[end] + # The head reads the encoding plus either the incoming energy (nonlinear) or + # the current observation (linear) — see `_head_input`. + head_in = width + (linear ? n_context + n_observation : nBat) + combiner = linear ? + _battery_policy_head(head_in, nBat, collect(Int, head_layers); + hidden_activation = identity, output_activation = identity) : + DecisionRulesExa._dense_policy_head(head_in, nBat, collect(Int, head_layers); + activation = activation) + + return BatteryReachablePolicy( + encoder, combiner, + DecisionRulesExa._init_recurrent_state(encoder), + architecture, + n_context, n_observation, nBat, + Float32[b.energy_min for b in batteries], + Float32[b.energy_max for b in batteries], + Float32[b.charge_efficiency * Δt * b.charge_max for b in batteries], + Float32[Δt * b.discharge_max / b.discharge_efficiency for b in batteries], + Float32[b.self_discharge for b in batteries], + ) +end diff --git a/examples/BatteryStorageOPF/battery_solution_schema.jl b/examples/BatteryStorageOPF/battery_solution_schema.jl new file mode 100644 index 0000000..9ff36da --- /dev/null +++ b/examples/BatteryStorageOPF/battery_solution_schema.jl @@ -0,0 +1,479 @@ +# battery_solution_schema.jl +# +# The shared, engine-neutral description of a solved battery-storage AC-OPF +# trajectory. This file is shipped BYTE-IDENTICALLY in both public engines, so +# a solution written by the JuMP/PowerModels engine and a solution written by +# the ExaModels engine are the same object and can be differenced by name +# rather than by position. +# +# Format: one long CSV with header +# +# scenario,stage,class,index,value +# +# `class` names a physical quantity (see `SOLUTION_CLASSES`), `index` is the +# NETWORK identifier of the component it belongs to (bus id, generator id, +# branch id, battery id) — never a positional offset — and `value` is a Float64 +# printed with full round-tripping precision. Scalars per stage use index 0. +# +# Why long format and why identifiers. Objective agreement between two engines +# can hide a different feasible set, a null-space variable, or a solver barrier +# offset; only a per-variable comparison catches those, and a per-variable +# comparison is only trustworthy when both sides agree what "variable 7" means. +# Component identifiers in PGLib cases are arbitrary integers and need not be +# consecutive, so positional indexing is not merely fragile — it is wrong. +# +# This file deliberately has no package dependencies beyond `Printf` and the +# standard library: it must be copyable into either engine without dragging a +# resolver conflict behind it. + +using Printf + +""" +Physical classes a battery-storage solution may record. + +Battery-layer classes (index = battery identifier): + +- `"energy_in"` incoming energy ``e_{b,t-1}`` (pu·h) +- `"energy_out"` outgoing energy ``e_{b,t}`` (pu·h) +- `"target"` the strict target ``\\hat e_{b,t}`` (pu·h); absent in the + targetless SDDP formulation +- `"target_dual"` the multiplier ``\\lambda_{b,t}`` of the strict target + equality, i.e. ``\\partial Q/\\partial \\hat e_{b,t}`` +- `"p_ch"` charging power (pu) +- `"p_dis"` discharging power (pu) +- `"p_bat"` net active injection ``p^{dis}-p^{ch}`` (pu) + +Nodal classes (index = bus identifier): + +- `"deficit"` the uncapped nonnegative recourse injection ``d_{i,t}`` (pu) +- `"surplus"` the uncapped nonnegative recourse sink ``s_{i,t}`` (pu) +- `"pd"`, `"qd"` REALIZED active/reactive demand at the bus (pu) +- `"vm"`, `"va"` voltage magnitude (pu) and angle (rad) +- `"pg_bus"`, `"qg_bus"` generation aggregated to the bus (pu) +- `"price_active"`, `"price_reactive"` nodal duals of the balance, where the + engine has them + +Generator classes (index = generator identifier): `"pg"`, `"qg"` (pu). + +Branch classes (index = branch identifier): `"p_fr"`, `"q_fr"`, `"p_to"`, +`"q_to"` (pu, at the respective ends). + +Scalar classes (index 0): + +- `"cost_generation"`, `"cost_throughput"`, `"cost_deficit"`, `"cost_surplus"` +- `"cost_stage"` their sum for the stage +- `"objective"` the engine's own reported stage objective +- `"residual_equality"` worst absolute equality-constraint residual +- `"solved"` 1.0 when the engine accepted the solve, 0.0 otherwise +""" +const SOLUTION_CLASSES = ( + "energy_in", "energy_out", "target", "target_dual", + "p_ch", "p_dis", "p_bat", + "deficit", "surplus", "pd", "qd", "vm", "va", "pg_bus", "qg_bus", + "price_active", "price_reactive", + "pg", "qg", + "p_fr", "q_fr", "p_to", "q_to", + "cost_generation", "cost_throughput", "cost_deficit", "cost_surplus", + "cost_stage", "objective", "residual_equality", "solved", +) + +"Header line of every solution CSV." +const SOLUTION_HEADER = "scenario,stage,class,index,value" + +""" + SolutionRecorder + +Accumulator for solution records in the shared long format. + +# Fields +- `rows::Vector{Tuple{Int,Int,String,Int,Float64}}`: `(scenario, stage, class, + index, value)` in insertion order. + +# Notes +Rows are appended in whatever order an engine produces them; nothing downstream +depends on the order, because comparison is by `(scenario, stage, class, +index)`. Insertion order IS preserved on write so that a diff of two files from +the same engine stays readable. +""" +struct SolutionRecorder + rows::Vector{Tuple{Int,Int,String,Int,Float64}} +end + +SolutionRecorder() = SolutionRecorder(Tuple{Int,Int,String,Int,Float64}[]) + +""" + record!(rec, scenario, stage, class, index, value) + +Append one record, validating the class name. + +# Notes +An unknown class is an ERROR rather than a silently-written row: a typo in a +class name would make the corresponding quantity vanish from a cross-engine +comparison and the comparison would still report "all classes agree". +""" +function record!(rec::SolutionRecorder, scenario::Integer, stage::Integer, + class::AbstractString, index::Integer, value::Real) + class in SOLUTION_CLASSES || error("unknown solution class \"$class\"") + push!(rec.rows, (Int(scenario), Int(stage), String(class), Int(index), Float64(value))) + return rec +end + +""" + record_map!(rec, scenario, stage, class, values::AbstractDict) + +Append one record per `(identifier => value)` pair, in sorted identifier order. +""" +function record_map!(rec::SolutionRecorder, scenario::Integer, stage::Integer, + class::AbstractString, values::AbstractDict) + for k in sort!(collect(keys(values))) + record!(rec, scenario, stage, class, k, values[k]) + end + return rec +end + +""" + write_solution(path, rec::SolutionRecorder) + +Write the accumulated records to `path` in the shared long format. + +# Notes +Values are printed with `%.17g`, which round-trips every `Float64` exactly, so a +cross-engine difference read back from these files is a difference between the +engines and never a difference introduced by printing. +""" +function write_solution(path::AbstractString, rec::SolutionRecorder) + mkpath(dirname(abspath(path))) + open(path, "w") do io + println(io, SOLUTION_HEADER) + for (s, t, c, i, v) in rec.rows + @printf(io, "%d,%d,%s,%d,%.17g\n", s, t, c, i, v) + end + end + return path +end + +""" + physical_residuals(network, batteries, Δt, sol) -> NamedTuple + +Recompute the physics of one solved stage from its reported values and return +the worst violation in each class. + +# Arguments +- `network::AbstractDict`: the frozen PGLib network (per-unit). +- `batteries`: the case's batteries; each must expose `index`, `bus`, + `self_discharge`, `charge_efficiency`, `discharge_efficiency`. +- `Δt::Real`: stage duration in hours. +- `sol`: a named tuple or dictionary exposing, keyed by NETWORK identifier, + `vm`, `va`, `pg`, `qg`, `p_fr`, `q_fr`, `p_to`, `q_to`, `deficit`, `surplus`, + `pd`, `qd`, `p_ch`, `p_dis`, `energy_in`, `energy_out`. + +# Returns +A `NamedTuple` of worst absolute violations: +`(branch_flow, active_balance, reactive_balance, thermal, angle, voltage, + transition)`. + +# Notes +This is deliberately INDEPENDENT of both engines: it re-derives the AC branch +flows from the reported voltages, re-adds the nodal balances from the reported +injections, and re-applies the battery transition to the reported controls. An +engine can therefore be wrong in a way its own solver is happy with and still be +caught here — which is the only kind of check worth running against a manually +written formulation. + +Angles are only meaningful for a polar solution. A solution whose `va` entries +are `NaN` (a W-space relaxation has no angle variable) yields `NaN` in the +branch-flow and angle classes, which is honest rather than silently zero. +""" +function physical_residuals(network::AbstractDict, batteries, Δt::Real, sol) + vm, va = sol.vm, sol.va + worst_flow = 0.0 + worst_thermal = 0.0 + worst_angle = 0.0 + + inj_p = Dict{Int,Float64}(k => 0.0 for k in keys(vm)) + inj_q = Dict{Int,Float64}(k => 0.0 for k in keys(vm)) + + for (_, br) in network["branch"] + Int(get(br, "br_status", 1)) == 0 && continue + l = Int(br["index"]) + haskey(sol.p_fr, l) || continue + f, t = Int(br["f_bus"]), Int(br["t_bus"]) + r, x = Float64(get(br, "br_r", 0.0)), Float64(br["br_x"]) + r2x2 = r^2 + x^2 + g = r2x2 > 0 ? r / r2x2 : 0.0 + b = r2x2 > 0 ? -x / r2x2 : 0.0 + tap = Float64(get(br, "tap", 1.0)); tap = tap ≈ 0 ? 1.0 : tap + shift = Float64(get(br, "shift", 0.0)) + tr, ti = tap * cos(shift), tap * sin(shift) + ttm = tr^2 + ti^2; ttm = ttm > 0 ? ttm : 1.0 + g_fr, b_fr = Float64(get(br, "g_fr", 0.0)), Float64(get(br, "b_fr", 0.0)) + g_to, b_to = Float64(get(br, "g_to", 0.0)), Float64(get(br, "b_to", 0.0)) + + vf, vt = vm[f], vm[t] + θ = va[f] - va[t] + pfr = (g + g_fr) / ttm * vf^2 + (-g * tr + b * ti) / ttm * vf * vt * cos(θ) + + (-b * tr - g * ti) / ttm * vf * vt * sin(θ) + qfr = -(b + b_fr) / ttm * vf^2 - (-b * tr - g * ti) / ttm * vf * vt * cos(θ) + + (-g * tr + b * ti) / ttm * vf * vt * sin(θ) + pto = (g + g_to) * vt^2 + (-g * tr - b * ti) / ttm * vt * vf * cos(-θ) + + (-b * tr + g * ti) / ttm * vt * vf * sin(-θ) + qto = -(b + b_to) * vt^2 - (-b * tr + g * ti) / ttm * vt * vf * cos(-θ) + + (-g * tr - b * ti) / ttm * vt * vf * sin(-θ) + + worst_flow = max(worst_flow, abs(pfr - sol.p_fr[l]), abs(qfr - sol.q_fr[l]), + abs(pto - sol.p_to[l]), abs(qto - sol.q_to[l])) + + rate = Float64(get(br, "rate_a", Inf)) + if isfinite(rate) + worst_thermal = max(worst_thermal, + sol.p_fr[l]^2 + sol.q_fr[l]^2 - rate^2, + sol.p_to[l]^2 + sol.q_to[l]^2 - rate^2) + end + amin = Float64(get(br, "angmin", -pi)); amax = Float64(get(br, "angmax", pi)) + worst_angle = max(worst_angle, amin - θ, θ - amax) + + inj_p[f] -= sol.p_fr[l]; inj_q[f] -= sol.q_fr[l] + inj_p[t] -= sol.p_to[l]; inj_q[t] -= sol.q_to[l] + end + + for (_, gen) in network["gen"] + Int(get(gen, "gen_status", 1)) == 0 && continue + gi = Int(gen["index"]) + haskey(sol.pg, gi) || continue + bus = Int(gen["gen_bus"]) + inj_p[bus] += sol.pg[gi] + inj_q[bus] += sol.qg[gi] + end + + for (_, sh) in get(network, "shunt", Dict{String,Any}()) + Int(get(sh, "status", 1)) == 0 && continue + bus = Int(sh["shunt_bus"]) + haskey(inj_p, bus) || continue + inj_p[bus] -= Float64(get(sh, "gs", 0.0)) * vm[bus]^2 + inj_q[bus] += Float64(get(sh, "bs", 0.0)) * vm[bus]^2 + end + + worst_transition = 0.0 + for b in batteries + haskey(sol.p_ch, b.index) || continue + inj_p[b.bus] += sol.p_dis[b.index] - sol.p_ch[b.index] + lhs = sol.energy_out[b.index] - b.self_discharge * sol.energy_in[b.index] - + b.charge_efficiency * Δt * sol.p_ch[b.index] + + (Δt / b.discharge_efficiency) * sol.p_dis[b.index] + worst_transition = max(worst_transition, abs(lhs)) + end + + worst_p = 0.0 + worst_q = 0.0 + worst_v = 0.0 + for (_, bus) in network["bus"] + i = Int(bus["index"]) + haskey(inj_p, i) || continue + worst_p = max(worst_p, abs(inj_p[i] + sol.deficit[i] - sol.surplus[i] - sol.pd[i])) + worst_q = max(worst_q, abs(inj_q[i] - sol.qd[i])) + worst_v = max(worst_v, Float64(get(bus, "vmin", 0.0)) - vm[i], + vm[i] - Float64(get(bus, "vmax", Inf))) + end + + return (branch_flow = worst_flow, active_balance = worst_p, + reactive_balance = worst_q, thermal = worst_thermal, + angle = worst_angle, voltage = worst_v, transition = worst_transition) +end + +""" + read_solution(path) -> Dict{Tuple{Int,Int,String,Int},Float64} + +Read a solution file into a lookup keyed by `(scenario, stage, class, index)`. + +# Notes +Duplicate keys are an ERROR. Two rows claiming the same physical quantity mean +the writer lost track of what it was recording, and silently keeping the last +one would make a parity comparison depend on file order. +""" +function read_solution(path::AbstractString) + out = Dict{Tuple{Int,Int,String,Int},Float64}() + open(path, "r") do io + header = readline(io) + header == SOLUTION_HEADER || + error("$path: unexpected header \"$header\"; expected \"$SOLUTION_HEADER\"") + for line in eachline(io) + isempty(strip(line)) && continue + parts = split(line, ',') + length(parts) == 5 || error("$path: malformed row \"$line\"") + key = (parse(Int, parts[1]), parse(Int, parts[2]), String(parts[3]), parse(Int, parts[4])) + haskey(out, key) && error("$path: duplicate record for $key") + out[key] = parse(Float64, parts[5]) + end + end + return out +end + +# ───────────────────────────────────────────────────────────────────────────── +# The physical cost contract +# +# An interior-point method does not leave a nonnegative variable AT zero. It +# leaves it a barrier tolerance away, and the sign of that offset depends on the +# solver's own bound handling — Ipopt parks the two nodal recourse injections at +# exactly zero, MadNLP a bound-relaxation below it. On any one bus the +# difference is about 1e-8 pu and physically nothing at all. +# +# The recourse PRICE, however, is chosen far above any generator, 1e5 to 1e6 per +# pu. Multiply 1e-8 pu by 1e6 and sum over two thousand buses and the two +# engines' reported stage objectives differ by tens of cost units on a problem +# where neither used any recourse. That difference is a barrier artifact of the +# solver, not a difference between two policies, and it must never reach a +# training-selection metric or a paired cost comparison. +# +# So the reported cost is defined here, once, and both engines compute it with +# THIS code: +# +# * the raw solver objective is preserved, untouched, for diagnostics; +# * every recourse element within the declared physical tolerance of zero is +# projected to EXACTLY zero, element by element; +# * an element outside that tolerance is NOT projected. The solve is marked +# inadmissible and the caller rejects it — a policy that genuinely used +# recourse is rejected, never quietly priced. +# +# The projection changes what is REPORTED, never what was solved. The stage +# problem still carries the recourse variables at their full price, which is +# what makes a dynamically reachable target attainable; nothing here relaxes a +# constraint, adds a penalty or rewrites an objective. +# ───────────────────────────────────────────────────────────────────────────── + +""" +The bound relaxation every TRUE-ACP solve of this study runs with. + +# Notes +ONE value, shared by every ACP path on both engines: the JuMP/PowerModels/Ipopt +ACP model, the ExaModels/MadNLP ACP model on CPU **and** on GPU, nonlinear +TS-DDR, recurrent-linear TSLDR, the ACP forward evaluation of both the SOC-WR +and the DC SDDP arms, and every deterministic-equivalent, perfect-foresight, +diagnostic and cross-engine parity solve. It is stated explicitly at each site +rather than inherited from a solver default, because the two solvers do not +agree on what that default is and a study whose two engines relax bounds +differently is not comparing like with like. + +An interior-point method relaxes every variable bound by this factor before +solving, so the point it converges to may sit fractionally outside the declared +box. That is why the study's guarantee is the residual RECOMPUTED from the +reported solution — never the solver's own infeasibility report, which is the +infeasibility of the relaxed problem. + +**It may not be set to zero.** Doing so was measured to break the CUDSS/GPU path +outright: `RESTORATION_FAILED` at iteration 2 on every case and horizon tried +(`case14` T=3 and T=24, `case118` T=24, `case1354_pegase` T=24), while the CPU +path was unaffected — so a CPU-only validation cannot establish this setting. +""" +const ACP_BOUND_RELAX_FACTOR = 1e-8 + +""" +Largest transition-equality residual that still counts as exact, derived from +[`ACP_BOUND_RELAX_FACTOR`](@ref) rather than fitted to an observation. + +# Notes +The transition row carries BOTH controls, + +```math +e_t - \\alpha e_{t-1} - \\eta^{ch}\\Delta t\\, p^{ch}_t + + (\\Delta t/\\eta^{dis})\\, p^{dis}_t = 0, +``` + +and an interior-point method may leave each control a bound relaxation outside +its declared box. Projecting those deviations back onto the ORIGINAL feasible +bounds contributes about + +```math +\\Delta t\\,(\\eta^{ch}\\delta^{ch} + \\delta^{dis}/\\eta^{dis}), +``` + +which at `ACP_BOUND_RELAX_FACTOR = 1e-8` is order `2e-8`. The factor five covers +the known coefficients with margin while staying 100x tighter than the +single-digit `1e-6` original-problem residual scale the study reports at. + +Checked PER TRANSITION ROW, so it does not accumulate with the horizon. The +`max` with `1e-9` preserves the historical gate for any tighter relaxation. +""" +const TRANSITION_RESIDUAL_TOL = max(1e-9, 5 * ACP_BOUND_RELAX_FACTOR) + +""" +Largest recourse injection, in pu, that still counts as none. + +# Notes +The same constant on both sides of the study. It is well above any +interior-point method's distance-to-bound — measured at about `1e-8` pu on both +engines — and far below any quantity the network cares about. +""" +const PHYSICAL_RECOURSE_TOL = 1e-6 + +""" + project_recourse(values, tol=PHYSICAL_RECOURSE_TOL) -> (projected, worst, admissible) + +Project a recourse map element by element. + +# Returns +- `projected::Dict{Int,Float64}`: every element within `tol` of zero replaced by + exactly `0.0`, every other element kept verbatim. +- `worst::Float64`: the largest absolute RAW value, before projection. +- `admissible::Bool`: whether every element was within `tol`. + +# Notes +Element by element, never in aggregate. A thousand buses each `1e-7` pu short sum +to `1e-4` pu, which an aggregate test would wave through and which this rejects +one element at a time — and, conversely, one bus genuinely short by `1` pu is +caught even though the other thousand are clean. +""" +function project_recourse(values::AbstractDict, tol::Real = PHYSICAL_RECOURSE_TOL) + out = Dict{Int,Float64}() + worst = 0.0 + admissible = true + for k in sort!(collect(keys(values))) + v = Float64(values[k]) + worst = max(worst, abs(v)) + if abs(v) <= tol + out[k] = 0.0 + else + out[k] = v + admissible = false + end + end + return out, worst, admissible +end + +""" + physical_stage_cost(sol, recourse; tol=PHYSICAL_RECOURSE_TOL) -> NamedTuple + +The stage cost this study reports, and the raw objective it came from. + +# Arguments +- `sol`: any engine's stage solution, needing `cost_generation`, + `cost_throughput`, `deficit`, `surplus` and (optionally) `objective`. +- `recourse::RecourseCosts`: the case's own frozen recourse prices. + +# Returns +`(raw, corrected, generation, throughput, deficit, surplus, correction, +worst_recourse, admissible)` — every field in the case's own objective units. + +# Notes +`corrected` is the sum of the generation cost, the throughput cost and the +recourse actually charged AFTER projection; `correction = raw - corrected` is +the barrier artifact, reported so it can be inspected rather than discovered. + +This is the ONLY function either engine may use to produce a headline cost. The +raw objective is a solver diagnostic and comparing two engines on it compares +their barrier parameters. +""" +function physical_stage_cost(sol, recourse; tol::Real = PHYSICAL_RECOURSE_TOL) + d, worst_d, ok_d = project_recourse(sol.deficit, tol) + s, worst_s, ok_s = project_recourse(sol.surplus, tol) + cost_d = recourse.deficit * sum(values(d); init = 0.0) + cost_s = recourse.surplus * sum(values(s); init = 0.0) + gen = Float64(sol.cost_generation) + thr = Float64(sol.cost_throughput) + corrected = gen + thr + cost_d + cost_s + raw = hasproperty(sol, :objective) ? Float64(sol.objective) : NaN + return (raw = raw, corrected = corrected, generation = gen, throughput = thr, + deficit = cost_d, surplus = cost_s, + correction = isnan(raw) ? NaN : raw - corrected, + worst_recourse = max(worst_d, worst_s), + admissible = ok_d && ok_s) +end diff --git a/examples/BatteryStorageOPF/portfolio_runner.jl b/examples/BatteryStorageOPF/portfolio_runner.jl new file mode 100644 index 0000000..b915473 --- /dev/null +++ b/examples/BatteryStorageOPF/portfolio_runner.jl @@ -0,0 +1,1071 @@ +#!/usr/bin/env julia +# portfolio_runner.jl +# +# The production runner for the two methods THIS engine owns: +# `:tsddr_nonlinear` and `:tsldr_recurrent_linear`. The other two study methods, +# `:sddp_soc` and `:sddp_dc`, belong to the JuMP engine +# (`DecisionRules.jl/examples/BatteryStorageOPF/portfolio_runner.jl`) and are +# refused here BY NAME, exactly as `run_battery_method` refuses them. +# +# WHAT THIS FILE IS, AND WHAT IT IS NOT. +# It is a SEGMENT DRIVER: it turns "train this frozen case, with this frozen +# configuration, from global update `a` to global update `b`, and survive being +# killed at any moment" into files on disk. It contains no policy, no stage +# model, no gradient, no cost convention and no evaluation rule of its own — +# every one of those comes from `train_battery_exa_strict.jl` and the two shared +# contract files, unchanged. What it adds is the machinery a long preemptible +# run needs and a single in-process training call does not: identity binding, +# verified checkpoints, resumption, a stop protocol and an honest result record. +# +# ───────────────────────────────────────────────────────────────────────────── +# COMMAND CONTRACT +# +# julia --project= portfolio_runner.jl \ +# --case-manifest \ +# --method \ +# --config \ +# --protocol \ +# --output \ +# --resume-from +# +# Those six flags are sufficient on their own; the command above runs with no +# scheduler and no campaign controller of any kind. Five further flags exist +# purely as conveniences for an automated caller and ALL of them default: +# +# --run-id (default "standalone") +# --segment (default 1) +# --attempt (default 1) +# --stop-file (default /STOP) +# --max-seconds (default 1e9) +# +# ───────────────────────────────────────────────────────────────────────────── +# THE FROZEN CONFIGURATION (`--config`, TOML) +# +# target_index total global updates for the WHOLE run (the run is done +# when the global update count reaches this) +# segment_updates global updates this invocation may add at most +# checkpoint_every updates between checkpoints +# eval_every updates between screening-panel evaluations +# ma_window window of the reported moving average of the training loss +# num_stages horizon T +# trajectories scenarios averaged into one gradient step +# workers persistent solver workers; 1 (default) is the serial path, +# production uses 2. `trajectories` must be at least this +# lr, lr_final endpoints of the cosine ramp, indexed by GLOBAL update +# encoder_layers e.g. [64, 64] +# head_layers e.g. [128, 128] +# eval_columns screening-protocol columns forming the fixed panel +# seed the run's single seed +# device "cpu" or "gpu" +# max_recourse physical admissibility tolerance, pu +# method OPTIONAL; when present it must equal --method +# +# ───────────────────────────────────────────────────────────────────────────── +# THE PROTOCOL DESCRIPTOR (`--protocol`, TOML) +# +# kind "screening" (or "sole" on a fixture case that declares only +# one protocol). "final" is REFUSED. +# num_stages, num_scenarios, seed, sha256 +# +# The descriptor does not CARRY a protocol — the protocol is regenerated from +# the frozen case, as `read_battery_case` regenerates it, and the descriptor is +# what the regenerated one is checked against. A descriptor is therefore an +# assertion about identity, never a second source of truth, and it is what makes +# "this run was selected on the screening panel" a checkable claim rather than a +# promise. Write one for a case with: +# +# julia --project=. -e 'include("portfolio_runner.jl"); +# write_protocol_descriptor("case/pglib_opf_case118_ieee", "screening.toml")' +# +# ───────────────────────────────────────────────────────────────────────────── +# OUTPUTS, all inside `--output`, none of them ever committed +# +# checkpoints/ck_XXXXXXXX.jld2 the checkpoint payload +# checkpoints/ck_XXXXXXXX.jld2.meta.toml its digest, indices and lineage +# history.csv index, train_loss, panel_value, bound, solve_ok, +# solve_fail, deficit (7 columns, fixed) +# trajectory.csv index, train_loss, train_loss_ma, lr, wall_seconds +# evaluation.csv index, protocol, columns, mean_cost, worst_recourse, +# complete, selected, best_cost +# result.toml the segment record +# identity.toml every coordinate this segment was bound to +# +# `bound` is `NaN` in every row: this is not a bounding method, and a column +# that exists for the SDDP arms is left empty rather than filled with a number +# that would be read as one. +# +# ───────────────────────────────────────────────────────────────────────────── +# DETERMINISM AND SEGMENTATION +# +# A run cut into pieces must produce what the same run in one piece produces. +# Three things carry that: +# +# * the learning rate is `cosine_lr(i, target_index, lr, lr_final)` — a pure +# function of the GLOBAL update index, never of a per-segment step counter; +# * the scenario sampler's state is checkpointed and restored exactly, so +# update `i` draws the atoms it would have drawn uninterrupted; +# * the optimizer's moment estimates are checkpointed and restored, because +# Adam's position is its moments as much as its weights, and a resumed +# segment that silently restarts them takes a different first step. +# +# NOTHING here depends on where a segment started or how many times it was +# preempted. `trajectory_checksum`, the running sum of the per-update training +# loss, is the single number that certifies it. + +using TOML +using SHA +using Dates +using Printf +using Random +using Statistics +using Flux +using Optimisers +using JLD2 +using StableRNGs + +# The certified implementation. Everything scientific comes from here; this file +# adds no second copy of any of it. Its `PROGRAM_FILE` guard keeps the include +# from launching a training run. +include(joinpath(@__DIR__, "train_battery_exa_strict.jl")) + +# ───────────────────────────────────────────────────────────────────────────── +# Schemas +# ───────────────────────────────────────────────────────────────────────────── + +""" +Result-record schema. Must match the number the campaign controller verifies; +a runner speaking a different one is rejected rather than half-read. +""" +const RUNNER_RESULT_SCHEMA = 1 + +""" +Segment-checkpoint schema, distinct from `BATTERY_CHECKPOINT_SCHEMA`. + +The policy checkpoint written by [`save_checkpoint`](@ref) restores a POLICY; a +segment checkpoint additionally restores a RUN — its global update count, its +sampler position, its evaluation history and its best admissible selection. The +two tags are checked separately so a policy-only file can never be mistaken for +a resumable segment. +""" +const RUNNER_CHECKPOINT_SCHEMA = "battery_storage_opf/segment/1" + +"The two methods this engine owns, and the engine that owns the other two." +const RUNNER_METHODS = (:tsddr_nonlinear, :tsldr_recurrent_linear) + +# ───────────────────────────────────────────────────────────────────────────── +# Small self-contained primitives +# +# Deliberately reimplemented here rather than shared with any caller: this file +# must run standalone, from a public checkout, with no orchestration package on +# the load path. `sha256_file` is the one exception — it already exists in +# `battery_case.jl`, which this file includes, and defining a second one would +# leave two digest functions that could drift apart. +# ───────────────────────────────────────────────────────────────────────────── + +"UTC timestamp in the one format every record in this campaign uses." +utcnow() = Dates.format(now(UTC), dateformat"yyyy-mm-dd\THH:MM:SS\Z") + +"SHA-256 of a byte buffer or a string, as lowercase hex." +sha256_hex(data::Vector{UInt8}) = bytes2hex(sha256(data)) +sha256_hex(s::AbstractString) = bytes2hex(sha256(codeunits(String(s)))) + +""" + atomic_write(path, data) -> String + +Write `data` to a sibling temporary file, flush it, `fsync` it, `rename(2)` it +onto `path`, then read it back and re-hash it. Returns the digest. + +# Notes +A file half-written when the node dies is never visible under its final name, +which is the whole reason a controller may trust any file it finds. The read-back +is not paranoia about `rename`: it catches a full filesystem and a silently +truncated write, both of which this project has seen. +""" +function atomic_write(path::AbstractString, data::Vector{UInt8}) + mkpath(dirname(abspath(path))) + tmp = string(path, ".tmp.", getpid(), ".", time_ns()) + open(tmp, "w") do io + write(io, data) + flush(io) + try + ccall(:fsync, Cint, (Cint,), fd(io)) + catch + # fsync is a durability optimisation here, not a correctness one: + # the rename is what makes the file atomic. A filesystem that + # refuses it must not take the run down. + end + end + mv(tmp, path; force = true) + got = sha256_file(path) + want = sha256_hex(data) + got == want || error("atomic_write verification failed for $path") + return got +end +atomic_write(p::AbstractString, s::AbstractString) = + atomic_write(p, Vector{UInt8}(codeunits(String(s)))) + +"Serialize a dictionary to TOML and write it atomically. Returns the digest." +function write_toml_atomic(path::AbstractString, d::AbstractDict) + buf = IOBuffer() + TOML.print(buf, d; sorted = true) + return atomic_write(path, take!(buf)) +end + +""" + runner_code_digest(dir) -> String + +SHA-256 over the sorted `(relative path, file digest)` list of every `.jl` file +beside this runner. + +# Notes +Recorded in the result so a number can be tied to the exact code that produced +it even when the checkout was dirty — which, during a study, it usually is. The +git commit is recorded too, and the two answer different questions: the commit +says which revision was checked out, the digest says what was actually run. +""" +function runner_code_digest(dir::AbstractString) + rows = String[] + for (root, _, files) in walkdir(dir) + occursin("/.git", root) && continue + for f in files + endswith(f, ".jl") || continue + full = joinpath(root, f) + push!(rows, string(relpath(full, dir), " ", sha256_file(full))) + end + end + sort!(rows) + return sha256_hex(join(rows, "\n")) +end + +"The git commit of `dir`, or `\"none\"` outside a repository." +function git_commit(dir::AbstractString) + try + return strip(read(`git -C $dir rev-parse HEAD`, String)) + catch + return "none" + end +end + +""" + parse_args(args) -> Dict{String,String} + +`--key value` / `--flag` parser. + +# Notes +Unknown flags are KEPT rather than rejected, so an automated caller may pass +extras; but no flag outside the documented six is ever REQUIRED, which is what +keeps the six-flag command a complete command. +""" +function parse_args(args) + d = Dict{String,String}() + i = 1 + while i <= length(args) + if startswith(args[i], "--") + k = args[i][3:end] + if i < length(args) && !startswith(args[i+1], "--") + d[k] = args[i+1] + i += 2 + else + d[k] = "true" + i += 1 + end + else + i += 1 + end + end + return d +end + +"Read an integer vector from a TOML value that may be a list or a single number." +_int_list(v) = v isa AbstractVector ? [Int(x) for x in v] : [Int(v)] + +# ───────────────────────────────────────────────────────────────────────────── +# The protocol descriptor +# ───────────────────────────────────────────────────────────────────────────── + +""" + write_protocol_descriptor(case_dir, out_path; kind=:screening) -> String + +Write the protocol descriptor a run is launched against, and return its path. + +# Notes +Generated from the frozen case itself: the `kind`, the shape and the digest are +copied out of the case manifest, so a descriptor cannot describe a protocol the +case does not declare. `:final` is refused here as well as at load time — a +descriptor naming the fresh panel should not exist in the first place. +""" +function write_protocol_descriptor(case_dir::AbstractString, out_path::AbstractString; + kind::Symbol = :screening) + kind === :final && error("refusing to write a descriptor for the FINAL protocol") + case = read_battery_case(case_dir) + scr = get(case.manifest, "screening", nothing) + block, resolved = if scr === nothing + (case.manifest["protocol"], "sole") + else + (scr, "screening") + end + kind === :screening || String(kind) == resolved || + error("case $(case.name) declares a $resolved protocol, not a $kind one") + write_toml_atomic(out_path, Dict{String,Any}( + "kind" => resolved, + "case" => case.name, + "num_stages" => Int(block["num_stages"]), + "num_scenarios" => Int(block["num_scenarios"]), + "seed" => Int(block["seed"]), + "sha256" => String(block["sha256"]), + "written_utc" => utcnow(), + )) + return out_path +end + +""" + resolve_protocol(case, descriptor_path) -> (matrix, kind, declared) + +Regenerate the evaluation protocol and bind it to the descriptor, fail-closed. + +# Returns +`(matrix, kind, declared)` — the `(stages × scenarios)` atom-index matrix, the +kind [`evaluation_protocol`](@ref) actually produced, and the descriptor as read. + +# Notes +FOUR refusals, in this order, and every one of them happens before a single +scenario outcome is computed: + + 1. a descriptor whose `kind` is `"final"` — training may never be selected on + the fresh panel, and the refusal must not depend on noticing it later; + 2. a descriptor whose kind disagrees with what the case declares; + 3. a shape that disagrees with the regenerated matrix; + 4. a digest that disagrees with the regenerated protocol's. + +The last one is the load-bearing check. `evaluation_protocol` already re-derives +the screening protocol from the frozen support and re-verifies it against the +manifest; the descriptor adds the statement that THIS RUN was launched against +that protocol and not another, which is the part a result file can be audited on +afterwards. +""" +function resolve_protocol(case::BatteryCase, descriptor_path::AbstractString) + isfile(descriptor_path) || error("no protocol descriptor at $descriptor_path") + d = TOML.parsefile(descriptor_path) + declared = String(get(d, "kind", "")) + declared == "final" && error( + "protocol descriptor $descriptor_path declares the FINAL protocol; " * + "training may only be selected on the screening protocol") + declared in ("screening", "sole") || error( + "protocol descriptor $descriptor_path declares kind $(repr(declared)); " * + "expected \"screening\" (or \"sole\" on a fixture case)") + + matrix, kind = evaluation_protocol(case) + String(kind) == declared || error( + "protocol descriptor declares $declared but the case regenerates a $kind protocol") + + block = kind === :sole ? case.manifest["protocol"] : case.manifest["screening"] + Int(get(d, "num_stages", -1)) == Int(block["num_stages"]) || + error("protocol descriptor stage count does not match the case") + Int(get(d, "num_scenarios", -1)) == Int(block["num_scenarios"]) || + error("protocol descriptor scenario count does not match the case") + String(get(d, "sha256", "")) == String(block["sha256"]) || + error("protocol descriptor digest does not match the case's $kind protocol") + size(matrix, 2) == Int(block["num_scenarios"]) || + error("regenerated protocol has $(size(matrix, 2)) columns, not $(block["num_scenarios"])") + return matrix, kind, d +end + +# ───────────────────────────────────────────────────────────────────────────── +# Identity +# ───────────────────────────────────────────────────────────────────────────── + +""" + run_identity(; manifest_path, case, method, config_path, conf, + protocol_path, protocol_kind, num_stages) -> Dict + +Every coordinate that makes two runs scientifically different, plus one digest +over all of them. + +# The coordinates +| field | why it is here | +|---|---| +| `case_manifest_sha256` | the manifest FILE, byte for byte | +| `case_content_sha256` | the case CONTENT: the manifest's own artifact digests, so an edited manifest pointing at the same artifacts is still caught, and so is the reverse | +| `method` | which of the study's four this is | +| `config_sha256` | the frozen configuration file | +| `protocol_sha256`, `protocol_kind` | which panel selection may look at | +| `horizon` | the stage count actually trained | +| `seed` | the run's single seed | +| `architecture` | `:tsddr_nonlinear` or `:tsldr_recurrent_linear` | +| `acp_bound_relax_factor` | the common true-ACP setting both engines state explicitly | + +# Notes +`identity_sha256` is a digest of the canonical `key=value` rendering of the +others. It is written into every checkpoint and re-derived on resume; a +mismatch on ANY coordinate refuses the resume rather than continuing a run whose +meaning changed underneath it. That is stricter than it needs to be for a +scheduler that always re-launches the same command — deliberately, because the +failure it prevents is silent and the cost of the check is a hash. +""" +function run_identity(; manifest_path, case, method, config_path, conf, + protocol_path, protocol_kind, num_stages, + conf_workers = 1, conf_trajectories = 1) + # The case CONTENT digest is taken over the manifest's recorded artifact + # digests, in sorted order. `read_battery_case` has already verified that + # each artifact on disk hashes to its entry, so this one string stands for + # the network, the batteries and the demand together. + arts = case.manifest["artifacts"] + content = join([string(k, "=", arts[k]) for k in sort!(collect(keys(arts)))], ";") + + id = Dict{String,Any}( + "case" => case.name, + "case_manifest" => abspath(manifest_path), + "case_manifest_sha256" => sha256_file(manifest_path), + "case_content_sha256" => sha256_hex(content), + "method" => String(method), + "config_sha256" => sha256_file(config_path), + "protocol_sha256" => sha256_file(protocol_path), + "protocol_kind" => String(protocol_kind), + "horizon" => Int(num_stages), + "seed" => Int(conf["seed"]), + "architecture" => String(method), + "engine" => "exa", + "workers" => Int(conf_workers), + "trajectories" => Int(conf_trajectories), + "acp_bound_relax_factor" => ACP_BOUND_RELAX_FACTOR, + "checkpoint_schema" => RUNNER_CHECKPOINT_SCHEMA, + ) + id["identity_sha256"] = sha256_hex(join( + [string(k, "=", id[k]) for k in sort!(collect(keys(id)))], "\n")) + return id +end + +""" + assert_identity(want, got, whence) + +Refuse a continuation whose identity differs from this segment's, naming the +first field that differs. + +# Notes +Reporting the FIELD matters. "identity mismatch" sends a reader to diff two +hashes; "seed 1 vs 2" ends the investigation. +""" +function assert_identity(want::AbstractDict, got::AbstractDict, whence::AbstractString) + for k in sort!(collect(keys(want))) + k == "identity_sha256" && continue + haskey(got, k) || error("$whence is missing the identity field `$k`") + got[k] == want[k] || error( + "$whence identity mismatch on `$k`: checkpoint has $(repr(got[k])), " * + "this segment has $(repr(want[k]))") + end + String(get(got, "identity_sha256", "")) == String(want["identity_sha256"]) || + error("$whence identity digest mismatch") + return nothing +end + +# ───────────────────────────────────────────────────────────────────────────── +# Checkpoints +# ───────────────────────────────────────────────────────────────────────────── + +""" + checkpoint_paths(output, index) -> (payload, sidecar) + +`checkpoints/ck_XXXXXXXX.jld2` and its `.meta.toml`, zero-padded so a directory +listing sorts in run order. +""" +function checkpoint_paths(output::AbstractString, index::Integer) + dir = joinpath(output, "checkpoints") + name = @sprintf("ck_%08d.jld2", index) + return joinpath(dir, name), joinpath(dir, name * ".meta.toml") +end + +""" + write_segment_checkpoint(output, index, state, identity; kind) -> (path, sha) + +Write one self-contained, verified, monotonically numbered checkpoint. + +# What it preserves +Policy architecture and parameters, the optimizer state, the global update +count, the sampler's RNG state, the evaluation history, and the best admissible +evaluation with the checkpoint index that produced it. That list is the +definition of "self-contained for continuation": anything missing from it is +something a resumed run would silently restart. + +# Notes +ORDER MATTERS, and it is the same order the controller assumes. The payload is +written atomically and hashed FIRST; only then is the sidecar written naming +that digest. A crash between the two leaves a payload with no sidecar, which is +ignored; a crash before either leaves nothing. There is no interleaving that +leaves a sidecar vouching for a file that was never finished. + +The payload goes through [`save_checkpoint`](@ref) — the certified writer, which +moves everything to the host so a GPU checkpoint reloads on a CPU — into a +temporary path, which is then renamed. `save_checkpoint` writes with JLD2 +directly and is not atomic on its own; the rename is what makes it so. +""" +function write_segment_checkpoint(output::AbstractString, index::Integer, + state::NamedTuple, identity::AbstractDict; + kind::AbstractString = "periodic") + path, meta_path = checkpoint_paths(output, index) + mkpath(dirname(path)) + tmp = string(path, ".tmp.", getpid(), ".", time_ns()) + + meta = Dict{String,Any}( + "segment_schema" => RUNNER_CHECKPOINT_SCHEMA, + "case" => identity["case"], + "network_sha256" => state.network_sha256, + "num_stages" => identity["horizon"], + "panel_protocol" => identity["protocol_kind"], + "panel_columns" => collect(Int, state.eval_columns), + "panel_mean_cost" => state.best_cost, + "step" => Int(index), + "encoder_layers" => collect(Int, state.encoder_layers), + "head_layers" => collect(Int, state.head_layers), + "n_observation" => Int(state.n_observation), + "n_context" => Int(state.n_context), + # --- what makes it a SEGMENT checkpoint rather than a policy file ---- + "global_index" => Int(index), + "rng_state" => string(state.rng.state), + "trajectory_checksum" => state.checksum, + "best_cost" => state.best_cost, + "best_index" => Int(state.best_index), + "updates_total" => Int(index), + "workers" => Int(state.workers), + "trajectories" => Int(state.trajectories), + "peak_simultaneous_solves" => Int(state.peak), + "written_utc" => utcnow(), + "identity" => Dict{String,Any}(identity), + ) + save_checkpoint(tmp, state.policy, meta; + opt_state = state.opt_state, history = state.history) + mv(tmp, path; force = true) + sha = sha256_file(path) + + write_toml_atomic(meta_path, Dict{String,Any}( + "file" => basename(path), + "sha256" => sha, + "parent_sha256" => state.parent_sha, + "global_index" => Int(index), + "index_from" => Int(state.index_from), + "run_id" => state.run_id, + "segment" => Int(state.segment), + "attempt" => Int(state.attempt), + "kind" => kind, + "written_utc" => utcnow(), + )) + return path, sha +end + +""" + load_segment_checkpoint(path) -> (data, meta) + +Read a parent checkpoint, refusing it unless its sidecar digest matches the +payload on disk and it carries this file's segment schema. + +# Notes +The controller verifies checkpoints too. This check is not redundant with it: a +worker resuming from a file nobody re-hashed since the scan would be trusting a +window it cannot see into, and the two ends enforce the rule independently so +neither has to assume the other ran. +""" +function load_segment_checkpoint(path::AbstractString) + isfile(path) || error("--resume-from does not exist: $path") + meta_path = path * ".meta.toml" + if isfile(meta_path) + side = TOML.parsefile(meta_path) + got = sha256_file(path) + got == String(get(side, "sha256", "")) || error( + "parent checkpoint digest mismatch: $path has $got, its sidecar claims " * + "$(get(side, "sha256", "missing"))") + end + data = JLD2.load(path) + meta = data["meta"] + String(get(meta, "schema", "")) == BATTERY_CHECKPOINT_SCHEMA || error( + "parent checkpoint $path is not a $BATTERY_CHECKPOINT_SCHEMA policy file") + String(get(meta, "segment_schema", "")) == RUNNER_CHECKPOINT_SCHEMA || error( + "parent checkpoint $path carries segment schema " * + "$(repr(get(meta, "segment_schema", missing))) but this runner writes " * + "$RUNNER_CHECKPOINT_SCHEMA") + haskey(meta, "identity") || error( + "parent checkpoint $path carries no identity record; it was not written " * + "by this runner and cannot be continued") + return data, meta +end + +# ───────────────────────────────────────────────────────────────────────────── +# The segment +# ───────────────────────────────────────────────────────────────────────────── + +""" + moving_average(v, w) -> Vector{Float64} + +Trailing moving average of window `w`, defined from the first sample: + +``\\mathrm{ma}_i = \\frac{1}{\\min(i,w)} \\sum_{j=\\max(1,i-w+1)}^{i} v_j`` + +# Notes +The per-update training loss is one sample of a random objective — it is a +different estimand from the fixed-panel evaluation and is never compared with +it. Only its moving average is legible, so both are written and the raw column +is kept beside it. +""" +function moving_average(v::AbstractVector, w::Integer) + n = length(v) + out = zeros(Float64, n) + s = 0.0 + for i in 1:n + s += v[i] + i > w && (s -= v[i-w]) + out[i] = s / min(i, w) + end + return out +end + +""" + run_segment(a) -> Int + +Drive one segment: bind identity, resume or start, train to the segment's stop +index or until asked to stop, and write a verified checkpoint and an honest +result. Returns a process exit code. + +# The loop, one update +Draw `trajectories` scenarios from the frozen per-stage supports, roll the +policy forward on each, solve each strict deterministic equivalent, average the +per-trajectory actor gradients, and apply one Adam step at +`cosine_lr(i, target_index, lr, lr_final)`. This is the certified update of +[`train_strict`](@ref) built out of the same functions; what differs is only +that the index `i` is GLOBAL and the loop can be stopped and resumed at any +boundary between updates. + +A step in which every trajectory's solve failed applies nothing and does not +advance the global index — an index that moved without an update would make the +learning-rate schedule and the checksum disagree with an uninterrupted run. + +# Stopping +The stop file is polled after every COMPLETE update. On a stop request the +current update is already finished, a checkpoint is written and verified, an +honest `preempted` result is written, and the process exits 0. `complete` is +reported only when the configured target index was actually reached. +""" +function run_segment(a::AbstractDict) + t_start = time() + + # ---- the six scientific flags ----------------------------------------- + manifest_path = a["case-manifest"] + method = Symbol(a["method"]) + config_path = a["config"] + protocol_path = a["protocol"] + output = a["output"] + resume = get(a, "resume-from", "none") + + # ---- controller conveniences, every one defaulted ---------------------- + run_id = get(a, "run-id", "standalone") + segment = parse(Int, get(a, "segment", "1")) + attempt = parse(Int, get(a, "attempt", "1")) + stop_file = get(a, "stop-file", joinpath(output, "STOP")) + max_secs = parse(Float64, get(a, "max-seconds", "1e9")) + + # ---- method ownership, before anything is loaded ----------------------- + # Refused BY NAME and pointed at the engine that owns it, the same way + # `run_battery_method` does. A runner that half-implemented the other pair + # would fail somewhere far less legible than here. + if !(method in RUNNER_METHODS) + haskey(BATTERY_METHODS, method) || error( + "unknown method :$method; the study's methods are " * + "$(sort!(collect(keys(BATTERY_METHODS))))") + error("method :$method runs on the $(battery_method(method).engine) engine " * + "(DecisionRules.jl/examples/BatteryStorageOPF/portfolio_runner.jl), not on " * + "this one; this package loads neither PowerModels nor SDDP") + end + + mkpath(joinpath(output, "checkpoints")) + conf = TOML.parsefile(config_path) + haskey(conf, "method") && String(conf["method"]) != String(method) && error( + "the frozen config names method $(conf["method"]) but --method is $method") + + target_index = Int(get(conf, "target_index", 2000)) + segment_updates = Int(get(conf, "segment_updates", 500)) + ckpt_every = Int(get(conf, "checkpoint_every", 50)) + eval_every = Int(get(conf, "eval_every", 100)) + ma_window = Int(get(conf, "ma_window", 25)) + num_stages = Int(get(conf, "num_stages", 24)) + trajectories = Int(get(conf, "trajectories", 2)) + workers = Int(get(conf, "workers", BATTERY_DEFAULT_WORKERS)) + lr = Float64(get(conf, "lr", 1e-3)) + lr_final = Float64(get(conf, "lr_final", 1e-4)) + encoder_layers = _int_list(get(conf, "encoder_layers", [64, 64])) + head_layers = _int_list(get(conf, "head_layers", [128, 128])) + eval_columns = _int_list(get(conf, "eval_columns", [1, 2, 3, 4])) + seed = Int(get(conf, "seed", 20260804)) + device = String(get(conf, "device", "cpu")) + max_recourse = Float64(get(conf, "max_recourse", 1e-6)) + + trajectories >= workers || error( + "the frozen config sets trajectories=$trajectories and workers=$workers; " * + "a worker with no scenario to solve would idle for the whole segment") + workers <= Threads.nthreads() || @warn( + "workers=$workers but this process has $(Threads.nthreads()) thread(s): a " * + "blocking solve cannot overlap another on one thread, so the solves will " * + "serialize and `peak_simultaneous_solves` will not reach `workers`") + + # ---- the frozen case, its protocol, and the identity ------------------- + case_dir = dirname(abspath(manifest_path)) + basename(manifest_path) == "case_manifest.json" || error( + "--case-manifest must name a case_manifest.json, got $(basename(manifest_path))") + case = read_battery_case(case_dir) + + # The protocol is resolved BEFORE the first update, so a run launched + # against the wrong panel dies at its start rather than at its first + # evaluation — and so no scenario outcome is computed on the way to finding + # out. + eval_matrix, protocol_kind, _ = resolve_protocol(case, protocol_path) + size(eval_matrix, 1) >= num_stages || error( + "the $protocol_kind protocol covers $(size(eval_matrix, 1)) stages but " * + "training asks for $num_stages") + maximum(eval_columns) <= size(eval_matrix, 2) || error( + "panel column $(maximum(eval_columns)) is outside the $protocol_kind " * + "protocol's $(size(eval_matrix, 2)) columns") + + ident = run_identity(; manifest_path = manifest_path, case = case, method = method, + config_path = config_path, conf = conf, + protocol_path = protocol_path, protocol_kind = protocol_kind, + num_stages = num_stages, conf_workers = workers, + conf_trajectories = trajectories) + write_toml_atomic(joinpath(output, "identity.toml"), ident) + + @printf("segment %s seg%d att%d · method %s · case %s\n", + run_id, segment, attempt, method, case.name) + @printf(" panel: %s protocol, %d of %d columns · identity %s\n", + protocol_kind, length(eval_columns), size(eval_matrix, 2), + first(ident["identity_sha256"], 16)) + + # ---- build the policy and the problem ---------------------------------- + backend, to_device, solver_kwargs = configure_device(device) + prob = build_battery_exa(case, num_stages; backend = backend) + Random.seed!(seed) + rng = StableRNG(seed) + policy = to_device(battery_reachable_policy(case, encoder_layers; + n_observation = prob.nBus, + n_context = N_CONTEXT, + head_layers = head_layers, + architecture = method)) + assert_device(policy, device) + opt_state = Optimisers.setup(Optimisers.Adam(lr), policy) + + history = NamedTuple[] + evaluations = NamedTuple[] + best_cost = Inf + best_index = 0 + checksum = 0.0 + index_from = 0 + parent_sha = "none" + + # ---- resume ------------------------------------------------------------ + if resume != "none" && !isempty(resume) + data, meta = load_segment_checkpoint(resume) + assert_identity(ident, Dict{String,Any}(meta["identity"]), "parent checkpoint") + load_checkpoint!(policy, resume; case = case) + # `load_checkpoint!` returns the host copy of the optimizer state; it has + # to travel to the policy's device or the first update mixes memories. + st = get(data, "opt_state", nothing) + st === nothing && error("parent checkpoint carries no optimizer state") + opt_state = to_device(st) + h = get(data, "history", nothing) + history = h === nothing ? NamedTuple[] : collect(h) + index_from = Int(meta["global_index"]) + checksum = Float64(meta["trajectory_checksum"]) + best_cost = Float64(meta["best_cost"]) + best_index = Int(meta["best_index"]) + rng.state = parse(UInt128, String(meta["rng_state"])) + parent_sha = sha256_file(resume) + @printf(" resumed from index %d · checksum %.10e · best %.6f\n", + index_from, checksum, best_cost) + end + + stop_target = min(target_index, index_from + segment_updates) + index_from < stop_target || error( + "nothing to do: resumed at $index_from with stop target $stop_target") + + # ---- local artifacts --------------------------------------------------- + # `history.csv` is the controller's fixed seven-column schema. The richer + # per-update record goes to `trajectory.csv` and the panel to + # `evaluation.csv`, so no consumer has to guess which column means what. + hist_io = open(joinpath(output, "history.csv"), "w") + println(hist_io, "index,train_loss,panel_value,bound,solve_ok,solve_fail,deficit") + flush(hist_io) + + losses_seen = Float64[] + traj_rows = Tuple{Int,Float64,Float64,Float64}[] + solve_ok = 0 + solve_fail = 0 + worst_deficit = 0.0 + e0 = initial_energy(case) + like = _policy_array(policy) + e0_dev = _to_like(like, e0) + + # Persistent workers for the whole segment: each binds the device and then + # builds its OWN problem and solver inside its own task. They are shut down + # in `finally`, including on a stop-file exit or an exception. + pool = battery_worker_pool(case, num_stages, device, solver_kwargs; workers = workers) + dispatched_ids = Int[]; accepted_ids = Int[]; rejected_ids = Int[] + @printf(" workers %d · trajectories %d · peak simultaneous solves reported per batch\n", + workers, trajectories) + for r in pool.report + @printf(" worker %d: device %s stream %s linear_solver %s problem @%s\n", + r.worker, r.device, r.stream, r.linear_solver, string(r.problem; base = 16)) + end + # FLUSH. This process is killed by a signal when the wall or a preemption + # arrives, and anything still in Julia's stdout buffer dies with it — a + # segment that ran for hours would leave an empty log. Flushing here and + # after every update keeps the record legible at the moment it matters most. + flush(stdout) + + # TIME ACCOUNTING. The 12-hour budget is on ACTIVE TRAINING, so the three + # costs are measured separately rather than lumped into one wall figure: + # setup (case load, protocol resolution, policy build, worker pool), + # training (the gradient batches), and evaluation (the screening panel). + # Queue time and depot construction happen outside this process entirely and + # are reported by the controller, not here. + setup_seconds = time() - t_start + training_seconds = 0.0 + evaluation_seconds = 0.0 + + idx = index_from + last_ck_path = resume == "none" ? "" : resume + last_ck_sha = parent_sha + reason = "segment_updates_reached" + + _state() = (policy = policy, opt_state = opt_state, history = history, + workers = workers, trajectories = trajectories, peak = pool.peak, + rng = rng, checksum = checksum, best_cost = best_cost, + best_index = best_index, parent_sha = parent_sha, + index_from = index_from, run_id = run_id, segment = segment, + attempt = attempt, eval_columns = eval_columns, + encoder_layers = encoder_layers, head_layers = head_layers, + n_observation = prob.nBus, n_context = N_CONTEXT, + network_sha256 = case.manifest["artifacts"]["network.json"]) + + try + while idx < stop_target + i = idx + 1 + this_lr = cosine_lr(i, target_index, lr, lr_final) + Optimisers.adjust!(opt_state, this_lr) + + # THE SHARED BATCH. Scenarios are drawn in order and numbered, dispatched + # up to `workers` at a time, collected by scenario NUMBER and reduced in + # scenario-number order — so the update does not depend on which solve + # finished first, and the sampler advances by exactly `trajectories` + # draws whatever the worker count is. + _t_batch = time() + batch = trajectory_batch!(pool, policy, prob, case, rng, num_stages, e0_dev, like; + solver_kwargs = solver_kwargs, + trajectories = trajectories, index = i) + training_seconds += time() - _t_batch + grads = batch.grads + losses = batch.losses + solve_ok += length(batch.accepted) + solve_fail += length(batch.rejected) + worst_deficit = max(worst_deficit, batch.worst_recourse) + append!(dispatched_ids, batch.dispatched) + append!(accepted_ids, batch.accepted) + append!(rejected_ids, batch.rejected) + + if isempty(losses) + # Every trajectory failed: nothing is applied and the global index + # does not move. Retrying with the next draws is the only choice + # that keeps index, schedule and checksum consistent. + @warn "no usable trajectory at index $i; retrying with the next draws" + if isfile(stop_file) || (time() - t_start) > max_secs + reason = isfile(stop_file) ? "signal_stop" : "max_seconds" + break + end + continue + end + + grads = _scale_grads(grads, 1 / length(losses)) + opt_state, policy = Optimisers.update!(opt_state, policy, grads) + idx = i + l = mean(losses) + checksum += l + push!(history, (step = idx, loss = l, lr = this_lr)) + push!(losses_seen, l) + push!(traj_rows, (idx, l, this_lr, time() - t_start)) + @printf("update %6d loss %16.6f lr %.3e\n", idx, l, this_lr) + flush(stdout) + + # ---- fixed-panel evaluation and checkpoint selection --------------- + panel_value = NaN + if eval_every > 0 && (idx % eval_every == 0 || idx == stop_target) + _t_eval = time() + ev = evaluate_panel(policy, prob, case, eval_columns; + max_recourse = max_recourse, solver_kwargs = solver_kwargs) + evaluation_seconds += time() - _t_eval + panel_value = ev.mean_cost + selected = ev.complete && ev.mean_cost < best_cost + selected && (best_cost = ev.mean_cost; best_index = idx) + push!(evaluations, (index = idx, protocol = String(ev.protocol), + mean_cost = ev.mean_cost, worst_recourse = ev.worst_recourse, + complete = ev.complete, selected = selected, + best_cost = best_cost)) + @printf(" %s panel: mean %16.6f worst recourse %.3e complete %s%s\n", + ev.protocol, ev.mean_cost, ev.worst_recourse, ev.complete, + selected ? " [selected]" : "") + flush(stdout) + end + + @printf(hist_io, "%d,%.10f,%s,NaN,%d,%d,%.10e\n", idx, l, + isnan(panel_value) ? "NaN" : @sprintf("%.10f", panel_value), + solve_ok, solve_fail, worst_deficit) + flush(hist_io) + + # ---- checkpoint ---------------------------------------------------- + if idx % ckpt_every == 0 || idx == stop_target + last_ck_path, last_ck_sha = write_segment_checkpoint( + output, idx, _state(), ident; + kind = idx == stop_target ? "final" : "periodic") + end + + # ---- graceful stop, between complete updates ----------------------- + if isfile(stop_file) || (time() - t_start) > max_secs + reason = isfile(stop_file) ? "signal_stop" : "max_seconds" + @info "stopping early" reason index = idx + if idx % ckpt_every != 0 && idx != stop_target + last_ck_path, last_ck_sha = write_segment_checkpoint( + output, idx, _state(), ident; kind = "periodic") + end + break + end + end + finally + close_worker_pool!(pool) + end + close(hist_io) + + # ---- the richer local artifacts ---------------------------------------- + ma = moving_average(losses_seen, ma_window) + open(joinpath(output, "trajectory.csv"), "w") do io + println(io, "index,train_loss,train_loss_ma$(ma_window),lr,wall_seconds") + for (k, r) in enumerate(traj_rows) + @printf(io, "%d,%.10f,%.10f,%.6e,%.3f\n", r[1], r[2], ma[k], r[3], r[4]) + end + end + open(joinpath(output, "evaluation.csv"), "w") do io + println(io, "index,protocol,columns,mean_cost,worst_recourse,complete,selected,best_cost") + for e in evaluations + @printf(io, "%d,%s,%s,%.10f,%.6e,%s,%s,%.10f\n", e.index, e.protocol, + join(eval_columns, " "), e.mean_cost, e.worst_recourse, + e.complete, e.selected, e.best_cost) + end + end + + # ---- the segment result ------------------------------------------------- + reached = idx >= stop_target + reached && idx >= target_index && (reason = "target_reached") + isempty(last_ck_path) && error( + "the segment produced no checkpoint; refusing to write a result that " * + "claims progress it cannot evidence") + + here = @__DIR__ + projdir = dirname(something(Base.active_project(), joinpath(here, "Project.toml"))) + result = Dict{String,Any}( + "schema" => RUNNER_RESULT_SCHEMA, + "run_id" => run_id, + "segment" => segment, + "attempt" => attempt, + "method" => String(method), + "status" => reached ? "complete" : "preempted", + # `status` is the SEGMENT's verdict, and the controller depends on that: + # a segment that finished its planned updates must be acceptable, or a + # multi-segment run could never make progress. Whether the RUN is + # finished is a different question and gets its own field — a reader + # must never infer "the run reached its target" from "the segment + # completed". `termination_reason` separates them too: + # `target_reached` only when the configured target index was reached. + "run_complete" => idx >= target_index, + "termination_reason" => reason, + "command" => join(vcat(["julia", "--project=" * projdir, @__FILE__], + ARGS), " "), + "julia_version" => string(VERSION), + "project_toml_sha256" => sha256_file(joinpath(projdir, "Project.toml")), + "manifest_toml_sha256" => isfile(joinpath(projdir, "Manifest.toml")) ? + sha256_file(joinpath(projdir, "Manifest.toml")) : "none", + "code_commit" => git_commit(here), + "code_digest" => runner_code_digest(here), + "case_manifest" => abspath(manifest_path), + "case_digest" => sha256_file(manifest_path), + "config_digest" => sha256_file(config_path), + "protocol_digest" => sha256_file(protocol_path), + "protocol_kind" => String(protocol_kind), + "support_digest" => String(case.manifest["support"]["sha256"]), + "identity_digest" => ident["identity_sha256"], + "parent_checkpoint" => resume, + "parent_sha256" => parent_sha, + "child_checkpoint" => last_ck_path, + "child_sha256" => last_ck_sha, + "index_from" => index_from, + "index_to" => idx, + "updates_completed" => idx - index_from, + "target_index" => target_index, + "wall_seconds" => round(time() - t_start, digits = 3), + "setup_seconds" => round(setup_seconds, digits = 3), + "training_seconds" => round(training_seconds, digits = 3), + "evaluation_seconds" => round(evaluation_seconds, digits = 3), + "gpu_seconds" => lowercase(device) == "gpu" ? + round(time() - t_start, digits = 3) : 0.0, + "device" => device, + # The accelerator as MEASURED, not as configured: what each worker bound + # to, how many solves were ever in flight at once, and which scenario + # numbers were dispatched, accepted and rejected. + "workers" => workers, + "trajectories" => trajectories, + "peak_simultaneous_solves" => pool.peak, + "worker_devices" => [String(r.device) for r in pool.report], + "worker_streams" => [String(r.stream) for r in pool.report], + "worker_linear_solver" => [String(r.linear_solver) for r in pool.report], + "worker_problem_ids" => [string(r.problem; base = 16) for r in pool.report], + "distinct_problems" => length(unique(r.problem for r in pool.report)), + # TRUE only if a run configured for the GPU ended up with a worker that + # is not on a CUDA device. Reported for every run, so "no CPU fallback" + # is a measurement rather than an assumption. + "cpu_fallback" => lowercase(device) == "gpu" && + !all(occursin("CuDevice", String(r.device)) + for r in pool.report), + "scenarios_dispatched" => length(dispatched_ids), + "scenarios_accepted" => length(accepted_ids), + "scenarios_rejected" => length(rejected_ids), + "solve_total" => solve_ok + solve_fail, + "solve_optimal" => solve_ok, + "solve_failed" => solve_fail, + "physical_deficit" => worst_deficit, + "physical_surplus" => 0.0, + "best_panel_cost" => best_cost == Inf ? NaN : best_cost, + "best_panel_index" => best_index, + "trajectory_checksum" => checksum, + "history_rows" => length(traj_rows), + "history_sha256" => sha256_file(joinpath(output, "history.csv")), + "slurm_job_id" => get(ENV, "SLURM_JOB_ID", ""), + "slurm_array_id" => get(ENV, "SLURM_ARRAY_JOB_ID", ""), + "node" => gethostname(), + "started_utc" => Dates.format(unix2datetime(t_start), + dateformat"yyyy-mm-dd\THH:MM:SS\Z"), + "finished_utc" => utcnow(), + "eval_indices" => [e.index for e in evaluations], + "eval_values" => [e.mean_cost for e in evaluations], + ) + write_toml_atomic(joinpath(output, "result.toml"), result) + @printf("segment done · %s · index %d→%d · checksum %.10e · best %.6f\n", + result["status"], index_from, idx, checksum, best_cost) + return 0 +end + +""" + main(args=ARGS) -> Int + +Check that the six scientific flags are present, then run one segment. +""" +function main(args = ARGS) + a = parse_args(args) + for k in ("case-manifest", "method", "config", "protocol", "output") + haskey(a, k) || error("--$k is required; see the header of $(@__FILE__)") + end + return run_segment(a) +end + +if abspath(PROGRAM_FILE) == @__FILE__ + exit(main(ARGS)) +end diff --git a/examples/BatteryStorageOPF/test/runtests.jl b/examples/BatteryStorageOPF/test/runtests.jl new file mode 100644 index 0000000..023c9f0 --- /dev/null +++ b/examples/BatteryStorageOPF/test/runtests.jl @@ -0,0 +1,1042 @@ +# Consolidated regression suite for the ExaModels/GPU battery engine. +# +# One file, grouped by the property being protected. The manual ACP formulation +# is checked against the physics (residuals recomputed from the reported +# solution, independently of the model that produced it) and against the case +# contract; its agreement with the actual PowerModels ACP model is checked by a +# separate cross-engine gate outside this package, because only a gate that +# depends on both packages at once can load both engines. +# +# julia --project=. test/runtests.jl +# DR_BAT_DEVICE=gpu julia --project=. test/runtests.jl # additionally on a GPU + +using Test +using Flux +using Zygote +using Random +using Statistics +using LinearAlgebra +using MadNLP +using JLD2 + +const EXAMPLE = dirname(@__DIR__) +include(joinpath(EXAMPLE, "train_battery_exa_strict.jl")) # pulls in the whole engine + +const CASE_DIR = get(ENV, "DR_BAT_CASE_DIR", + joinpath(EXAMPLE, "case", "pglib_opf_case14_ieee")) + +# Cases are CONSTRUCTED by the JuMP package's builder and MIRRORED here; nothing +# under `case/` is committed, because a committed artifact is a second source of +# truth that can drift from the builder that defines it. This engine cannot build +# one — it has no PGLib dependency by design — so it says exactly what to run. +isfile(joinpath(CASE_DIR, "case_manifest.json")) || error(""" +no case at $CASE_DIR. Build and mirror it from the JuMP package first: + + cd /path/to/DecisionRules.jl/examples/BatteryStorageOPF + DR_BAT_MIRROR=$(dirname(EXAMPLE))/$(basename(EXAMPLE)) julia --project=. build_battery_case.jl +""") +const DEVICE = get(ENV, "DR_BAT_DEVICE", "cpu") + +@testset "battery storage OPF (Exa engine)" begin + + case = read_battery_case(CASE_DIR) + net = exa_network(case) + Δt = stage_hours(case) + bats = sort(collect(case.batteries); by = b -> b.index) + nBat = length(bats) + backend, to_device, solver_kwargs = configure_device(DEVICE) + + # ── The network parse ──────────────────────────────────────────────────── + @testset "network parse" begin + @test nbus(net) == length(case.network["bus"]) + @test ngen(net) == count(g -> Int(get(g[2], "gen_status", 1)) != 0, case.network["gen"]) + @test nbranch(net) == count(b -> Int(get(b[2], "br_status", 1)) != 0, case.network["branch"]) + @test !isempty(net.ref_bus_positions) + @test sum(net.nominal_pd) ≈ sum(Float64(l["pd"]) for (_, l) in case.network["load"]) + @test sum(net.nominal_qd) ≈ sum(Float64(l["qd"]) for (_, l) in case.network["load"]) + # Shunts live in their own table and must reach the bus they belong to. + for (_, sh) in get(case.network, "shunt", Dict{String,Any}()) + p = net.bus_pos[Int(sh["shunt_bus"])] + @test net.buses[p].bs != 0.0 || Float64(get(sh, "bs", 0.0)) == 0.0 + end + + # Component identifiers are IDENTITIES, not positions: a case whose bus + # ids are relabelled to a sparse set must parse to the same physics. + relabelled = deepcopy(case.network) + remap = Dict(Int(b["index"]) => 100 * Int(b["index"]) + 7 for (_, b) in case.network["bus"]) + newbus = Dict{String,Any}() + for (_, b) in relabelled["bus"] + b["index"] = remap[Int(b["bus_i"])] + b["bus_i"] = b["index"] + newbus[string(b["index"])] = b + end + relabelled["bus"] = newbus + for (_, g) in relabelled["gen"]; g["gen_bus"] = remap[Int(g["gen_bus"])]; end + for (_, l) in relabelled["load"]; l["load_bus"] = remap[Int(l["load_bus"])]; end + for (_, s) in relabelled["shunt"]; s["shunt_bus"] = remap[Int(s["shunt_bus"])]; end + for (_, br) in relabelled["branch"] + br["f_bus"] = remap[Int(br["f_bus"])] + br["t_bus"] = remap[Int(br["t_bus"])] + end + rcase = BatteryCase(case.dir, case.name, relabelled, + [BatterySpec(b.index, remap[b.bus], b.energy_min, b.energy_max, + b.energy_initial, b.charge_max, b.discharge_max, + b.charge_efficiency, b.discharge_efficiency, + b.self_discharge, b.throughput_cost) for b in bats], + case.recourse, case.demand, case.manifest) + rnet = exa_network(rcase) + @test nbus(rnet) == nbus(net) && ngen(rnet) == ngen(net) && nbranch(rnet) == nbranch(net) + @test rnet.nominal_pd ≈ net.nominal_pd + @test [b.f_pos for b in rnet.branches] == [b.f_pos for b in net.branches] + @test rnet.ref_bus_positions == net.ref_bus_positions + end + + # ── Model structure ────────────────────────────────────────────────────── + @testset "model structure" begin + T = 3 + prob = build_battery_exa(case, T; backend = backend) + nB, nG, nBR = prob.nBus, prob.nGen, prob.nBranch + @test prob.model.meta.nvar == 2T * nB + 2T * nG + 4T * nBR + 2T * nB + 2T * nBat + @test length(prob.transition_range) == T * nBat + @test last(prob.transition_range) == prob.model.meta.ncon # transitions are LAST + + lv = Array(prob.model.meta.lvar); uv = Array(prob.model.meta.uvar) + off = 2T * nB + 2T * nG + 4T * nBR + rng_d = (off + 1):(off + T * nB) + rng_s = (off + T * nB + 1):(off + 2T * nB) + # Two-sided recourse: nonnegative, and uncapped in both directions. + @test all(==(0.0), lv[rng_d]) && all(isinf, uv[rng_d]) + @test all(==(0.0), lv[rng_s]) && all(isinf, uv[rng_s]) + # Charge/discharge respect the case's power ratings. + rng_ch = (off + 2T * nB + 1):(off + 2T * nB + T * nBat) + @test all(==(0.0), lv[rng_ch]) + @test maximum(uv[rng_ch]) ≈ maximum(b.charge_max for b in bats) + @test eltype(prob.model.meta.x0) === Float64 + end + + # ── The strict solve and its multipliers ───────────────────────────────── + @testset "strict solve" begin + T = 3 + prob = build_battery_exa(case, T; backend = backend) + atoms = [3, 1, 2] + pd, qd = realized_demand(case, net, collect(1:T), atoms) + set_demand!(prob, pd, qd) + e0 = initial_energy(case) + + function targets(frac) + xs = Float64[]; prev = copy(e0) + for _ in 1:T + nxt = similar(prev) + for (k, b) in enumerate(bats) + lo, hi = reachable_interval(b, prev[k], Δt) + nxt[k] = lo + frac * (hi - lo) + end + append!(xs, nxt); prev = nxt + end + return xs + end + + x = targets(0.45) + set_energy_path!(prob, e0, x) + # The strict-mode invariant: the parameter's first block IS the initial + # state, because the model has no initial-condition row. + @test prob.energy_values[1:nBat] ≈ e0 + res = solve!(prob; solver_kwargs...) + @test solve_succeeded(res) + sol = battery_solution(prob, res) + cost = stage_costs(prob, sol) + @test sum(cost.total) ≈ res.objective atol = 1e-6 + @test maximum(sol.deficit) < 1e-6 && maximum(sol.surplus) < 1e-6 + @test maximum(min.(sol.p_ch, sol.p_dis)) < 1e-6 # no simultaneous operation + + # The reported trajectory IS the target, exactly: energy is a parameter. + @test vec(sol.energy[:, 2:end]) ≈ x atol = 1e-12 + + # Residuals recomputed independently of the model that produced them. + for t in 1:T + s = (vm = Dict(net.buses[i].id => sol.vm[i, t] for i in eachindex(net.buses)), + va = Dict(net.buses[i].id => sol.va[i, t] for i in eachindex(net.buses)), + pg = Dict(net.gens[i].id => sol.pg[i, t] for i in eachindex(net.gens)), + qg = Dict(net.gens[i].id => sol.qg[i, t] for i in eachindex(net.gens)), + p_fr = Dict(net.branches[i].id => sol.p_fr[i, t] for i in eachindex(net.branches)), + q_fr = Dict(net.branches[i].id => sol.q_fr[i, t] for i in eachindex(net.branches)), + p_to = Dict(net.branches[i].id => sol.p_to[i, t] for i in eachindex(net.branches)), + q_to = Dict(net.branches[i].id => sol.q_to[i, t] for i in eachindex(net.branches)), + deficit = Dict(net.buses[i].id => sol.deficit[i, t] for i in eachindex(net.buses)), + surplus = Dict(net.buses[i].id => sol.surplus[i, t] for i in eachindex(net.buses)), + pd = Dict(net.buses[i].id => pd[t, i] for i in eachindex(net.buses)), + qd = Dict(net.buses[i].id => qd[t, i] for i in eachindex(net.buses)), + p_ch = Dict(bats[k].index => sol.p_ch[k, t] for k in 1:nBat), + p_dis = Dict(bats[k].index => sol.p_dis[k, t] for k in 1:nBat), + energy_in = Dict(bats[k].index => sol.energy[k, t] for k in 1:nBat), + energy_out = Dict(bats[k].index => sol.energy[k, t + 1] for k in 1:nBat)) + r = physical_residuals(case.network, bats, Δt, s) + @test r.branch_flow < 1e-6 + @test r.active_balance < 1e-8 + @test r.reactive_balance < 1e-8 + @test r.transition < TRANSITION_RESIDUAL_TOL + @test r.thermal < 1e-6 + @test r.voltage < 1e-6 + end + + # The multiplier is the derivative of the solved value in the target, + # including the self-discharge factor that couples adjacent rows. + λ = target_multipliers(prob, res) + @test length(λ) == T * nBat + h = 1e-5 + for i in (1, nBat + 2, (T - 1) * nBat + 3) + xp = copy(x); xp[i] += h + xm = copy(x); xm[i] -= h + set_energy_path!(prob, e0, xp) + vp = solve!(prob; solver_kwargs...).objective + set_energy_path!(prob, e0, xm) + vm_ = solve!(prob; solver_kwargs...).objective + @test (vp - vm_) / (2h) ≈ λ[i] rtol = 1e-4 + end + end + + # ── A generator that exists in some stages and not others ──────────────── + # The case may declare a per-stage availability schedule for any generator + # (`STAGE_AVAILABILITY_KEY`). The JuMP engine applies it to the parsed network + # before PowerModels instantiates each stage; this engine builds every stage + # at once, so it applies it to each stage's generator BOUNDS instead. The + # failure this guards against is silence: a schedule that is written into a + # case, hashed and mirrored here, and then ignored by the model builder, would + # give this engine a generator that is always available while the JuMP engine, + # the case record and the digest all say otherwise — two engines solving two + # different problems, which is the one thing this suite exists to prevent. + @testset "per-stage generator availability" begin + # ── Additivity: the frozen case declares no schedule ────────────────── + # A case built before this convention existed must build EXACTLY as it + # did then: one `repeat` of the case's own limits per stage, compared + # bit-for-bit rather than approximately. + @test all(isempty(g.availability) for g in net.gens) + T = 2 + plain = build_battery_exa(case, T; backend = backend) + off_p = 2T * nbus(net) + off_q = off_p + T * ngen(net) + plv = Array(plain.model.meta.lvar); puv = Array(plain.model.meta.uvar) + # An EXACTLY degenerate box is not a box in this model: `_pin_exact_boxes!` + # opens it and pins the variable with the equality row `x − v = 0`, which + # is the same feasible set without the zero-width bound an interior-point + # method mishandles. The expectation therefore carries that transform. + opened(lo, hi) = lo == hi ? (-Inf, Inf) : (lo, hi) + want_p = [opened(g.pmin, g.pmax) for g in net.gens] + want_q = [opened(isfinite(g.qmin) ? g.qmin : -1e4, + isfinite(g.qmax) ? g.qmax : 1e4) for g in net.gens] + @test plv[(off_p + 1):(off_p + T * ngen(net))] == repeat(first.(want_p), T) + @test puv[(off_p + 1):(off_p + T * ngen(net))] == repeat(last.(want_p), T) + @test plv[(off_q + 1):(off_q + T * ngen(net))] == repeat(first.(want_q), T) + @test puv[(off_q + 1):(off_q + T * ngen(net))] == repeat(last.(want_q), T) + # No zero-width box survives anywhere in the model, which is the property + # the reformulation exists to guarantee. + @test !any(i -> plv[i] == puv[i], eachindex(plv)) + + # ── The fixture ─────────────────────────────────────────────────────── + # An in-memory case whose generator `gid` is FREE to run and carries the + # schedule `av`. Nothing is written to disk: the schedule is network data, + # and a test that had to run the JuMP builder could not run in this + # environment at all. + # + # The unit is made free rather than picked for being dispatched, so that + # the always-available twin further down is a decisive null control by + # construction: a zero-cost unit runs unless something stops it, so a + # stage-2 output of exactly zero can only be the schedule. Picking a unit + # by its dispatch would make the control depend on the frozen case's + # economics, which is not what is being tested here. + refbuses = Set(net.buses[p].id for p in net.ref_bus_positions) + cands = [i for (i, g) in enumerate(net.gens) + if !(net.buses[g.bus_pos].id in refbuses)] + @test !isempty(cands) + gpos = cands[argmax([net.gens[i].pmax for i in cands])] + GID = net.gens[gpos].id + + function fixture(av; free::Bool = true) + netj = deepcopy(case.network) + g = netj["gen"][string(GID)] + if free + g["model"] = 2; g["ncost"] = 2; g["cost"] = [0.0, 0.0] + end + av === nothing ? delete!(g, STAGE_AVAILABILITY_KEY) : + (g[STAGE_AVAILABILITY_KEY] = av) + return BatteryCase(case.dir, case.name, netj, case.batteries, + case.recourse, case.demand, case.manifest) + end + + base = build_battery_exa(fixture(nothing), T; backend = backend) + fnet = exa_network(fixture(nothing)) + gsel = fnet.gens[gpos] + @test gsel.id == GID + lv = Array(base.model.meta.lvar); uv = Array(base.model.meta.uvar) + + # ── What the parser refuses ─────────────────────────────────────────── + @test_throws ErrorException exa_network(fixture(Float64[])) + @test_throws ErrorException exa_network(fixture(1.0)) + @test_throws ErrorException exa_network(fixture([1.0, 1.5])) + @test_throws ErrorException exa_network(fixture([1.0, -0.5])) + @test_throws ErrorException exa_network(fixture([1.0, NaN])) + # Inconsistent bounds are checked where the new data is read. + badb = fixture([1.0, 0.0]) + badb.network["gen"][string(GID)]["pmin"] = Float64(gsel.pmax) + 1.0 + @test_throws ErrorException exa_network(badb) + + # ── Scaling is per stage, and covers reactive as well as active ─────── + sched = fixture([1.0, 0.0]) + snet = exa_network(sched) + @test snet.gens[gpos].availability == [1.0, 0.0] + @test availability_at(snet.gens[gpos], 1) == 1.0 + @test availability_at(snet.gens[gpos], 2) == 0.0 + sprob = build_battery_exa(sched, T; backend = backend) + # The model's VARIABLE shape does not depend on the schedule. + @test sprob.model.meta.nvar == base.model.meta.nvar + slv = Array(sprob.model.meta.lvar); suv = Array(sprob.model.meta.uvar) + nG = ngen(net) + p1 = off_p + gpos; p2 = off_p + nG + gpos + q1 = off_q + gpos; q2 = off_q + nG + gpos + @test slv[p1] == gsel.pmin && suv[p1] == gsel.pmax # stage 1: untouched + # Stage 2 is exactly out. The unit is taken out by an EQUALITY row now, + # not by a zero-width box, so its box is OPEN and the pin is what holds + # it at zero — the same feasible set, and the dispatch below proves it. + @test slv[p2] == -Inf && suv[p2] == Inf + @test slv[q2] == -Inf && suv[q2] == Inf + # The scheduled build carries one pin per fully-unavailable p and q entry + # more than the unscheduled one. + @test sprob.model.meta.ncon == base.model.meta.ncon + 2 + @test slv[q1] == lv[q1] && suv[q1] == uv[q1] + # Every other generator, in both stages, is exactly as it was. + for i in 1:(T * nG) + (i == gpos || i == nG + gpos) && continue + @test slv[off_p + i] == lv[off_p + i] && suv[off_p + i] == uv[off_p + i] + @test slv[off_q + i] == lv[off_q + i] && suv[off_q + i] == uv[off_q + i] + end + # A schedule of all ones is the null control for that zero: same case, + # same unit, and bounds identical to the unscheduled build. + ones_prob = build_battery_exa(fixture([1.0, 1.0]), T; backend = backend) + @test Array(ones_prob.model.meta.lvar) == lv + @test Array(ones_prob.model.meta.uvar) == uv + + # ── A stage the schedule does not cover is an error, never the last ─── + @test_throws ErrorException build_battery_exa(sched, 3; backend = backend) + @test_throws ErrorException build_battery_exa(sched, 1; backend = backend, + stages = [3]) + + # ── A WINDOW of the horizon reads that window's entry ───────────────── + # A continuation problem is the case's stage 2 solved on its own, and it + # must see stage 2's availability, not the first entry of the schedule. + w2 = build_battery_exa(sched, 1; backend = backend, stages = [2]) + @test w2.stages == [2] + @test Array(w2.model.meta.lvar)[2 * nbus(net) + gpos] == -Inf + @test Array(w2.model.meta.uvar)[2 * nbus(net) + gpos] == Inf + w1 = build_battery_exa(sched, 1; backend = backend, stages = [1]) + @test Array(w1.model.meta.uvar)[2 * nbus(net) + gpos] == gsel.pmax + # And the window is enforced at the solve site rather than assumed: a + # scheduled problem refuses an offset it was not built for, while an + # unscheduled one accepts every offset exactly as it always did. + @test assert_stage_window(sprob, [1, 2]) === nothing + @test_throws ErrorException assert_stage_window(sprob, [2, 3]) + @test assert_stage_window(base, [2, 3]) === nothing + @test !has_stage_schedule(base) && has_stage_schedule(sprob) + + # ── What it DISPATCHES ──────────────────────────────────────────────── + # One demand realization, one strict trajectory, imposed on the scheduled + # problem and on its always-available twin. The schedule is the only + # difference between the two. + atoms = [1, 2] + pd2, qd2 = realized_demand(sched, snet, collect(1:T), atoms) + e0 = initial_energy(sched) + xs = Float64[]; prev = copy(e0) + for _ in 1:T + nxt = similar(prev) + for (k, b) in enumerate(bats) + lo, hi = reachable_interval(b, prev[k], Δt) + nxt[k] = lo + 0.5 * (hi - lo) + end + append!(xs, nxt); prev = nxt + end + set_demand!(sprob, pd2, qd2); set_energy_path!(sprob, e0, xs) + sres = solve!(sprob; solver_kwargs...) + @test solve_succeeded(sres) + ssol = battery_solution(sprob, sres) + @test abs(ssol.pg[gpos, 2]) <= 1e-9 # the schedule's own property + @test abs(ssol.qg[gpos, 2]) <= 1e-9 + # The null control dispatches the same unit in the same stage without it. + set_demand!(ones_prob, pd2, qd2); set_energy_path!(ones_prob, e0, xs) + ores = solve!(ones_prob; solver_kwargs...) + @test solve_succeeded(ores) + osol = battery_solution(ones_prob, ores) + @test abs(osol.pg[gpos, 2]) > 1e-6 + + # ── The schedule is DATA, not a differentiable path ─────────────────── + # It reaches the model through variable bounds only, so the trajectory + # derivative the trainer consumes is still exactly the derivative of the + # solved value — checked here against central differences on the case + # that carries the schedule. + λ = target_multipliers(sprob, sres) + @test length(λ) == T * nBat + @test all(isfinite, λ) + h = 1e-5 + for i in (1, nBat + 1) + xp = copy(xs); xp[i] += h + xm = copy(xs); xm[i] -= h + set_energy_path!(sprob, e0, xp) + vp = solve!(sprob; solver_kwargs...).objective + set_energy_path!(sprob, e0, xm) + vm_ = solve!(sprob; solver_kwargs...).objective + @test (vp - vm_) / (2h) ≈ λ[i] rtol = 1e-4 + end + end + + # ── The strict reachable policy ────────────────────────────────────────── + @testset "reachable policy" begin + Random.seed!(11) + prob = build_battery_exa(case, 4; backend = backend) + policy = to_device(battery_reachable_policy(case, [8]; + n_observation = prob.nBus, n_context = N_CONTEXT, + head_layers = [12])) + assert_device(policy, DEVICE) + @test_throws ArgumentError battery_reachable_policy(case, [8]; + n_observation = prob.nBus, activation = tanh) + + like = _policy_array(policy) + e0 = initial_energy(case) + e0d = _to_like(like, e0) + atoms = [1, 3, 2, 2] + features = rollout_features(case, prob.net, atoms; like = like) + + # The vectorized bounds agree with the shared case contract's scalar form. + lo, hi = reachable_bounds(policy, e0d, e0d) + for (k, b) in enumerate(bats) + l, u = reachable_interval(b, e0[k], Δt) + @test Float64(Array(lo)[k]) ≈ l atol = 1e-5 + @test Float64(Array(hi)[k]) ≈ u atol = 1e-5 + end + + # Every emitted target lies inside its own reachable interval. + x = Float64.(vec(Array(rollout_targets(policy, features, e0d)))) + prev = copy(e0) + for t in 1:4 + for (k, b) in enumerate(bats) + l, u = reachable_interval(b, prev[k], Δt) + @test l - 1e-5 <= x[(t - 1) * nBat + k] <= u + 1e-5 + end + prev = x[((t - 1) * nBat + 1):(t * nBat)] + end + + # The recurrent state really advances, and `reset!` really resets it. + Flux.reset!(policy) + s0 = deepcopy(policy.state) + policy(vcat(features[:, 1], e0d)) + @test !isapprox(Float64.(vec(Array(policy.state[1][1]))), + Float64.(vec(Array(s0[1][1]))); atol = 1e-12) + Flux.reset!(policy) + @test Float64.(vec(Array(policy.state[1][1]))) ≈ Float64.(vec(Array(s0[1][1]))) + + # A repeated rollout of the SAME scenario reproduces itself exactly, + # which is only true if the boundary reset actually happens. + x2 = Float64.(vec(Array(rollout_targets(policy, features, e0d)))) + @test x2 == x + # A DIFFERENT scenario must produce a different trajectory — otherwise + # the encoder is memoryless and the policy is not reading the demand. + alt = rollout_features(case, prob.net, [3, 1, 1, 3]; like = like) + @test !isapprox(Float64.(vec(Array(rollout_targets(policy, alt, e0d)))), x; atol = 1e-8) + + # The gradient flows through the reachable bounds. Holding the head + # output fixed, the target still moves with the incoming energy, so a + # derivative taken with the bounds detached is strictly smaller. + λ = _to_like(like, ones(4 * nBat)) + _, g_full = actor_gradient(policy, features, λ, e0d) + gvec = Float64[] + Flux.fmap(x -> (x isa AbstractArray && append!(gvec, Float64.(vec(Array(x)))); x), g_full) + @test any(!iszero, gvec) + @test all(isfinite, gvec) + end + + # ── One shared ACP bound relaxation, stated not inherited ─────────────── + @testset "ACP bound-relaxation parity" begin + @test ACP_BOUND_RELAX_FACTOR == 1e-8 + @test haskey(DEFAULT_SOLVER_OPTIONS, :bound_relax_factor) + @test DEFAULT_SOLVER_OPTIONS.bound_relax_factor === ACP_BOUND_RELAX_FACTOR + # Zero is what broke CUDSS; it must never be reintroduced silently. + @test DEFAULT_SOLVER_OPTIONS.bound_relax_factor > 0 + # The constant arrives from the byte-identical shared contract file, so + # the two engines cannot drift apart on it. + @test occursin("ACP_BOUND_RELAX_FACTOR", + read(joinpath(EXAMPLE, "battery_solution_schema.jl"), String)) + end + + # ── Which protocol a policy may be SELECTED on ────────────────────────── + # + # The final protocol exists to be fresh. A trainer that scored checkpoints on + # it would destroy that property silently — the columns solve, the costs are + # finite, and the printed panel looks exactly like a screening panel. An + # earlier revision of the trainer did precisely this, because + # `manifest["protocol"]` IS the final protocol and `manifest["screening"]` is + # the screening one. + @testset "selection protocol" begin + # The correctness fixture declares one protocol and no split at all. + @test get(case.manifest, "screening", nothing) === nothing + msole, ksole = evaluation_protocol(case) + @test ksole === :sole + @test msole == scenario_index_matrix(case.demand, + Int(case.manifest["protocol"]["num_stages"]), + Int(case.manifest["protocol"]["num_scenarios"])) + + # A case that DOES declare a screening protocol must be evaluated on it, + # and the panel it produces must share no scenario with the final one. + # The stage count matches the final protocol's, as it does on every panel + # case, because the exclusion set is that protocol's columns. + pstages = Int(case.manifest["protocol"]["num_stages"]) + sseed, sscen = 424242, 6 + ex = protocol_columns(scenario_index_matrix(case.demand, pstages, + Int(case.manifest["protocol"]["num_scenarios"]))) + function with_screening(sha) + man = deepcopy(case.manifest) + man["screening"] = Dict{String,Any}("seed" => sseed, "num_stages" => pstages, + "num_scenarios" => sscen, + "excludes" => "protocol", "sha256" => sha) + return BatteryCase(case.dir, case.name, case.network, case.batteries, + case.recourse, case.demand, man) + end + good = protocol_digest(case.demand, pstages, sscen; seed = sseed, exclude = ex) + mscr, kscr = evaluation_protocol(with_screening(good)) + @test kscr === :screening + @test mscr == scenario_index_matrix(case.demand, pstages, sscen; + seed = sseed, exclude = ex) + @test mscr != msole[1:pstages, 1:sscen] + # Disjoint by construction, not by luck. + @test isempty(intersect(Set(protocol_columns(mscr)), Set(ex))) + # A screening record whose digest does not regenerate is refused, so a + # tampered or stale manifest cannot quietly select a different panel. + @test_throws ErrorException evaluation_protocol(with_screening(repeat("0", 64))) + + # ── The panel mean is the CORRECTED cost, not the raw objective ───── + # This engine parks the two nodal recourse injections a bound-relaxation + # BELOW zero. At the case's recourse price that is a visible negative + # penalty in the raw objective, and a selection metric carrying it would + # rank checkpoints partly on the solver's barrier parameter. The panel + # therefore goes through `physical_stage_cost`, exactly as every reported + # cost in the study does. + pprob = build_battery_exa(case, 3; backend = backend) + ppol = to_device(battery_reachable_policy(case, [6]; n_observation = pprob.nBus, + n_context = N_CONTEXT, head_layers = [6])) + ev = evaluate_panel(ppol, pprob, case, [1]; solver_kwargs = solver_kwargs) + @test ev.complete + # A raw "worst recourse" could be NEGATIVE and pass a positive tolerance + # for the wrong reason; the contract's is an absolute value. + @test ev.worst_recourse >= 0 + @test ev.worst_recourse < PHYSICAL_RECOURSE_TOL + # Recompute the same column's RAW total, and its generation-plus- + # throughput. With no recourse used, the corrected cost is exactly the + # latter — and the raw objective is neither. + matrix, _ = evaluation_protocol(case) + atoms = matrix[1:3, 1] + lk = _policy_array(ppol) + tg = rollout_targets(ppol, rollout_features(case, pprob.net, atoms; like = lk), + _to_like(lk, initial_energy(case))) + _, psol, _ = strict_solve!(pprob, case, atoms, tg; solver_kwargs = solver_kwargs) + pc = stage_costs(pprob, psol) + @test ev.mean_cost ≈ sum(pc.generation) + sum(pc.throughput) atol = 1e-9 + @test ev.mean_cost != sum(pc.total) + @test abs(sum(pc.total) - ev.mean_cost) ≈ abs(sum(pc.deficit) + sum(pc.surplus)) atol = 1e-9 + + # The trainer resolves it once, reports it, and records it in the + # checkpoint — so which panel selected a policy is on the artifact. + ck = joinpath(mktempdir(), "prot.jld2") + out = train_strict(; case_dir = CASE_DIR, num_stages = 3, epochs = 1, batches = 1, + trajectories = 1, encoder_layers = [6], head_layers = [6], + eval_every = 1, eval_columns = [1], device = DEVICE, + checkpoint = ck, verbose = false) + @test out.protocol === :sole + @test isfile(ck) + @test JLD2.load(ck)["meta"]["panel_protocol"] == "sole" + end + + # ── The recurrent linear decision rule (TSLDR) ─────────────────────────── + # + # What is being protected here is a NAME. "Time-series linear decision rule" + # is a claim about a function class, and a recurrent network that quietly + # kept one gate, one squashing output or one read of the incoming energy + # would train, reduce loss, and be reported under a name that is false. Each + # group below closes one way that could happen, and each is stated about the + # RAW target — the object the claim is about — rather than about the emitted + # target, which is deliberately a nonlinear (bounded, state-dependent) + # function of it. + @testset "recurrent linear TSLDR" begin + Random.seed!(4711) + T = 4 + prob = build_battery_exa(case, T; backend = backend) + mkpolicy(; enc = [6], head = [5], arch = :tsldr_recurrent_linear) = + to_device(battery_reachable_policy(case, enc; n_observation = prob.nBus, + n_context = N_CONTEXT, head_layers = head, architecture = arch)) + policy = mkpolicy() + assert_device(policy, DEVICE) + like = _policy_array(policy) + e0 = initial_energy(case) + e0d = _to_like(like, e0) + features = rollout_features(case, prob.net, [1, 3, 2, 2]; like = like) + + # ── What the constructor refuses ───────────────────────────────────── + @test_throws ArgumentError battery_reachable_policy(case, [6]; + n_observation = prob.nBus, architecture = :tsldr_linear) + # A recurrent layer that is not the architecture's own affine one cannot + # be smuggled in under the linear name. + @test_throws ArgumentError battery_reachable_policy(case, [6]; + n_observation = prob.nBus, encoder_type = Flux.GRU, + architecture = :tsldr_recurrent_linear) + # Neither can a different squashing: it belongs to the feasibility layer. + @test_throws ArgumentError battery_reachable_policy(case, [6]; + n_observation = prob.nBus, activation = NNlib.sigmoid, + architecture = :tsldr_recurrent_linear) + + # ── Activation audit ───────────────────────────────────────────────── + # Every function-valued field in the trainable tree is the identity, AND + # every encoder cell is an `RNNCell` — the second half is the decisive + # one, because an `LSTMCell` writes its sigmoid gates and its tanh into + # the forward pass and carries no activation field to be caught by the + # first. + @test !isempty(policy_activations(policy)) + @test all(f -> f === identity, policy_activations(policy)) + cells = policy_recurrent_cells(policy) + @test !isempty(cells) + @test all(c -> c isa Flux.RNNCell, cells) + @test all(c -> c.σ === identity, cells) + # The head is affine end to end: every layer of it is a `Dense` whose + # activation is the identity, output layer included. + heads = policy.combiner isa Flux.Chain ? collect(policy.combiner.layers) : [policy.combiner] + @test all(l -> l isa Flux.Dense && l.σ === identity, heads) + # The null control: the nonlinear architecture must FAIL this audit, or + # the audit is not measuring anything. + @test any(c -> !(c isa Flux.RNNCell), policy_recurrent_cells(mkpolicy(arch = :tsddr_nonlinear))) + @test any(f -> f !== identity, policy_activations(mkpolicy(arch = :tsddr_nonlinear))) + + # ── The raw map is the one the emitted target is built from ───────── + # Every gate below is stated about `rollout_raw_targets`. That is only + # evidence about the POLICY if the emitted target really is the + # feasibility layer applied to those raw values — otherwise the gates + # could keep passing on a map the rollout no longer uses. Feeding the + # raw targets through the shared layer, threading the state exactly as + # the rollout threads it, must reproduce the rollout to the last bit. + rawz = Array(rollout_raw_targets(policy, features)) + emitted = Float64.(vec(Array(rollout_targets(policy, features, e0d)))) + rebuilt = Float64[] + prev = e0d + for t in 1:T + ê = feasible_target(policy, _to_like(like, Float64.(rawz[:, t])), prev) + append!(rebuilt, Float64.(vec(Array(ê)))) + prev = ê + end + @test rebuilt == emitted + + # ── Causality: a future atom cannot move an earlier raw target ─────── + noise = _to_like(like, randn(MersenneTwister(2), size(features, 1) * (T - 2))) + alt = hcat(features[:, 1:2], reshape(noise, size(features, 1), T - 2)) + z0 = Array(rollout_raw_targets(policy, features)) + z1 = Array(rollout_raw_targets(policy, alt)) + @test z0[:, 1:2] == z1[:, 1:2] # EXACTLY, not approximately + @test !isapprox(z0[:, 3:T], z1[:, 3:T]; atol = 1e-8) + + # ── History: an EARLIER atom does move a later raw target ──────────── + # Separately, one stage at a time, so a single test cannot pass because + # some other stage happened to carry the difference. + for k in 1:(T - 1) + bumped = copy(features) + bumped[:, k] .+= one(eltype(features)) + zb = Array(rollout_raw_targets(policy, bumped)) + @test !isapprox(zb[:, T], z0[:, T]; atol = 1e-6) + end + + # ── Ordering: the rule reads a SEQUENCE, not a bag ────────────────── + # Swapping two stages' observations, which leaves the multiset of + # observations untouched, must move a later raw target. A map that + # summed the history would pass every test above and fail this one. + swapped = hcat(features[:, 2], features[:, 1], features[:, 3:T]) + @test !isapprox(Array(rollout_raw_targets(policy, swapped))[:, T], + z0[:, T]; atol = 1e-6) + + # ── Stage dependence is explicit, through the stage representation ── + # Perturbing ONLY the deterministic clock rows — leaving every demand + # row exactly as it was — must move the raw target, or the architecture + # has quietly stopped reading the stage it is at. + clocked = copy(features) + clocked[1:N_CONTEXT, :] .+= one(eltype(features)) + @test !isapprox(Array(rollout_raw_targets(policy, clocked)), z0; atol = 1e-6) + + # ── Affinity of the raw map, in Float64 ────────────────────────────── + # f(αx + (1−α)y) = αf(x) + (1−α)f(y) on arbitrary inputs, which is the + # definition of affine and is checked at the precision the claim is made + # at rather than at the trainer's working precision. + # + # This block and the two after it are host-Float64 MATH gates: they + # difference a map against its own closed form, which needs the + # precision and not the device. The device path is exercised by the + # rollout, gradient and training blocks around them. + p64 = Flux.f64(battery_reachable_policy(case, [6]; n_observation = prob.nBus, + n_context = N_CONTEXT, head_layers = [5], + architecture = :tsldr_recurrent_linear)) + A = randn(MersenneTwister(3), Float64, size(features)) + B = randn(MersenneTwister(4), Float64, size(features)) + α = 0.37 + fA = Array(rollout_raw_targets(p64, A)) + fB = Array(rollout_raw_targets(p64, B)) + fM = Array(rollout_raw_targets(p64, α .* A .+ (1 - α) .* B)) + @test maximum(abs.(fM .- (α .* fA .+ (1 - α) .* fB))) < 1e-12 + # The null control again: the nonlinear head is NOT affine, so the same + # identity must fail for it. It reads the incoming energy, so the + # comparison is made on the emitted target it does produce. + pnl = Flux.f64(battery_reachable_policy(case, [6]; n_observation = prob.nBus, + n_context = N_CONTEXT, head_layers = [5])) + z64 = _to_like(Float64[0.0], initial_energy(case)) + gA = Float64.(vec(Array(rollout_targets(pnl, A, z64)))) + gB = Float64.(vec(Array(rollout_targets(pnl, B, z64)))) + gM = Float64.(vec(Array(rollout_targets(pnl, α .* A .+ (1 - α) .* B, z64)))) + @test maximum(abs.(gM .- (α .* gA .+ (1 - α) .* gB))) > 1e-6 + + # ── Explicit unrolling of the small recurrence ─────────────────────── + # h_t = A h_{t-1} + B ξ_t + b and z_t = C h_t + D ξ_t + d, written out + # from the weight matrices by hand and compared against the + # implementation. A single-layer encoder and a bare head, so the formula + # is the one the documentation states, with nothing composed away. + Random.seed!(1234) + plain = Flux.f64(battery_reachable_policy(case, [5]; + n_observation = prob.nBus, n_context = N_CONTEXT, + head_layers = Int[], architecture = :tsldr_recurrent_linear)) + cell = policy_recurrent_cells(plain)[1] + Bm, Am, bv = Array(cell.Wi), Array(cell.Wh), Array(cell.bias) + Wc, dv = Array(plain.combiner.weight), Array(plain.combiner.bias) + width = size(Am, 1) + Cm, Dm = Wc[:, 1:width], Wc[:, (width + 1):end] + Ξ = Array(rollout_features(case, prob.net, [2, 1, 3, 1]; like = Float64[0.0])) + h = zeros(Float64, width) + manual = similar(Ξ, size(Cm, 1), T) + for t in 1:T + h = Am * h + Bm * Ξ[:, t] + bv # the affine recurrent update + manual[:, t] = Cm * h + Dm * Ξ[:, t] + dv + end + @test Array(rollout_raw_targets(plain, Ξ)) ≈ manual atol = 1e-12 + # And the closed form of the same thing: z_t as a sum over the history. + closed = similar(manual) + for t in 1:T + acc = zeros(Float64, width) + for k in 1:t + acc .+= Am^(t - k) * (Bm * Ξ[:, k] + bv) + end + closed[:, t] = Cm * acc + Dm * Ξ[:, t] + dv + end + @test closed ≈ manual atol = 1e-12 + + # ── Targets stay reachable over the full T = 24 horizon ───────────── + prob24 = build_battery_exa(case, 24; backend = backend) + p24 = to_device(battery_reachable_policy(case, [8]; n_observation = prob24.nBus, + n_context = N_CONTEXT, head_layers = [10], + architecture = :tsldr_recurrent_linear)) + like24 = _policy_array(p24) + f24 = rollout_features(case, prob24.net, + [1 + (t % num_atoms(case.demand, t)) for t in 1:24]; like = like24) + x24 = Float64.(vec(Array(rollout_targets(p24, f24, _to_like(like24, e0))))) + prev = copy(e0) + for t in 1:24 + for (k, b) in enumerate(bats) + l, u = reachable_interval(b, prev[k], Δt) + @test l - 1e-5 <= x24[(t - 1) * nBat + k] <= u + 1e-5 + end + prev = x24[((t - 1) * nBat + 1):(t * nBat)] + end + + # ── The actor gradient against centered finite differences ────────── + # Directional, in Float64, at T = 4 and T = 24, with NO relaxed + # tolerance: the surrogate ⟨λ, ê(θ)⟩ is smooth here, and the distance to + # the nearest kink of the feasibility layer is measured first so that + # "smooth here" is established rather than assumed. + for (Th, pr) in ((4, prob), (24, prob24)) + Random.seed!(2026) + pg = Flux.f64(battery_reachable_policy(case, [6]; n_observation = pr.nBus, + n_context = N_CONTEXT, head_layers = [8], + architecture = :tsldr_recurrent_linear)) + lk = Float64[0.0] + e0g = _to_like(lk, e0) + fg = rollout_features(case, pr.net, + [1 + (t % num_atoms(case.demand, t)) for t in 1:Th]; like = lk) + λ = _to_like(lk, randn(MersenneTwister(5), Th * nBat)) + + # Distance to the nearest branch switch of `max`/`min` in the + # reachable bounds, along the trajectory actually taken. + xs = Float64.(vec(Array(rollout_targets(pg, fg, e0g)))) + prev = copy(e0); kink = Inf + for t in 1:Th + for (k, b) in enumerate(bats) + dec = b.self_discharge * prev[k] + kink = min(kink, + abs(b.energy_min - (dec - Δt * b.discharge_max / b.discharge_efficiency)), + abs(b.energy_max - (dec + b.charge_efficiency * Δt * b.charge_max))) + end + prev = xs[((t - 1) * nBat + 1):(t * nBat)] + end + @test kink > 1e-5 + + _, g = actor_gradient(pg, fg, λ, e0g) + gv = Float64[] + Flux.fmap(x -> (x isa AbstractArray && append!(gv, Float64.(vec(Array(x)))); x), g) + dir = randn(MersenneTwister(11), length(gv)); dir ./= norm(dir) + ad = dot(gv, dir) + bump(h) = begin + q = deepcopy(pg); i = Ref(0) + shift(x) = x isa AbstractArray ? + (a = copy(x); for j in eachindex(a); i[] += 1; a[j] += h * dir[i[]]; end; a) : x + q.encoder = Flux.fmap(shift, q.encoder) + q.combiner = Flux.fmap(shift, q.combiner) + sum(λ .* rollout_targets(q, fg, e0g)) + end + h = 1e-5 + fd = (bump(h) - bump(-h)) / (2h) + @test isapprox(fd, ad; rtol = 1e-7) + end + + # ── Save and reload preserves architecture, parameters, optimizer + # state and the emitted trajectory ───────────────────────────────── + keep = mkpolicy() + opt = Optimisers.setup(Optimisers.Adam(1e-3), keep) + # Take one real step so the moment estimates are not their initial value, + # or "the optimizer state survived" would be true of a fresh setup too. + _, g1 = actor_gradient(keep, features, _to_like(like, ones(T * nBat)), e0d) + opt, keep = Optimisers.update!(opt, keep, g1) + traj = Float64.(vec(Array(rollout_targets(keep, features, e0d)))) + moments = Float64[] + Flux.fmap(x -> (x isa AbstractArray && append!(moments, Float64.(vec(Array(x)))); x), opt) + + cpath = joinpath(mktempdir(), "tsldr.jld2") + save_checkpoint(cpath, keep, Dict( + "case" => case.name, + "network_sha256" => case.manifest["artifacts"]["network.json"]); + opt_state = opt, history = [(step = 1, loss = 1.5)]) + + back = mkpolicy() + got = load_checkpoint!(back, cpath; case = case) + @test got.meta["architecture"] == "tsldr_recurrent_linear" + @test Float64.(vec(Array(rollout_targets(back, features, e0d)))) == traj + rmoments = Float64[] + Flux.fmap(x -> (x isa AbstractArray && append!(rmoments, Float64.(vec(Array(x)))); x), got.opt_state) + @test rmoments == moments + @test got.history == [(step = 1, loss = 1.5)] + + # A nonlinear checkpoint may not be loaded into a linear policy, and the + # refusal is by NAME — before any array is touched, so it does not + # depend on two encoders happening to have incompatible weight shapes. + npath = joinpath(mktempdir(), "nl.jld2") + save_checkpoint(npath, mkpolicy(arch = :tsddr_nonlinear), Dict( + "case" => case.name, + "network_sha256" => case.manifest["artifacts"]["network.json"])) + @test_throws ErrorException load_checkpoint!(back, npath; case = case) + @test_throws ErrorException load_checkpoint!(mkpolicy(arch = :tsddr_nonlinear), + cpath; case = case) + + # ── Training runs the linear architecture through the same path ───── + out = train_strict(; case_dir = CASE_DIR, architecture = :tsldr_recurrent_linear, + num_stages = 4, epochs = 1, batches = 2, trajectories = 1, + encoder_layers = [8], head_layers = [12], + eval_every = 2, eval_columns = [1, 2], device = DEVICE, + checkpoint = joinpath(mktempdir(), "tsldr_smoke.jld2"), + verbose = false) + @test out.architecture === :tsldr_recurrent_linear + @test out.updates == 2 + @test all(isfinite(h.loss) for h in out.history) + @test isfinite(out.best.cost) + @test isfile(out.checkpoint) + @test out.policy.architecture === :tsldr_recurrent_linear + end + + # ── The four method identifiers ───────────────────────────────────────── + @testset "method identifiers" begin + @test sort!(collect(keys(BATTERY_METHODS))) == + [:sddp_dc, :sddp_soc, :tsddr_nonlinear, :tsldr_recurrent_linear] + for id in keys(BATTERY_METHODS) + m = battery_method(id) + @test m.id === id + # The invariants are what make the four comparable, so every row + # carries them and every row carries the SAME ones. + @test m.horizon == 24 + @test m.protocol == "screening" + @test m.stage_semantics == BATTERY_METHOD_INVARIANTS.stage_semantics + @test m.recourse == BATTERY_METHOD_INVARIANTS.recourse + @test m.cost_contract == BATTERY_METHOD_INVARIANTS.cost_contract + @test m.comparison == BATTERY_METHOD_INVARIANTS.comparison + end + @test battery_method(:tsddr_nonlinear).engine === :exa + @test battery_method(:tsldr_recurrent_linear).architecture === :tsldr_recurrent_linear + @test battery_method(:sddp_soc).backward === :soc + @test battery_method(:sddp_dc).backward === :dc + @test_throws ArgumentError battery_method(:tsldr) + # This engine refuses the two it does not own, by name and with the + # owning engine in the message, rather than failing deeper down. + @test_throws ErrorException run_battery_method(:sddp_soc) + @test_throws ErrorException run_battery_method(:sddp_dc) + # And it really does run the two it does own. + out = run_battery_method(:tsldr_recurrent_linear; case_dir = CASE_DIR, + num_stages = 3, epochs = 1, batches = 1, trajectories = 1, + encoder_layers = [6], head_layers = [6], eval_every = 0, + device = DEVICE, + checkpoint = joinpath(mktempdir(), "m.jld2"), verbose = false) + @test out.architecture === :tsldr_recurrent_linear && out.updates == 1 + end + + # ── Checkpoints ────────────────────────────────────────────────────────── + @testset "checkpoint round trip" begin + Random.seed!(3) + prob = build_battery_exa(case, 3; backend = backend) + policy = to_device(battery_reachable_policy(case, [6]; + n_observation = prob.nBus, n_context = N_CONTEXT, + head_layers = [8])) + like = _policy_array(policy) + e0d = _to_like(like, initial_energy(case)) + features = rollout_features(case, prob.net, [2, 1, 3]; like = like) + before = Float64.(vec(Array(rollout_targets(policy, features, e0d)))) + + path = joinpath(mktempdir(), "ckpt.jld2") + opt = Optimisers.setup(Optimisers.Adam(1e-3), policy) + save_checkpoint(path, policy, Dict( + "case" => case.name, + "network_sha256" => case.manifest["artifacts"]["network.json"]); + opt_state = opt, history = [(step = 1, loss = 2.0)]) + + fresh = to_device(battery_reachable_policy(case, [6]; + n_observation = prob.nBus, n_context = N_CONTEXT, + head_layers = [8])) + @test !isapprox(Float64.(vec(Array(rollout_targets(fresh, features, e0d)))), before; atol = 1e-8) + loaded = load_checkpoint!(fresh, path; case = case) + @test loaded.meta["case"] == case.name + @test loaded.meta["schema"] == BATTERY_CHECKPOINT_SCHEMA + # The architecture travels with the checkpoint, always. + @test loaded.meta["architecture"] == "tsddr_nonlinear" + # Exact reproduction, not merely close: the reload must be the policy. + @test Float64.(vec(Array(rollout_targets(fresh, features, e0d)))) == before + # The optimizer state and the trajectory came back too. + @test loaded.opt_state !== nothing + @test loaded.history == [(step = 1, loss = 2.0)] + + # A checkpoint from a different case is refused rather than mismatched. + bad = joinpath(mktempdir(), "bad.jld2") + save_checkpoint(bad, policy, Dict("case" => "other", "network_sha256" => "deadbeef")) + @test_throws ErrorException load_checkpoint!(fresh, bad; case = case) + + # A checkpoint written before the schema existed is refused rather than + # resumed with a fresh optimizer while reporting that it resumed. + stale = joinpath(mktempdir(), "stale.jld2") + JLD2.jldsave(stale; state = Flux.state(Flux.cpu(policy)), + meta = Dict("case" => case.name)) + @test_throws ErrorException load_checkpoint!(fresh, stale; case = case) + end + + # ── Training performs real updates ─────────────────────────────────────── + @testset "training smoke" begin + out = train_strict(; case_dir = CASE_DIR, num_stages = 4, epochs = 1, batches = 2, + trajectories = 1, encoder_layers = [8], head_layers = [12], + eval_every = 2, eval_columns = [1, 2], device = DEVICE, + checkpoint = joinpath(mktempdir(), "smoke.jld2"), verbose = false) + @test out.updates == 2 + @test length(out.history) == 2 + @test all(isfinite(h.loss) for h in out.history) + # The learning-rate schedule is a declared function of the step index. + @test out.history[1].lr > out.history[end].lr + # A complete panel evaluation selected a checkpoint. + @test isfinite(out.best.cost) + @test isfile(out.checkpoint) + end + + # ── The physical cost contract, on THIS engine's own solutions ────────── + # + # `physical_stage_cost` arrives with the byte-identical schema file, so the + # two engines do not merely follow the same recipe — they run the same code. + # What this checks is that MadNLP's own barrier artifact is removed by it: + # this engine parks the recourse variables a bound-relaxation BELOW zero, + # which at the case's recourse price is a visible negative penalty in the + # raw objective and must not reach a reported cost. + @testset "physical cost semantics" begin + prob = build_battery_exa(case, 2) + pd, qd = realized_demand(case, net, [1, 2], [1, 2]) + set_demand!(prob, pd, qd) + e0 = [b.energy_initial for b in bats] + xhat = Float64[] + e_prev = copy(e0) + for _ in 1:2 + nxt = similar(e_prev) + for (k, b) in enumerate(bats) + lo, hi = reachable_interval(b, e_prev[k], Δt) + nxt[k] = lo + 0.5 * (hi - lo) + end + append!(xhat, nxt); e_prev = nxt + end + set_energy_path!(prob, e0, xhat) + res = solve!(prob) + sol = battery_solution(prob, res) + cost = stage_costs(prob, sol) + bus_of = Dict(i => net.buses[i].id for i in eachindex(net.buses)) + + for t in 1:2 + s = (cost_generation = cost.generation[t], cost_throughput = cost.throughput[t], + deficit = Dict(bus_of[i] => sol.deficit[i, t] for i in eachindex(net.buses)), + surplus = Dict(bus_of[i] => sol.surplus[i, t] for i in eachindex(net.buses)), + objective = cost.total[t]) + c = physical_stage_cost(s, case.recourse) + # This stage uses no recourse, so the corrected cost is exactly the + # physical generation plus throughput — no barrier residue at all. + @test c.admissible + @test c.worst_recourse < PHYSICAL_RECOURSE_TOL + @test c.deficit == 0.0 + @test c.surplus == 0.0 + @test c.corrected ≈ cost.generation[t] + cost.throughput[t] + @test isfinite(c.correction) + end + end + + # ── The files the two engines must agree on byte for byte ─────────────── + # + # This package has no PGLib and no PowerModels dependency, so it cannot + # build a case and cannot construct the portfolio: it CONSUMES both. What it + # can check, and must, is that the copies it consumes them through have not + # drifted from the JuMP package's originals — a drifted `battery_case.jl` + # would let the two engines read one frozen case as two different problems + # while both reported success. + @testset "shared files and the portfolio manifest" begin + peer = get(ENV, "DR_BAT_PEER", + normpath(joinpath(EXAMPLE, "..", "..", "..", + "DecisionRules.jl", "examples", + "BatteryStorageOPF"))) + shared = ["battery_case.jl", "battery_solution_schema.jl"] + manifest = joinpath(EXAMPLE, "battery_portfolio.json") + if isdir(peer) + isfile(manifest) && push!(shared, "battery_portfolio.json") + for f in shared + @test isfile(joinpath(EXAMPLE, f)) + @test isfile(joinpath(peer, f)) + @test bytes2hex(SHA.sha256(read(joinpath(EXAMPLE, f)))) == + bytes2hex(SHA.sha256(read(joinpath(peer, f)))) + end + else + for f in shared + @test isfile(joinpath(EXAMPLE, f)) + end + end + + # The portfolio manifest is readable and self-consistent from THIS side + # too, with nothing but JSON and SHA — which is the whole point of + # keeping it a small, hash-checkable file rather than a case tree. + if isfile(manifest) + m = JSON.parsefile(manifest) + @test m["schema"] == "battery_storage_opf/portfolio/1" + @test m["seed"] == 20260814 + @test m["horizon"] == 24 + @test length(m["profile"]) == 24 + @test length(m["cases"]) >= 10 + # Recompute the manifest's self-digest: canonical JSON of everything + # but the digest field. `canonical_json` came in with + # `battery_case.jl`, which the byte-identity test above has already + # pinned to the JuMP package's copy. + body = Dict{String,Any}(k => v for (k, v) in m if k != "digest") + @test bytes2hex(SHA.sha256(canonical_json(plain(body)))) == m["digest"] + for c in m["cases"] + @test length(c["placement"]["buses"]) == c["counts"]["battery"] + @test length(c["regions"]["sizes"]) == 6 + @test c["protocols"]["screening"]["excludes"] == "final" + end + end + end +end diff --git a/examples/BatteryStorageOPF/train_battery_exa_strict.jl b/examples/BatteryStorageOPF/train_battery_exa_strict.jl new file mode 100644 index 0000000..5d9a396 --- /dev/null +++ b/examples/BatteryStorageOPF/train_battery_exa_strict.jl @@ -0,0 +1,1191 @@ +# train_battery_exa_strict.jl +# +# The single, fully parameterized strict TS-DDR training entry point for the +# battery study, plus the rollout and evaluation machinery it shares with the +# correctness gates. +# +# THE ACTOR GRADIENT, in one paragraph. +# The policy emits a strict, one-stage reachable target trajectory +# ``\hat e(\theta)``; the deterministic equivalent solves the true-ACP stage +# problems with the outgoing energy pinned to it, and returns the multipliers +# ``\lambda`` of the battery state transitions. By the envelope theorem the +# derivative of the solved value with respect to the trajectory is exactly +# ``\lambda``, so +# +# ∇_θ Q(w; \hat e(θ)) = Σ_t λ_t ∇_θ \hat e_t(θ), +# +# and the update is obtained by differentiating the surrogate ⟨λ, ê(θ)⟩ with λ +# HELD CONSTANT. The whole recurrent chain — encoder memory, head, and the +# reachable bounds' dependence on the previous target — is inside that +# differentiation. Nothing is detached. +# +# Usage +# julia --project=. -t auto train_battery_exa_strict.jl +# +# Environment (all optional): +# DR_BAT_CASE_DIR frozen case directory +# DR_BAT_ARCH tsddr_nonlinear | tsldr_recurrent_linear +# (default tsddr_nonlinear) +# DR_BAT_STAGES horizon T (default 24) +# DR_BAT_EPOCHS number of epochs (default 2) +# DR_BAT_BATCHES gradient steps per epoch (default 5) +# DR_BAT_TRAJ trajectories per gradient step (default 2) +# DR_BAT_LR initial learning rate (default 1e-3) +# DR_BAT_LR_FINAL final learning rate of the cosine ramp (default 1e-4) +# DR_BAT_ENCODER encoder widths, comma separated (default 64,64) +# DR_BAT_HEAD head widths, comma separated (default 128,128) +# DR_BAT_EVAL_EVERY gradient steps between panel evaluations (default 5) +# DR_BAT_EVAL_COLS protocol columns forming the panel (default 1,2,3,4) +# DR_BAT_SEED training seed (default 20260804) +# DR_BAT_DEVICE "cpu" or "gpu" (default cpu) +# DR_BAT_MAX_RECOURSE physical admissibility tolerance, pu (default 1e-6) +# DR_BAT_CHECKPOINT checkpoint path + +using Flux +using Zygote +using Optimisers +using JLD2 +using Random +using StableRNGs +using Statistics +using Printf +using LinearAlgebra +using DecisionRulesExa + +include(joinpath(@__DIR__, "battery_case.jl")) +include(joinpath(@__DIR__, "battery_solution_schema.jl")) +include(joinpath(@__DIR__, "battery_exa.jl")) +include(joinpath(@__DIR__, "battery_reachable_policy.jl")) + +# ───────────────────────────────────────────────────────────────────────────── +# Observation and context +# ───────────────────────────────────────────────────────────────────────────── + +""" + stage_context(case, t) -> Vector{Float64} + +Deterministic per-stage context the policy is allowed to see. + +# Notes +The pair ``(\\sin 2\\pi t/P, \\cos 2\\pi t/P)`` for the deterministic profile's +period ``P``, which the frozen support records. It encodes the position in the daily cycle without a discontinuity at +midnight, which a raw hour index would introduce. This is DETERMINISTIC +information — knowing the clock is not knowing the future demand — so it does +not violate nonanticipativity. +""" +function stage_context(case::BatteryCase, t::Integer) + P = profile_period(case.demand) + θ = 2π * (t - 1) / P + return [sin(θ), cos(θ)] +end + +"Width of the context block." +const N_CONTEXT = 2 + +""" + stage_observation(net, case, t, atom) -> Vector{Float64} + +The observation revealed at the beginning of stage `t`: the realized per-bus +ACTIVE demand (pu), indexed by bus position. + +# Notes +Reactive demand carries no extra information — every load is scaled by the same +multiplier on both sides, because the process preserves each load's power factor +— so feeding it would double the input width for nothing. +""" +function stage_observation(net::ExaNetwork, case::BatteryCase, t::Integer, atom::Integer) + pd, _ = realized_demand(case, net, [t], [atom]) + return vec(pd) +end + +# ───────────────────────────────────────────────────────────────────────────── +# Rollout +# ───────────────────────────────────────────────────────────────────────────── + +""" + rollout_features(case, net, atoms; stage_offset=0, like) -> AbstractMatrix + +Build the `(n_context + n_observation) × T` matrix of policy inputs that do NOT +depend on the policy: the deterministic context and the revealed demand. + +# Keywords +- `like::AbstractArray`: array supplying the element type and device the matrix + must land on. + +# Notes +These features are constants of the rollout. Building them OUTSIDE the +differentiated region matters for two reasons: it keeps the host-to-device copy +(a mutation, which automatic differentiation refuses to trace) off the tape, and +it makes explicit that nothing in the observation depends on the parameters. +""" +function rollout_features(case::BatteryCase, net::ExaNetwork, + atoms::AbstractVector{<:Integer}; + stage_offset::Integer = 0, + like::AbstractArray) + T = length(atoms) + cols = [vcat(stage_context(case, stage_offset + i), + stage_observation(net, case, stage_offset + i, atoms[i])) for i in 1:T] + host = reduce(hcat, cols) + device = similar(like, size(host)...) + copyto!(device, eltype(like).(host)) + return device +end + +""" + rollout_targets(policy, features, e0) -> AbstractVector + +Roll the policy forward over a scenario and return the flat, stage-major target +trajectory ``[\\hat e_1; \\ldots; \\hat e_T]``. + +# Arguments +- `policy::BatteryReachablePolicy`. +- `features::AbstractMatrix`: the per-stage inputs from + [`rollout_features`](@ref); column `i` is stage `i`. +- `e0::AbstractVector`: initial energy, in battery-position order. + +# Returns +- A vector of length `T·nBat`, differentiable in the policy parameters. + +# Notes +The recurrent state starts from `Flux.initialstates` — the scenario boundary — +and is threaded explicitly through [`policy_step`](@ref), and the emitted target +of stage `t` becomes the incoming energy of stage `t+1`. That feedback is what +makes this a genuinely multistage policy, and it is precisely the path along +which the reachable bounds' dependence on the incoming energy carries gradient. + +The trajectory is accumulated in a `Zygote.Buffer` so the loop stays type-stable +and still differentiable; a plain array write would be a mutation Zygote +refuses. +""" +function rollout_targets(policy::BatteryReachablePolicy, features::AbstractMatrix, + e0::AbstractVector) + T = size(features, 2) + nBat = policy.n_battery + state = DecisionRulesExa._init_recurrent_state(policy.encoder) + e_prev = e0 + buf = Zygote.Buffer(similar(e0, T * nBat)) + for i in 1:T + target, state = policy_step(policy, state, vcat(features[:, i], e_prev)) + buf[((i - 1) * nBat + 1):(i * nBat)] = target + e_prev = target + end + return copy(buf) +end + +""" + rollout_raw_targets(policy, features) -> Matrix + +Roll the LINEAR decision rule forward over a scenario and return its RAW +targets, before the feasibility layer: column `t` is ``z_t``. + +# Arguments +- `policy::BatteryReachablePolicy`: must be `:tsldr_recurrent_linear`. +- `features::AbstractMatrix`: the per-stage inputs from + [`rollout_features`](@ref); column `t` is ``\\xi_t``. + +# Notes +No incoming energy is threaded through this rollout, and that is the whole +point: the raw target of the linear rule is a function of the observed demand +history ALONE, so the map this returns is the affine causal map +``(\\xi_1,\\ldots,\\xi_T) \\mapsto (z_1,\\ldots,z_T)`` that the causality, +history, affinity and unrolling gates are stated about. The emitted targets — +which do depend on the state, through the reachable interval — come from +[`rollout_targets`](@ref) as they do for either architecture. + +Accumulated in a `Zygote.Buffer` for the same reason as the target rollout, so +that the raw map is differentiable too and a gate may difference it directly. +""" +function rollout_raw_targets(policy::BatteryReachablePolicy, features::AbstractMatrix) + T = size(features, 2) + nBat = policy.n_battery + state = DecisionRulesExa._init_recurrent_state(policy.encoder) + buf = Zygote.Buffer(similar(features, nBat, T)) + for i in 1:T + z, state = raw_target_step(policy, state, features[:, i]) + buf[:, i] = z + end + return copy(buf) +end + +""" + initial_energy(case) -> Vector{Float64} + +The frozen initial energy of every battery, in battery-position order. +""" +initial_energy(case::BatteryCase) = + Float64[b.energy_initial for b in sort(collect(case.batteries); by = b -> b.index)] + +# ───────────────────────────────────────────────────────────────────────────── +# One solve of the strict deterministic equivalent +# ───────────────────────────────────────────────────────────────────────────── + +""" + strict_solve!(prob, case, atoms, targets; stage_offset=0, solver_kwargs=NamedTuple()) + -> (result, solution, λ) + +Impose one scenario and one target trajectory on the deterministic equivalent, +solve it, and return the solution together with the actor signal. + +# Notes +`λ` is [`target_multipliers`](@ref)'s output: ``\\partial Q/\\partial \\hat e``, +already carrying the ``\\alpha`` correction that links consecutive transition +rows. + +The scenario and the targets are written into the model's PARAMETERS, so the +model itself — its sparsity pattern, its derivative kernels — is built once and +reused for the whole run; only the solver instance is fresh, for the reason +documented on [`solve!`](@ref). +""" +function strict_solve!(prob::BatteryExaProblem, case::BatteryCase, + atoms::AbstractVector{<:Integer}, targets::AbstractVector; + stage_offset::Integer = 0, + solver_kwargs = NamedTuple()) + stages = collect((stage_offset + 1):(stage_offset + prob.horizon)) + # Demand is a parameter and may be re-imposed for any window; per-stage + # generator availability is in the bounds and may not. See + # [`assert_stage_window`](@ref) — a case with no schedule accepts every offset. + assert_stage_window(prob, stages) + pd, qd = realized_demand(case, prob.net, stages, collect(atoms)) + set_demand!(prob, pd, qd) + set_energy_path!(prob, initial_energy(case), Float64.(vec(Array(targets)))) + result = solve!(prob; solver_kwargs...) + return result, battery_solution(prob, result), target_multipliers(prob, result) +end + +# ───────────────────────────────────────────────────────────────────────────── +# Evaluation +# ───────────────────────────────────────────────────────────────────────────── + +# `evaluation_protocol(case)` — which panel a policy may be SELECTED on — now +# lives in `battery_case.jl`, the file both engines carry byte-identically. It +# is a property of the frozen CASE and not of this trainer, and the JuMP engine +# needs exactly the same answer; keeping one copy is what makes "both engines +# selected on the same protocol" a fact rather than two implementations that +# agree today. + +""" + evaluate_panel(policy, prob, case, columns; max_recourse, solver_kwargs) + -> NamedTuple + +Evaluate the policy on a fixed panel of paired SCREENING-protocol columns. + +# Returns +`(mean_cost, costs, worst_recourse, complete, protocol)`. + +# Notes +The panel is FIXED and comes from [`evaluation_protocol`](@ref), so its columns +mean the same demand paths for every checkpoint and for the SDDP baseline. +Checkpoint selection uses this panel and nothing else — never the training loss, +whose sample size changes between phases, and never the final paired protocol, +which is evaluated once after selection. + +An evaluation is COMPLETE only if every column solved, every stage of every +column was ADMISSIBLE under the shared cost contract, and the worst physical +recourse on every column is within `max_recourse`. An incomplete evaluation is +invalid: averaging the columns that happened to succeed would report a policy +that does not exist. + +**The reported cost is the CORRECTED one.** Each stage goes through +`physical_stage_cost`, the byte-identical contract both engines carry, which +projects every recourse element within `PHYSICAL_RECOURSE_TOL` of zero to exactly +zero and marks the stage inadmissible when an element is outside it. This engine +parks the two nodal recourse injections a bound-relaxation BELOW zero; at a +recourse price of 1e5–1e6 per pu, summed over a couple of thousand buses, the raw +objective carries tens of cost units of pure barrier residue on a stage where no +recourse was used at all. That residue is a property of the solver, not of the +policy, and the contract exists so it never reaches a selection metric — which is +what a screening-panel mean is. +""" +function evaluate_panel(policy::BatteryReachablePolicy, prob::BatteryExaProblem, + case::BatteryCase, columns::AbstractVector{<:Integer}; + max_recourse::Real = 1e-6, solver_kwargs = NamedTuple()) + matrix, kind = evaluation_protocol(case) + size(matrix, 1) >= prob.horizon || + error("the $kind protocol covers $(size(matrix, 1)) stages but the policy has $(prob.horizon)") + maximum(columns) <= size(matrix, 2) || + error("column $(maximum(columns)) is outside the $kind protocol's $(size(matrix, 2)) columns") + e0 = initial_energy(case) + costs = Float64[] + worst = 0.0 + complete = true + like = _policy_array(policy) + bus_id = [b.id for b in prob.net.buses] + for c in columns + atoms = matrix[1:prob.horizon, c] + features = rollout_features(case, prob.net, atoms; like = like) + targets = rollout_targets(policy, features, _to_like(like, e0)) + result, sol, _ = strict_solve!(prob, case, atoms, targets; + solver_kwargs = solver_kwargs) + if !solve_succeeded(result) + complete = false + continue + end + stage = stage_costs(prob, sol) + corrected = 0.0 + admissible = true + for t in 1:prob.horizon + c_t = physical_stage_cost( + (cost_generation = stage.generation[t], cost_throughput = stage.throughput[t], + deficit = Dict(bus_id[i] => sol.deficit[i, t] for i in eachindex(bus_id)), + surplus = Dict(bus_id[i] => sol.surplus[i, t] for i in eachindex(bus_id)), + objective = stage.total[t]), case.recourse) + corrected += c_t.corrected + admissible &= c_t.admissible + worst = max(worst, c_t.worst_recourse) + end + admissible || (complete = false) + push!(costs, corrected) + end + complete &= (length(costs) == length(columns)) && (worst <= max_recourse) + return (mean_cost = isempty(costs) ? NaN : mean(costs), costs = costs, + worst_recourse = worst, complete = complete, protocol = kind) +end + +# ───────────────────────────────────────────────────────────────────────────── +# Training +# ───────────────────────────────────────────────────────────────────────────── + +""" + actor_gradient(policy, features, λ, e0) -> (value, gradient) + +Differentiate the surrogate ``\\langle \\lambda, \\hat e(\\theta)\\rangle`` +through the complete recurrent reachable policy. + +# Returns +- `value`: the surrogate's value. +- `gradient`: the gradient tree with respect to the policy's parameters. + +# Notes +`λ` enters as a CONSTANT: it is the envelope-theorem derivative of the solved +stage value, already evaluated at this trajectory, so differentiating it again +would double-count the stage problem's response. + +Everything else IS differentiated: the encoder's recurrent chain, the head, the +affine map into the reachable interval, and — critically — the interval's own +dependence on the incoming energy, which is the previous stage's target. +""" +function actor_gradient(policy::BatteryReachablePolicy, features::AbstractMatrix, + λ::AbstractVector, e0::AbstractVector) + out = Flux.withgradient(policy) do m + sum(λ .* rollout_targets(m, features, e0)) + end + return out.val, out.grad[1] +end + +""" + sample_atoms(rng, case, T) -> Vector{Int} + +Draw one training scenario: `T` independent atom indices, each from its own +stage's frozen support. +""" +function sample_atoms(rng, case::BatteryCase, T::Integer) + # Per STAGE: the frozen support is stage-dependent in general, so one shared + # probability vector would sample the wrong distribution on any case whose + # late stages carry a different support. + return [begin + p = cumsum(atom_probabilities(case.demand, t)) + searchsortedfirst(p, rand(rng)) + end for t in 1:T] +end + +""" + cosine_lr(step, total, lr0, lr1) -> Float64 + +Cosine ramp from `lr0` to `lr1` over `total` steps. + +# Notes +Declared as a function of the step index rather than carried as optimizer state, +so a run that is interrupted and resumed follows the same schedule it would have +followed uninterrupted. +""" +function cosine_lr(step::Integer, total::Integer, lr0::Real, lr1::Real) + total <= 1 && return Float64(lr1) + x = clamp((step - 1) / (total - 1), 0.0, 1.0) + return lr1 + 0.5 * (lr0 - lr1) * (1 + cos(π * x)) +end + +""" +Schema tag every checkpoint this file writes carries, and every checkpoint it +loads must carry. + +# Notes +Bumped from the unversioned Phase-A format when the policy gained an +`architecture` and the checkpoint gained the optimizer state and the training +trajectory. A checkpoint written before that has neither, and loading one would +resume a run with a fresh Adam moment estimate while reporting that it had +resumed — so it is refused by tag rather than adapted. +""" +const BATTERY_CHECKPOINT_SCHEMA = "battery_storage_opf/checkpoint/3" + +""" + save_checkpoint(path, policy, meta; opt_state=nothing, history=nothing) + +Write the policy's trainable state, its architecture, its optimizer state, its +training trajectory and its metadata to `path`. + +# Notes +Reachability metadata is deliberately NOT what a checkpoint restores: it belongs +to the frozen case, and a checkpoint that could override a battery rating would +let a stale file silently redefine the problem it was trained on. The case's +manifest hash and the ARCHITECTURE are recorded instead, so a reload against a +different case, or into a different architecture, FAILS rather than quietly +mismatching. + +The optimizer state and the trajectory are written because a checkpoint that +restores only the parameters does not restore the RUN: Adam's moment estimates +are as much of the optimizer's position as the weights are, and a resumed stage +that silently restarts them takes a different first step than an uninterrupted +one would have. Both are moved to the host before writing, so a checkpoint taken +on a GPU reloads on a CPU. +""" +function save_checkpoint(path::AbstractString, policy::BatteryReachablePolicy, meta::AbstractDict; + opt_state = nothing, history = nothing) + mkpath(dirname(abspath(path))) + record = Dict{String,Any}(meta) + record["schema"] = BATTERY_CHECKPOINT_SCHEMA + record["architecture"] = String(policy.architecture) + JLD2.jldsave(path; + state = Flux.state(Flux.cpu(policy)), + opt_state = opt_state === nothing ? nothing : Flux.cpu(opt_state), + history = history === nothing ? nothing : collect(history), + meta = record) + return path +end + +""" + load_checkpoint!(policy, path; case=nothing) -> NamedTuple + +Load a checkpoint into `policy`, verifying it belongs to the case in hand AND to +the architecture in hand. + +# Returns +`(meta, opt_state, history)`. `opt_state` and `history` are `nothing` when the +checkpoint carried none; the optimizer state comes back on the HOST and must be +moved with the policy by the caller. + +# Notes +Three refusals, each closing a way a run could continue while reporting +something untrue: + +- a checkpoint without this file's schema tag predates the architecture field + and the optimizer state; +- a checkpoint from a different network is a different problem; +- a checkpoint from a different ARCHITECTURE is a different function class. The + structural mismatch between an `LSTMCell` and an `RNNCell` would usually stop + it anyway, but "usually" is not a guarantee — two encoders can be built whose + weight shapes coincide — so the architecture is checked by name first, before + a single array is touched. +""" +function load_checkpoint!(policy::BatteryReachablePolicy, path::AbstractString; + case::Union{Nothing,BatteryCase} = nothing) + data = JLD2.load(path) + meta = data["meta"] + get(meta, "schema", "") == BATTERY_CHECKPOINT_SCHEMA || error( + "checkpoint $path carries schema $(repr(get(meta, "schema", missing))) " * + "but this engine writes $BATTERY_CHECKPOINT_SCHEMA") + want_arch = String(policy.architecture) + meta["architecture"] == want_arch || error( + "checkpoint $path was trained with architecture $(meta["architecture"]) " * + "but the policy in hand is $want_arch") + if case !== nothing && haskey(meta, "network_sha256") + want = case.manifest["artifacts"]["network.json"] + meta["network_sha256"] == want || error( + "checkpoint $path was trained on network $(meta["network_sha256"]) but the case in hand is $want") + end + load_stateconditioned_policy!(policy, data["state"]) + return (meta = meta, opt_state = get(data, "opt_state", nothing), + history = get(data, "history", nothing)) +end + + +# ───────────────────────────────────────────────────────────────────────────── +# The trajectory batch — the ONE place a batch of scenarios is solved +# +# Both entry points in this study use it: `train_strict` (one process, one +# training call) and the segment driver `portfolio_runner.jl`. Keeping two +# implementations of "solve `trajectories` scenarios and reduce their gradients" +# is how the two silently diverge, and the divergence would be invisible: both +# would still train, just not the same way. +# ───────────────────────────────────────────────────────────────────────────── + +"Default worker count. 1 reproduces the serial behaviour exactly." +const BATTERY_DEFAULT_WORKERS = 1 + +""" + cuda_device_binder(device) -> (bind!, describe, upload) + +Three closures for the accelerator: `bind!()` pins the CALLING TASK to the +device, `describe()` reports what that task actually has, and `upload(x)` moves +a host array onto the CALLING TASK's device. + +`upload` is how a worker materializes the targets the main task sent it. The +main task marshals them through the host — anything replied or sent across tasks +must be device-neutral — so the worker has a plain `Vector` and needs it on its +own device. Deriving the destination from `CUDA.cu` inside the worker is what +makes that device the worker's own; taking a reference array out of the problem +does NOT work, because a problem's parameter fields are `ExaModels.Parameter` +handles rather than arrays. + +# Notes +`bind!` must run INSIDE a worker task and BEFORE that worker constructs +anything, because the CUDA handles a solver allocates — CUBLAS, CUSPARSE, CUDSS +— bind to the calling task's device and stream at construction time. A problem +built on the main task and then solved from a worker is the documented way to +deadlock this stack. + +Everything the `@eval`ed imports bring into scope is newer than this function's +compiled world, so each is reached through `Base.invokelatest`. +""" +function cuda_device_binder(device::AbstractString) + lowercase(device) == "gpu" || + return (() -> nothing, () -> (device = "cpu", stream = "-"), identity) + cuda = Base.invokelatest(getglobal, Main, :CUDA) + bind! = function () + dev = Base.invokelatest(cuda.device) # the process's current device + Base.invokelatest(cuda.device!, dev) + return nothing + end + describe = () -> (device = string(Base.invokelatest(cuda.device)), + stream = string(Base.invokelatest(cuda.stream))) + # Element type is PRESERVED: the serial path handed `strict_solve!` whatever + # `rollout_targets` produced, and changing precision here would change the + # solve rather than only where it runs. + upload = x -> Base.invokelatest(cuda.cu, x) + return (bind!, describe, upload) +end + +""" + BatteryWorkerPool + +Persistent per-segment workers, each owning its own problem and solver. + +# Fields +- `workers`: how many. +- `inbox`, `outbox`: one request/reply channel per worker. +- `tasks`: the worker tasks, kept so `close_worker_pool!` can join them. +- `report`: what each worker actually bound to — device, stream, solver type — + recorded at construction so a claim about the accelerator is evidence rather + than configuration. +- `peak`: the largest number of solves in flight at once, observed. + +# Notes +`workers == 1` builds NO pool and no channels: the batch runs inline on the +calling task, which is bit-for-bit the path this file used before workers +existed. That is the compatible default, and it is also the only way the +single-worker and multi-worker results can be compared at all. +""" +mutable struct BatteryWorkerPool + workers::Int + inbox::Vector{Channel{Any}} + outbox::Vector{Channel{Any}} + tasks::Vector{Task} + report::Vector{Any} + peak::Int + inflight::Int +end + +""" + battery_worker_pool(case, num_stages, device, solver_kwargs; workers) -> BatteryWorkerPool + +Start `workers` persistent tasks, each of which binds the device, then builds +its OWN `BatteryExaProblem` and its own solver state inside that task. + +# Notes +Nothing is shared. A pool of workers over one problem would serialize on the +solver's internal state at best and corrupt it at worst; the cost of a problem +per worker is memory, and memory is what an H200 has. + +The whole worker body sits under `try`/`catch`: a `Threads.@spawn`ed task that +throws dies SILENTLY — the exception surfaces only at `wait`/`fetch` — so +without this the main task would block forever on `take!`, which is exactly what +a "hang" looks like from the outside. On error the worker reports loudly and +closes its outbox so the main loop fails fast instead of deadlocking. +""" +function battery_worker_pool(case::BatteryCase, num_stages::Integer, + device::AbstractString, solver_kwargs; + workers::Integer = BATTERY_DEFAULT_WORKERS) + workers = Int(workers) + workers >= 1 || throw(ArgumentError("workers must be at least 1, got $workers")) + pool = BatteryWorkerPool(workers, Channel{Any}[], Channel{Any}[], Task[], Any[], 0, 0) + if workers == 1 + # The inline path reports too, so "which device did this actually run + # on" is answerable at every worker count rather than only above one. + _, describe, _ = cuda_device_binder(device) + d = describe() + push!(pool.report, (worker = 1, device = d.device, stream = d.stream, + linear_solver = string(get(solver_kwargs, :linear_solver, "default")), + problem = UInt(0))) + return pool + end + + backend, _, _ = configure_device(device) + bind!, describe, upload = cuda_device_binder(device) + ready = Channel{Any}(workers) + for wi in 1:workers + inb = Channel{Any}(1); outb = Channel{Any}(1) + push!(pool.inbox, inb); push!(pool.outbox, outb) + t = Threads.@spawn try + bind!() # BEFORE anything is built + prob_w = build_battery_exa(case, Int(num_stages); backend = backend) + d = describe() + put!(ready, (worker = wi, device = d.device, stream = d.stream, + linear_solver = string(get(solver_kwargs, :linear_solver, "default")), + problem = objectid(prob_w))) + while true + msg = take!(inb) + msg === nothing && break + (sid, atoms, targets_cpu) = msg + targets_w = upload(targets_cpu) # onto THIS worker's device + result, sol, λ = strict_solve!(prob_w, case, atoms, targets_w; + solver_kwargs = solver_kwargs) + ok = solve_succeeded(result) + # Everything sent back is DEVICE-NEUTRAL. A device array replied + # into the main task's gradient is an illegal access waiting to + # happen the moment the two tasks are not on the same device. + put!(outb, (sid = sid, ok = ok, status = string(result.status), + loss = ok ? sum(stage_costs(prob_w, sol).total) : NaN, + lambda = ok ? Array(λ) : Float64[], + worst_recourse = ok ? max(maximum(abs, Array(sol.deficit)), + maximum(abs, Array(sol.surplus))) : NaN)) + end + catch e + @error "battery worker $wi died" exception = (e, catch_backtrace()) + close(outb) + rethrow() + end + push!(pool.tasks, t) + end + for _ in 1:workers + push!(pool.report, take!(ready)) + end + return pool +end + +""" + close_worker_pool!(pool) + +Send every worker its stop message and join it. Safe to call twice, and safe on +a pool whose workers already died. +""" +function close_worker_pool!(pool::BatteryWorkerPool) + for ch in pool.inbox + try; isopen(ch) && put!(ch, nothing); catch; end + end + for t in pool.tasks + try; wait(t); catch; end + end + empty!(pool.tasks) + return nothing +end + +""" + trajectory_batch!(pool, policy, prob, case, rng, num_stages, e0_dev, like; + solver_kwargs, trajectories, index) -> NamedTuple + +Solve one batch of `trajectories` scenarios and return the reduced gradient. + +# Returns +`(grads, losses, sids_dispatched, sids_accepted, sids_rejected, statuses, +worst_recourse, peak_inflight)`. + +# The determinism contract +1. **All scenarios are drawn FIRST**, in order, from `rng`, and numbered + `1..trajectories`. The sampler therefore advances by exactly `trajectories` + draws per batch no matter how many workers run or in what order they finish, + so a checkpointed RNG position means the same thing at every worker count. +2. Results are collected BY SCENARIO NUMBER, never by completion order. +3. Gradients are reduced in **scenario-number order**, because floating-point + addition is not associative and a completion-ordered sum would make the run + depend on which solve happened to finish first. +4. Exactly one optimizer update follows a batch, and only if at least one + scenario succeeded — the caller applies it. + +A failed scenario is retried ONCE, with the SAME scenario identity and the SAME +fixed solver configuration. There is no tolerance ladder and no second solver +setting: a scenario that fails twice under the frozen configuration is reported +as rejected and excluded from the reduction, never rescued by changing the +problem. +""" +function trajectory_batch!(pool::BatteryWorkerPool, policy::BatteryReachablePolicy, + prob::BatteryExaProblem, case::BatteryCase, rng, + num_stages::Integer, e0_dev, like; + solver_kwargs = NamedTuple(), trajectories::Integer = 2, + index::Integer = 0) + n = Int(trajectories) + n >= pool.workers || throw(ArgumentError( + "trajectories ($n) must be at least workers ($(pool.workers)): a worker " * + "with no scenario to solve would idle for the whole segment")) + + # (1) draw every scenario up front, in order + atoms_by_sid = [sample_atoms(rng, case, Int(num_stages)) for _ in 1:n] + features_by_sid = [rollout_features(case, prob.net, a; like = like) for a in atoms_by_sid] + targets_by_sid = [rollout_targets(policy, f, e0_dev) for f in features_by_sid] + + results = Vector{Any}(undef, n) + peak = 0 + + if pool.workers == 1 + for sid in 1:n + results[sid] = _solve_one_inline(prob, case, atoms_by_sid[sid], + targets_by_sid[sid], sid, solver_kwargs) + end + peak = 1 + else + # (2) dispatch up to `workers` at a time; collect by scenario number + next = 1 + busy = Dict{Int,Int}() # worker -> scenario id + free = collect(1:pool.workers) + inflight = 0 + while next <= n || !isempty(busy) + while next <= n && !isempty(free) + wi = pop!(free) + put!(pool.inbox[wi], (next, atoms_by_sid[next], Array(targets_by_sid[next]))) + busy[wi] = next + next += 1 + inflight += 1 + peak = max(peak, inflight) + end + for (wi, sid) in collect(busy) + # A dead worker closes its outbox on the way out. Without this + # check the loop polls a channel that will never be ready again + # and the segment hangs until the wall clock kills it — the + # failure looks like "slow" and is actually "dead". + if !isopen(pool.outbox[wi]) && !isready(pool.outbox[wi]) + error("worker $wi died while solving scenario $sid; its outbox is closed") + end + if isready(pool.outbox[wi]) + r = take!(pool.outbox[wi]) + results[r.sid] = r + delete!(busy, wi); push!(free, wi); inflight -= 1 + end + end + isempty(busy) || sleep(0.001) + end + end + + # (3) one retry per failed scenario, same identity, same solver configuration + for sid in 1:n + results[sid].ok && continue + @warn "strict solve failed; retrying the SAME scenario under the SAME configuration" index sid status=results[sid].status + results[sid] = pool.workers == 1 ? + _solve_one_inline(prob, case, atoms_by_sid[sid], targets_by_sid[sid], sid, solver_kwargs) : + begin + put!(pool.inbox[1], (sid, atoms_by_sid[sid], Array(targets_by_sid[sid]))) + take!(pool.outbox[1]) + end + end + + # (4) reduce in SCENARIO-NUMBER order + grads = nothing + losses = Float64[] + accepted = Int[]; rejected = Int[]; statuses = String[] + worst = 0.0 + for sid in 1:n + r = results[sid] + push!(statuses, r.status) + if !r.ok + push!(rejected, sid) + continue + end + push!(accepted, sid) + push!(losses, Float64(r.loss)) + worst = max(worst, Float64(r.worst_recourse)) + _, g = actor_gradient(policy, features_by_sid[sid], _to_like(like, r.lambda), e0_dev) + grads = grads === nothing ? g : _add_grads(grads, g) + end + pool.peak = max(pool.peak, peak) + return (grads = grads, losses = losses, dispatched = collect(1:n), + accepted = accepted, rejected = rejected, statuses = statuses, + worst_recourse = worst, peak_inflight = peak) +end + +"One scenario on the calling task, for the single-worker path." +function _solve_one_inline(prob, case, atoms, targets, sid, solver_kwargs) + result, sol, λ = strict_solve!(prob, case, atoms, targets; solver_kwargs = solver_kwargs) + ok = solve_succeeded(result) + return (sid = sid, ok = ok, status = string(result.status), + loss = ok ? sum(stage_costs(prob, sol).total) : NaN, + lambda = ok ? Array(λ) : Float64[], + worst_recourse = ok ? max(maximum(abs, Array(sol.deficit)), + maximum(abs, Array(sol.surplus))) : NaN) +end + +""" + train_strict(; kwargs...) -> NamedTuple + +Run one parameterized strict training stage, for either architecture. + +# Keywords +- `architecture::Symbol`: `:tsddr_nonlinear` (default) or + `:tsldr_recurrent_linear`; see [`BATTERY_ARCHITECTURES`](@ref). +- everything else as documented in this file's header. + +# Notes +One gradient step is: draw `trajectories` scenarios, roll the policy forward on +each, solve each strict deterministic equivalent, average the per-trajectory +actor gradients, and apply one Adam step at the scheduled learning rate. A small +sample gives a noisy but cheap gradient, which is what bulk descent wants; a +large one gives a precise gradient, which is what final convergence wants. + +Checkpoints are written only when a COMPLETE panel evaluation improves on the +best complete evaluation so far, so a policy that leans on physical recourse can +never become the selected one. + +**The architecture changes the policy and NOTHING else.** The stage model, the +strict target equality, the dual-gradient signal, the admissibility rule, the +corrected cost contract, the checkpoint machinery and the screening panel are +the same objects and the same code for both, which is the only way the two can +be compared on the panel afterwards. +""" +function train_strict(; case_dir::AbstractString = get(ENV, "DR_BAT_CASE_DIR", + joinpath(@__DIR__, "case", "pglib_opf_case14_ieee")), + architecture::Symbol = Symbol(get(ENV, "DR_BAT_ARCH", "tsddr_nonlinear")), + num_stages::Integer = parse(Int, get(ENV, "DR_BAT_STAGES", "24")), + epochs::Integer = parse(Int, get(ENV, "DR_BAT_EPOCHS", "2")), + batches::Integer = parse(Int, get(ENV, "DR_BAT_BATCHES", "5")), + trajectories::Integer = parse(Int, get(ENV, "DR_BAT_TRAJ", "2")), + workers::Integer = parse(Int, get(ENV, "DR_BAT_WORKERS", + string(BATTERY_DEFAULT_WORKERS))), + lr::Real = parse(Float64, get(ENV, "DR_BAT_LR", "1e-3")), + lr_final::Real = parse(Float64, get(ENV, "DR_BAT_LR_FINAL", "1e-4")), + encoder_layers = _env_ints("DR_BAT_ENCODER", [64, 64]), + head_layers = _env_ints("DR_BAT_HEAD", [128, 128]), + eval_every::Integer = parse(Int, get(ENV, "DR_BAT_EVAL_EVERY", "5")), + eval_columns = _env_ints("DR_BAT_EVAL_COLS", [1, 2, 3, 4]), + seed::Integer = parse(Int, get(ENV, "DR_BAT_SEED", "20260804")), + device::AbstractString = get(ENV, "DR_BAT_DEVICE", "cpu"), + max_recourse::Real = parse(Float64, get(ENV, "DR_BAT_MAX_RECOURSE", "1e-6")), + checkpoint::AbstractString = get(ENV, "DR_BAT_CHECKPOINT", + joinpath(@__DIR__, "battery_policy.jld2")), + verbose::Bool = true) + + case = read_battery_case(case_dir) + backend, to_device, solver_kwargs = configure_device(device) + + prob = build_battery_exa(case, Int(num_stages); backend = backend) + + Random.seed!(seed) + rng = StableRNG(seed) + policy = to_device(battery_reachable_policy(case, collect(Int, encoder_layers); + n_observation = prob.nBus, + n_context = N_CONTEXT, + head_layers = collect(Int, head_layers), + architecture = architecture)) + assert_device(policy, device) + + opt_state = Optimisers.setup(Optimisers.Adam(Float64(lr)), policy) + e0 = initial_energy(case) + like = _policy_array(policy) + e0_dev = _to_like(like, e0) + + total_steps = epochs * batches + # Resolved ONCE, before the first update, so a run that would have selected + # on the wrong protocol fails at its start rather than at its first + # evaluation — and so the kind is on the record from the beginning. + eval_matrix, eval_protocol = evaluation_protocol(case) + size(eval_matrix, 1) >= num_stages || + error("the $eval_protocol protocol has $(size(eval_matrix, 1)) stages but training asks for $num_stages") + verbose && @printf("selection panel: %s protocol, %d columns of %d\n", + eval_protocol, length(eval_columns), size(eval_matrix, 2)) + + history = NamedTuple[] + best = (cost = Inf, step = 0) + updates = 0 + t_start = time() + + # ONE batch implementation, shared with the segment driver. `workers == 1` + # runs it inline, which is the path this function always took. + pool = battery_worker_pool(case, num_stages, device, solver_kwargs; workers = workers) + try + for step in 1:total_steps + Optimisers.adjust!(opt_state, cosine_lr(step, total_steps, lr, lr_final)) + batch = trajectory_batch!(pool, policy, prob, case, rng, num_stages, e0_dev, like; + solver_kwargs = solver_kwargs, + trajectories = trajectories, index = step) + grads = batch.grads + losses = batch.losses + isempty(losses) && continue + grads = _scale_grads(grads, 1 / length(losses)) + opt_state, policy = Optimisers.update!(opt_state, policy, grads) + updates += 1 + push!(history, (step = step, loss = mean(losses), + lr = cosine_lr(step, total_steps, lr, lr_final))) + verbose && @printf("step %4d loss %14.4f lr %.3e\n", step, mean(losses), + cosine_lr(step, total_steps, lr, lr_final)) + + if eval_every > 0 && (step % eval_every == 0 || step == total_steps) + ev = evaluate_panel(policy, prob, case, collect(Int, eval_columns); + max_recourse = max_recourse, solver_kwargs = solver_kwargs) + verbose && @printf(" %s panel: mean %14.4f worst recourse %.3e complete %s\n", + ev.protocol, ev.mean_cost, ev.worst_recourse, ev.complete) + if ev.complete && ev.mean_cost < best.cost + best = (cost = ev.mean_cost, step = step) + save_checkpoint(checkpoint, policy, Dict( + "case" => case.name, + "network_sha256" => case.manifest["artifacts"]["network.json"], + "num_stages" => Int(num_stages), + "panel_protocol" => String(ev.protocol), + "panel_columns" => collect(Int, eval_columns), + "panel_mean_cost" => ev.mean_cost, + "step" => step, + "encoder_layers" => collect(Int, encoder_layers), + "head_layers" => collect(Int, head_layers), + "n_observation" => prob.nBus, + "n_context" => N_CONTEXT, + ); opt_state = opt_state, history = history) + end + end + end + + finally + # Workers are shut down on EVERY exit — normal, exception, or a caller + # that stopped early. A leaked worker holds a solver and its device + # memory for the life of the process. + close_worker_pool!(pool) + end + + return (policy = policy, problem = prob, case = case, + architecture = architecture, opt_state = opt_state, + protocol = eval_protocol, workers = workers, + worker_report = pool.report, peak_inflight = pool.peak, + history = history, best = best, updates = updates, + elapsed = time() - t_start, checkpoint = checkpoint) +end + +# ───────────────────────────────────────────────────────────────────────────── +# Device handling +# ───────────────────────────────────────────────────────────────────────────── + +""" + configure_device(device) -> (backend, to_device, solver_kwargs) + +Resolve `"cpu"` or `"gpu"` into an ExaModels backend, a policy mover, and the +MadNLP options that match. + +# Notes +The GPU path is loaded LAZILY, so the CPU path — which every correctness gate and +every CI run uses — never depends on a working CUDA installation. + +Three traps this function exists to avoid. `MadNLPGPU.CUDSSSolver` is `nothing` +unless CUDSS.jl has been loaded, and passing `nothing` as a linear solver fails +far from its cause. `Flux.gpu` is a silent no-op when cuDNN is absent, so a +"GPU" run can quietly execute the policy on the CPU; `cuDNN` is therefore +imported here and [`assert_device`](@ref) checks the outcome rather than trusting +it. And everything the `@eval`ed imports bring into scope is NEWER than this +function's own compiled world, so each of them is reached through +`Base.invokelatest`; calling them directly raises an "UndefVarError … the +binding may be too new". +""" +function configure_device(device::AbstractString) + if lowercase(device) == "cpu" + return nothing, identity, NamedTuple() + end + lowercase(device) == "gpu" || throw(ArgumentError("device must be \"cpu\" or \"gpu\"")) + @eval Main using CUDA, CUDSS, MadNLPGPU, cuDNN, KernelAbstractions + cuda = Base.invokelatest(getglobal, Main, :CUDA) + Base.invokelatest(cuda.functional) || + error("DR_BAT_DEVICE=gpu but CUDA is not functional") + backend = Base.invokelatest(cuda.CUDABackend) + madnlpgpu = Base.invokelatest(getglobal, Main, :MadNLPGPU) + linear_solver = Base.invokelatest(getglobal, madnlpgpu, :CUDSSSolver) + linear_solver === nothing && error("MadNLPGPU.CUDSSSolver is nothing; CUDSS.jl did not load") + return backend, x -> Base.invokelatest(Flux.gpu, x), (linear_solver = linear_solver,) +end + +""" + assert_device(policy, device) + +Fail loudly unless every trainable array and the recurrent state actually live +on the intended device. + +# Notes +A device move that silently did nothing is indistinguishable from a successful +one at the call site, and produces a run that reports GPU timings while +executing on the host. Checking the arrays themselves is the only assertion that +cannot be fooled. +""" +function assert_device(policy::BatteryReachablePolicy, device::AbstractString) + want_gpu = lowercase(device) == "gpu" + arrays = Any[] + Flux.fmap(x -> (x isa AbstractArray && push!(arrays, x); x), policy) + isempty(arrays) && error("assert_device found no arrays in the policy") + for a in arrays + on_gpu = !(a isa Array) + on_gpu == want_gpu || error( + "policy array of type $(typeof(a)) is $(on_gpu ? "on the GPU" : "on the CPU") but device=$device") + end + return nothing +end + +# ───────────────────────────────────────────────────────────────────────────── +# Small helpers +# ───────────────────────────────────────────────────────────────────────────── + +""" + _policy_array(policy) -> AbstractArray + +The first trainable array of `policy`, used as the reference for element type +and device when materializing rollout inputs. + +# Notes +Deriving the working array type from the policy itself — rather than from a +flag — means a policy that failed to move to the GPU produces CPU inputs and a +consistent (if slow) run, instead of a mixed-device `vcat` that fails deep +inside a kernel launch. +""" +function _policy_array(policy::BatteryReachablePolicy) + found = Ref{Any}(nothing) + Flux.fmap(x -> (x isa AbstractArray && found[] === nothing && (found[] = x); x), policy) + found[] === nothing && error("policy carries no arrays") + return found[] +end + +"Materialize `v` with the element type and device of `like`." +function _to_like(like::AbstractArray, v::AbstractVector) + out = similar(like, length(v)) + copyto!(out, eltype(like).(vec(Array(v)))) + return out +end + +"Parse a comma-separated integer list from the environment, with a default." +function _env_ints(key::AbstractString, default::AbstractVector{Int}) + raw = get(ENV, key, "") + isempty(strip(raw)) && return default + return [parse(Int, strip(x)) for x in split(raw, ",") if !isempty(strip(x))] +end + +"Recursively add two Zygote gradient trees of identical structure." +_add_grads(a::AbstractArray, b::AbstractArray) = a .+ b +_add_grads(a::Nothing, b) = b +_add_grads(a, b::Nothing) = a +_add_grads(::Nothing, ::Nothing) = nothing +_add_grads(a::NamedTuple{K}, b::NamedTuple{K}) where {K} = + NamedTuple{K}(map(_add_grads, values(a), values(b))) +_add_grads(a::Tuple, b::Tuple) = map(_add_grads, a, b) +_add_grads(a::Number, b::Number) = a + b + +"Recursively scale a Zygote gradient tree." +_scale_grads(a::AbstractArray, s) = a .* s +_scale_grads(::Nothing, s) = nothing +_scale_grads(a::NamedTuple{K}, s) where {K} = + NamedTuple{K}(map(x -> _scale_grads(x, s), values(a))) +_scale_grads(a::Tuple, s) = map(x -> _scale_grads(x, s), a) +_scale_grads(a::Number, s) = a * s + +# ───────────────────────────────────────────────────────────────────────────── +# The study's four method identifiers +# +# One table, carried by BOTH public engines with the same four rows and the same +# invariant fields, because the comparison the study makes is between four +# methods and not between two packages. Each engine can RUN the two methods it +# owns and refuses the other two by name, pointing at the engine that owns them — +# neither package loads the other, and a dispatch layer that pretended otherwise +# would fail somewhere less legible than here. +# ───────────────────────────────────────────────────────────────────────────── + +""" + BATTERY_METHODS + +The four policies this study compares, keyed by their stable identifier. + +# The rows + +| identifier | family | engine | what varies | +|---|---|---|---| +| `:tsddr_nonlinear` | `:tsddr` | `:exa` | LSTM encoder, nonlinear head | +| `:tsldr_recurrent_linear` | `:tsddr` | `:exa` | affine recurrence, affine head | +| `:sddp_soc` | `:sddp` | `:jump` | `SOCWRConicPowerModel` backward cuts | +| `:sddp_dc` | `:sddp` | `:jump` | `DCPPowerModel` backward cuts | + +# The invariants + +Every row declares the SAME `horizon`, `stage_semantics`, `recourse`, +`cost_contract` and `comparison` fields, and a test in each engine's suite +asserts it. They are recorded rather than assumed because the four methods are +only comparable if they share them: the frozen case and protocol identities, +`T = 24`, strict reachable targets with no target slack, uncapped physical nodal +recourse with the same admissibility rule, `physical_stage_cost` as the only +headline cost, and a true-ACP evaluation on paired protocol columns. + +`protocol` is `"screening"` for every row at this phase. The final 500-column +protocol is not opened by anything in this file. +""" +const BATTERY_METHODS = Dict{Symbol,NamedTuple}( + :tsddr_nonlinear => ( + family = :tsddr, engine = :exa, architecture = :tsddr_nonlinear, + backward = nothing, + summary = "strict TS-DDR with an LSTM encoder and a nonlinear bounded head"), + :tsldr_recurrent_linear => ( + family = :tsddr, engine = :exa, architecture = :tsldr_recurrent_linear, + backward = nothing, + summary = "strict recurrent TSLDR: affine recurrence and affine head, " * + "raw target affine in the observed demand history"), + :sddp_soc => ( + family = :sddp, engine = :jump, architecture = nothing, + backward = :soc, + summary = "SDDP with SOCWRConicPowerModel backward cuts and ACP forward decisions"), + :sddp_dc => ( + family = :sddp, engine = :jump, architecture = nothing, + backward = :dc, + summary = "SDDP with DCPPowerModel backward cuts and ACP forward decisions"), +) + +""" +The properties every one of [`BATTERY_METHODS`](@ref)' four rows shares. +""" +const BATTERY_METHOD_INVARIANTS = ( + horizon = 24, + protocol = "screening", + stage_semantics = "strict reachable outgoing-energy target, no target slack", + recourse = "uncapped two-sided physical nodal active recourse, admissibility at 1e-6 pu", + cost_contract = "physical_stage_cost from battery_solution_schema.jl", + comparison = "true-ACP cost on paired frozen protocol columns", +) + +""" + battery_method(id::Symbol) -> NamedTuple + +The descriptor of one method identifier, with the shared invariants merged in. + +# Notes +An unknown identifier raises and lists the four, rather than returning +`nothing`: a campaign driver that silently skipped a misspelled method would +report three-quarters of a study as a whole one. +""" +function battery_method(id::Symbol) + haskey(BATTERY_METHODS, id) || throw(ArgumentError( + "unknown battery method :$id; the study's methods are $(sort!(collect(keys(BATTERY_METHODS))))")) + return merge(BATTERY_METHODS[id], (id = id,), BATTERY_METHOD_INVARIANTS) +end + +""" + run_battery_method(id::Symbol; kwargs...) -> NamedTuple + +Dispatch a method identifier to this engine's implementation. + +# Notes +This engine owns the two `:exa` rows and runs them through the ONE +[`train_strict`](@ref) entry point, differing only in `architecture`. The two +`:sddp` rows belong to the JuMP engine: this package has no PowerModels and no +SDDP dependency by design, so they are refused by name here rather than +half-implemented. + +This is a dispatch layer, not a campaign runner. It selects an implementation +and forwards keyword arguments; it schedules nothing, resumes nothing and writes +no ledger. +""" +function run_battery_method(id::Symbol; kwargs...) + m = battery_method(id) + m.engine === :exa || error( + "method :$id runs on the $(m.engine) engine (DecisionRules.jl/examples/BatteryStorageOPF), " * + "not on this one; this package loads neither PowerModels nor SDDP") + return train_strict(; architecture = m.architecture, kwargs...) +end + +if abspath(PROGRAM_FILE) == @__FILE__ + out = train_strict() + @printf("\narchitecture %s\n", out.architecture) + @printf("%d updates in %.1f s; best complete panel %.4f at step %d\n", + out.updates, out.elapsed, out.best.cost, out.best.step) + @printf("checkpoint: %s\n", out.checkpoint) +end diff --git a/examples/HydroPowerModels/Project.toml b/examples/HydroPowerModels/Project.toml index 30e1a40..fa24e27 100644 --- a/examples/HydroPowerModels/Project.toml +++ b/examples/HydroPowerModels/Project.toml @@ -12,10 +12,15 @@ JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" MadNLP = "2621e9c9-9eb4-46b1-8089-e8c72242dfb6" MadNLPGPU = "d72a61cc-809d-412f-99be-fd81f4b8a598" +SHA = "ea8e919c-243c-51af-8825-aaa63cd721ce" +StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3" 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 = "../.."} +[extras] +CUDA_Runtime_jll = "76a88914-d11a-5bdc-97e0-2f5a05c973a2" + +[sources.DecisionRulesExa] +path = "../.." diff --git a/examples/HydroPowerModels/README.md b/examples/HydroPowerModels/README.md index 65f91a6..84e4db9 100644 --- a/examples/HydroPowerModels/README.md +++ b/examples/HydroPowerModels/README.md @@ -1,111 +1,117 @@ -# HydroPowerModels Example +# Bolivia hydro — ExaModels engine -Multi-stage hydrothermal scheduling using DecisionRulesExa.jl with DC or AC OPF formulations. +The GPU half of the long-term hydrothermal planning case study: this directory +trains and evaluates the policy. The case, the SDDP baseline and the figures live +in the companion package, `DecisionRules.jl/examples/HydroPowerModels`. -## Problem description +**The science is in the documentation** of that package, under *Case studies → +Long-term hydrothermal planning*. This file is the operating manual. -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: +The two packages share the case bytes and two source files **byte for byte**: +`bolivia/{PowerModels.json, hydro.json, inflows.csv, *.mof.json, +case_manifest.json}`, `generate_canonical_case_artifacts.jl` and +`hydro_solution_schema.jl`. The case files are mirrored by the other package's +`export_subproblem_mof.jl --exa-root=…`; the source files are copies whose +identity is the point — both engines assert the same case contract and write +their solutions in the same format, without either depending on the other. -- **Power flow constraints** (DC linearization or full AC polar OPF) -- **Reservoir dynamics** (water balance with stochastic inflows) -- **Generator and transmission limits** +## Layout -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 | +| file | role | |---|---| -| `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.) | +| `hydro_power_data.jl` | parses `PowerModels.json` / `hydro.json` / `inflows.csv` into the flat arrays the ExaModels builder consumes | +| `hydro_power_exa.jl` | builds the `ExaModel`: AC-polar or DC, strict or penalized targets, with `hydro_solution` to unpack a solved point into named blocks | +| `hydro_reachable_policy.jl` | the feasibility-guaranteeing policy (LSTM encoder over inflow, state-conditioned head, targets mapped into the one-stage reachable interval) | +| `hydro_solution_schema.jl` | the long format in which a full physical solution is written; byte-identical to the JuMP engine's copy | +| `hydro_training_utils.jl` | small shared helpers for the training scripts | +| `train_hydro_exa_strict.jl` | ONE training stage, fully parameterized by environment variables | +| `run_tsddr_lineage.jl` | the lineage driver: runs a declared multi-stage schedule end to end, chaining only selected checkpoints | +| `lineage_from_scratch.json` | the published from-scratch training schedule, as data: one entry per phase | +| `eval_paired_exa.jl` | paired evaluation of a checkpoint, with per-stage physical recording and an optional full-solution dump | +| `generate_canonical_case_artifacts.jl` | the frozen-case contract and its verifier | -## Running +## Commands -### GPU training (recommended) +Run from this directory with `--project=.`. -```julia -# From this directory: -julia --project -t auto train_hydro_exa.jl -``` +**1. Verify the case.** -Set `USE_GPU = true` in `train_hydro_exa.jl` (default). Requires a CUDA-capable GPU. +```bash +julia --project=. generate_canonical_case_artifacts.jl --verify +``` -### GPU training with critic control variate +**2. A short GPU smoke run** — a few updates on a short horizon, to confirm the +GPU stack (MadNLPGPU + CUDSS + cuDNN) is working before committing hours: -```julia -# From this directory: -julia --project -t auto train_hydro_exa_critic.jl +```bash +DR_NUM_STAGES=8 DR_NUM_ROLLOUT_STAGES=8 \ +DR_NUM_EPOCHS=1 DR_NUM_BATCHES=3 DR_NUM_TRAIN_PER_BATCH=2 \ +DR_NUM_EVAL_SCENARIOS=2 DR_EVAL_PROTOCOL_IDS=2,39 DR_EVAL_EVERY=3 \ +DR_ENABLE_WANDB=false \ + julia --project=. -t auto train_hydro_exa_strict.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()`. +**3. The full from-scratch training recipe.** This is the published schedule, +declared in `lineage_from_scratch.json` and executed stage by stage: -### CPU training +```bash +julia --project=. run_tsddr_lineage.jl # full lineage +julia --project=. run_tsddr_lineage.jl --dry-run # print the plan only +julia --project=. run_tsddr_lineage.jl --stages=phase3 # resume one phase +``` -Set `USE_GPU = false` in `train_hydro_exa.jl`, then run the same command. +Each stage runs as its own process, so a stage boundary is a real restart: the +optimizer state, the cosine learning-rate phase and the warm-up counter all +begin again. The driver chains only checkpoints that a COMPLETE, non-shedding +panel evaluation selected, hashes every parent before use, refuses `_latest` +snapshots outright, and stops the lineage — rather than falling back — if a +stage produces nothing selectable. Re-running resumes: a stage whose record +exists and whose checkpoint still hashes correctly is skipped. -### Configuration +Records land in `bolivia/ACPPowerModel/lineage/`: one JSON per stage with the +resolved environment, ancestry, checkpoint hashes, update count and both the +process wall time and the trainer's own training-loop seconds, plus a +lineage-level ledger. -Key parameters in `train_hydro_exa.jl`: +Neither W&B nor a workload manager is required. `DR_ENABLE_WANDB=false` turns +logging off; nothing in the driver reads a scheduler variable. -| 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) | +**4. Paired evaluation of a checkpoint.** -### Training features +```bash +DR_EVAL_CKPT=/path/to/checkpoint.jld2 DR_EVAL_LABEL=my_policy \ + julia --project=. -t auto eval_paired_exa.jl # the 10-column panel -- **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 +DR_EVAL_CKPT=… DR_EVAL_LABEL=shard_1_50 \ +DR_EVAL_COL_FIRST=1 DR_EVAL_COL_LAST=50 \ + julia --project=. -t auto eval_paired_exa.jl # one shard of the 500 +``` -## Validation +Adding `DR_SOLUTION_DUMP=1` additionally writes the full primal solution of every +stage and the decision trace that reproduces it, in the shared long format of +`hydro_solution_schema.jl` — the per-bus, per-branch physics the stagewise +figures are built from. (Nodal prices are duals and come from the JuMP engine's +evaluators, which have them directly.) -Compare the ExaModels formulation against a JuMP/MadNLP reference: +## Configuration surface of one training stage -```julia -julia --project -t auto eval_exa_de.jl -``` +`train_hydro_exa_strict.jl` is driven entirely by environment variables; the +lineage driver simply sets them. The ones that define a stage: -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. +| variable | meaning | +|---|---| +| `DR_NUM_TRAIN_PER_BATCH` | `nt`, trajectories sampled per gradient step | +| `DR_LR`, `DR_LR_FINAL`, `DR_LR_WARMUP` | cosine learning-rate schedule and its warm-up | +| `DR_NUM_EPOCHS` × `DR_NUM_BATCHES` | the update budget | +| `DR_MAX_TRAIN_SECONDS` | wall budget for the training loop | +| `DR_EVAL_EVERY`, `DR_EVAL_PROTOCOL_IDS`, `DR_NUM_EVAL_SCENARIOS` | the fixed evaluation panel and its cadence | +| `DR_SAVE_METRIC=rollout` | select checkpoints on the panel, not on the training loss | +| `DR_MAX_DEFICIT_PU` | reject an evaluation that shed load | +| `DR_ROLLOUT_PARALLEL`, `DR_ROLLOUT_RETRY_FAILED` | pooled vs sequential evaluation, and whether a failed scenario is retried sequentially | +| `DR_PRETRAINED_MODEL`, `DR_SEED_BEST`, `DR_PARENT_REPRO_TOL` | the parent checkpoint, its recorded value, and how exactly it must reproduce | +| `DR_STAGE_SUMMARY` | where to write the machine-readable end-of-stage record | + +`DR_STOP_AFTER_STALE_EVALS` exists but defaults off, and should stay off unless a +stage is expected to improve monotonically: raising the learning rate at a +restart reliably degrades the policy before it recovers, and a small stale count +terminates the stage inside that dip. diff --git a/examples/HydroPowerModels/bolivia/ACPPowerModel.mof.json b/examples/HydroPowerModels/bolivia/ACPPowerModel.mof.json index 5e63547..a38c526 100644 --- a/examples/HydroPowerModels/bolivia/ACPPowerModel.mof.json +++ b/examples/HydroPowerModels/bolivia/ACPPowerModel.mof.json @@ -1,39045 +1 @@ -{ - "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 - } - } - ] -} +{"has_scalar_nonlinear":true,"name":"MathOptFormat Model","version":{"major":1,"minor":7},"variables":[{"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},{"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]_in","primal_start":0.0},{"name":"reservoir[1]_out","primal_start":0.0},{"name":"reservoir[2]_in","primal_start":0.0},{"name":"reservoir[2]_out","primal_start":0.0},{"name":"reservoir[3]_in","primal_start":0.0},{"name":"reservoir[3]_out","primal_start":0.0},{"name":"reservoir[4]_in","primal_start":0.0},{"name":"reservoir[4]_out","primal_start":0.0},{"name":"reservoir[5]_in","primal_start":0.0},{"name":"reservoir[5]_out","primal_start":0.0},{"name":"reservoir[6]_in","primal_start":0.0},{"name":"reservoir[6]_out","primal_start":0.0},{"name":"reservoir[7]_in","primal_start":0.0},{"name":"reservoir[7]_out","primal_start":0.0},{"name":"reservoir[8]_in","primal_start":0.0},{"name":"reservoir[8]_out","primal_start":0.0},{"name":"reservoir[9]_in","primal_start":0.0},{"name":"reservoir[9]_out","primal_start":0.0},{"name":"reservoir[10]_in","primal_start":0.0},{"name":"reservoir[10]_out","primal_start":0.0},{"name":"reservoir[11]_in","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":"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":"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":"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.4213950047523992,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.4213950047523992,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.46024690223052,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.46024690223052,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.7456627284627748,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.7456627284627748,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.3473152225768015,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.3473152225768015,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.13631367642289954,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.13631367642289954,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.0916977112407253,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.0916977112407253,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-15.980730481506358,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-15.980730481506358,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.4325735387749903,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.4325735387749903,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.8777625235737184,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.8777625235737184,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.28958087993976717,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.28958087993976717,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.128676282013955,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.128676282013955,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.8287243608560181,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.8287243608560181,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.2416585439004273,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.2416585439004273,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-3.027806843733998,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-3.027806843733998,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-17.788682717374634,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-17.788682717374634,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.9656776626482336,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.9656776626482336,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.3418494649701906,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.3418494649701906,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.2592269273704175,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.2592269273704175,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.5442206253457624,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.5442206253457624,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.5382017465334347,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.5382017465334347,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-10.614654857863137,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-10.614654857863137,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-4.66785040912336,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-4.66785040912336,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.434853977156145,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.434853977156145,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.64335500582701,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.64335500582701,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.5424832182137913,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.5424832182137913,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.070955528571676,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.070955528571676,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.4978494338705233,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-1.4978494338705233,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.26161249681590054,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.26161249681590054,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.9263284811715553,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.9263284811715553,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.450918029773461,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-2.450918029773461,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.9733135131308841,{"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":"sin","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":[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":"cos","args":[{"type":"node","index":15}]},{"type":"*","args":[{"type":"node","index":12},{"type":"node","index":16}]},{"type":"*","args":[-0.9733135131308841,{"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":1.0,"variable":"reservoir[1]_out"},{"coefficient":0.6048,"variable":"outflow[1]"},{"coefficient":-0.6048,"variable":"outflow[2]"},{"coefficient":1.0,"variable":"spill[1]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[2]_out"},{"coefficient":0.6048,"variable":"outflow[2]"},{"coefficient":1.0,"variable":"spill[2]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[3]_out"},{"coefficient":0.6048,"variable":"outflow[3]"},{"coefficient":1.0,"variable":"spill[3]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[4]_out"},{"coefficient":0.6048,"variable":"outflow[4]"},{"coefficient":1.0,"variable":"spill[4]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[5]_out"},{"coefficient":0.6048,"variable":"outflow[5]"},{"coefficient":1.0,"variable":"spill[5]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[6]_out"},{"coefficient":-0.6048,"variable":"outflow[5]"},{"coefficient":0.6048,"variable":"outflow[6]"},{"coefficient":-1.0,"variable":"spill[5]"},{"coefficient":1.0,"variable":"spill[6]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[7]_out"},{"coefficient":0.6048,"variable":"outflow[7]"},{"coefficient":1.0,"variable":"spill[7]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[8]_out"},{"coefficient":0.6048,"variable":"outflow[8]"},{"coefficient":1.0,"variable":"spill[8]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[9]_out"},{"coefficient":-0.6048,"variable":"outflow[8]"},{"coefficient":0.6048,"variable":"outflow[9]"},{"coefficient":-1.0,"variable":"spill[8]"},{"coefficient":1.0,"variable":"spill[9]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[10]_out"},{"coefficient":0.6048,"variable":"outflow[10]"},{"coefficient":1.0,"variable":"spill[10]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[11]_out"},{"coefficient":0.6048,"variable":"outflow[11]"},{"coefficient":1.0,"variable":"spill[11]"},{"coefficient":-0.6048,"variable":"inflow[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.054227917226262}},{"function":{"type":"Variable","name":"inflow[2]"},"set":{"type":"EqualTo","value":15.253237155042374}},{"function":{"type":"Variable","name":"inflow[3]"},"set":{"type":"EqualTo","value":0.42297175432264633}},{"function":{"type":"Variable","name":"inflow[4]"},"set":{"type":"EqualTo","value":4.444426961132509}},{"function":{"type":"Variable","name":"inflow[5]"},"set":{"type":"EqualTo","value":5.401448346338854}},{"function":{"type":"Variable","name":"inflow[6]"},"set":{"type":"EqualTo","value":7.602365317441269}},{"function":{"type":"Variable","name":"inflow[7]"},"set":{"type":"EqualTo","value":0.40433946449534874}},{"function":{"type":"Variable","name":"inflow[8]"},"set":{"type":"EqualTo","value":10.01360814824206}},{"function":{"type":"Variable","name":"inflow[9]"},"set":{"type":"EqualTo","value":8.080938535198477}},{"function":{"type":"Variable","name":"inflow[10]"},"set":{"type":"EqualTo","value":1.0239458291153407}},{"function":{"type":"Variable","name":"inflow[11]"},"set":{"type":"EqualTo","value":3.507487794885554}},{"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}}]} \ No newline at end of file diff --git a/examples/HydroPowerModels/bolivia/DCPPowerModel.mof.json b/examples/HydroPowerModels/bolivia/DCPPowerModel.mof.json index b9cd177..05c24ea 100644 --- a/examples/HydroPowerModels/bolivia/DCPPowerModel.mof.json +++ b/examples/HydroPowerModels/bolivia/DCPPowerModel.mof.json @@ -1,7018 +1 @@ -{ - "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 - } - } - ] -} +{"name":"MathOptFormat Model","version":{"major":1,"minor":7},"variables":[{"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},{"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]_in","primal_start":0.0},{"name":"reservoir[1]_out","primal_start":0.0},{"name":"reservoir[2]_in","primal_start":0.0},{"name":"reservoir[2]_out","primal_start":0.0},{"name":"reservoir[3]_in","primal_start":0.0},{"name":"reservoir[3]_out","primal_start":0.0},{"name":"reservoir[4]_in","primal_start":0.0},{"name":"reservoir[4]_out","primal_start":0.0},{"name":"reservoir[5]_in","primal_start":0.0},{"name":"reservoir[5]_out","primal_start":0.0},{"name":"reservoir[6]_in","primal_start":0.0},{"name":"reservoir[6]_out","primal_start":0.0},{"name":"reservoir[7]_in","primal_start":0.0},{"name":"reservoir[7]_out","primal_start":0.0},{"name":"reservoir[8]_in","primal_start":0.0},{"name":"reservoir[8]_out","primal_start":0.0},{"name":"reservoir[9]_in","primal_start":0.0},{"name":"reservoir[9]_out","primal_start":0.0},{"name":"reservoir[10]_in","primal_start":0.0},{"name":"reservoir[10]_out","primal_start":0.0},{"name":"reservoir[11]_in","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":"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":"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_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":-12.485777918589607,"variable":"0_va[5]"},{"coefficient":12.485777918589607,"variable":"0_va[6]"},{"coefficient":1.0,"variable":"0_p[(5, 5, 6)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c31","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":6.795713842466891,"variable":"0_va[14]"},{"coefficient":-6.795713842466891,"variable":"0_va[13]"},{"coefficient":1.0,"variable":"0_p[(16, 13, 14)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c32","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-10.149298248521102,"variable":"0_va[16]"},{"coefficient":10.149298248521102,"variable":"0_va[17]"},{"coefficient":1.0,"variable":"0_p[(20, 16, 17)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c33","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":6.481250938450924,"variable":"0_va[12]"},{"coefficient":-6.481250938450924,"variable":"0_va[9]"},{"coefficient":1.0,"variable":"0_p[(12, 9, 12)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c34","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":4.2328983731321435,"variable":"0_va[22]"},{"coefficient":-4.2328983731321435,"variable":"0_va[21]"},{"coefficient":1.0,"variable":"0_p[(24, 21, 22)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c35","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.091029561081878,"variable":"0_va[25]"},{"coefficient":2.091029561081878,"variable":"0_va[26]"},{"coefficient":1.0,"variable":"0_p[(28, 25, 26)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c36","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":45.39453875906154,"variable":"0_va[8]"},{"coefficient":-45.39453875906154,"variable":"0_va[7]"},{"coefficient":1.0,"variable":"0_p[(8, 7, 8)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c37","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-19.8968547052082,"variable":"0_va[14]"},{"coefficient":19.8968547052082,"variable":"0_va[15]"},{"coefficient":1.0,"variable":"0_p[(17, 14, 15)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c38","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":9.121944633618186,"variable":"0_va[28]"},{"coefficient":-9.121944633618186,"variable":"0_va[19]"},{"coefficient":1.0,"variable":"0_p[(30, 19, 28)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c39","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":9.363115118052471,"variable":"0_va[1]"},{"coefficient":-9.363115118052471,"variable":"0_va[2]"},{"coefficient":1.0,"variable":"0_p[(1, 2, 1)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c40","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-3.33399327650884,"variable":"0_va[20]"},{"coefficient":3.33399327650884,"variable":"0_va[21]"},{"coefficient":1.0,"variable":"0_p[(23, 20, 21)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c41","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.8140484527509644,"variable":"0_va[16]"},{"coefficient":2.8140484527509644,"variable":"0_va[19]"},{"coefficient":1.0,"variable":"0_p[(22, 16, 19)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c42","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":3.667991302391842,"variable":"0_va[16]"},{"coefficient":-3.667991302391842,"variable":"0_va[14]"},{"coefficient":1.0,"variable":"0_p[(19, 14, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c43","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-20.88296190751831,"variable":"0_va[5]"},{"coefficient":20.88296190751831,"variable":"0_va[11]"},{"coefficient":1.0,"variable":"0_p[(6, 5, 11)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c44","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-52.44594387363901,"variable":"0_va[9]"},{"coefficient":52.44594387363901,"variable":"0_va[10]"},{"coefficient":1.0,"variable":"0_p[(11, 9, 10)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c45","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":5.498037005409949,"variable":"0_va[28]"},{"coefficient":-5.498037005409949,"variable":"0_va[19]"},{"coefficient":1.0,"variable":"0_p[(31, 19, 28)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c46","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-6.467289330533839,"variable":"0_va[7]"},{"coefficient":6.467289330533839,"variable":"0_va[10]"},{"coefficient":1.0,"variable":"0_p[(9, 7, 10)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c47","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-8.698708713000553,"variable":"0_va[11]"},{"coefficient":8.698708713000553,"variable":"0_va[18]"},{"coefficient":1.0,"variable":"0_p[(14, 11, 18)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c48","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-17.010777436904807,"variable":"0_va[3]"},{"coefficient":17.010777436904807,"variable":"0_va[4]"},{"coefficient":1.0,"variable":"0_p[(3, 3, 4)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c49","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-1.6861921183958626,"variable":"0_va[17]"},{"coefficient":1.6861921183958626,"variable":"0_va[27]"},{"coefficient":1.0,"variable":"0_p[(29, 17, 27)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c50","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-31.512256609281188,"variable":"0_va[6]"},{"coefficient":31.512256609281188,"variable":"0_va[7]"},{"coefficient":1.0,"variable":"0_p[(7, 6, 7)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c51","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":8.939086077602251,"variable":"0_va[23]"},{"coefficient":-8.939086077602251,"variable":"0_va[22]"},{"coefficient":1.0,"variable":"0_p[(25, 22, 23)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c52","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":16.36003009370084,"variable":"0_va[5]"},{"coefficient":-16.36003009370084,"variable":"0_va[4]"},{"coefficient":1.0,"variable":"0_p[(4, 4, 5)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c53","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":1.8998888915041532,"variable":"0_va[16]"},{"coefficient":-1.8998888915041532,"variable":"0_va[9]"},{"coefficient":1.0,"variable":"0_p[(13, 9, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c54","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-7.029547007720768,"variable":"0_va[12]"},{"coefficient":7.029547007720768,"variable":"0_va[13]"},{"coefficient":1.0,"variable":"0_p[(15, 12, 13)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c55","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":7.165952433825185,"variable":"0_va[3]"},{"coefficient":-7.165952433825185,"variable":"0_va[2]"},{"coefficient":1.0,"variable":"0_p[(2, 2, 3)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c56","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-2.868957761798156,"variable":"0_va[24]"},{"coefficient":2.868957761798156,"variable":"0_va[25]"},{"coefficient":1.0,"variable":"0_p[(27, 24, 25)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c57","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":11.73125512037617,"variable":"0_va[16]"},{"coefficient":-11.73125512037617,"variable":"0_va[18]"},{"coefficient":1.0,"variable":"0_p[(21, 18, 16)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c58","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":5.604798539074481,"variable":"0_va[24]"},{"coefficient":-5.604798539074481,"variable":"0_va[23]"},{"coefficient":1.0,"variable":"0_p[(26, 23, 24)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c59","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":-6.776372942488066,"variable":"0_va[8]"},{"coefficient":6.776372942488066,"variable":"0_va[9]"},{"coefficient":1.0,"variable":"0_p[(10, 8, 9)]"}],"constant":0.0},"set":{"type":"EqualTo","value":0.0}},{"name":"c60","function":{"type":"ScalarAffineFunction","terms":[{"coefficient":2.875699016068521,"variable":"0_va[20]"},{"coefficient":-2.875699016068521,"variable":"0_va[14]"},{"coefficient":1.0,"variable":"0_p[(18, 14, 20)]"}],"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":1.0,"variable":"reservoir[1]_out"},{"coefficient":0.6048,"variable":"outflow[1]"},{"coefficient":-0.6048,"variable":"outflow[2]"},{"coefficient":1.0,"variable":"spill[1]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[2]_out"},{"coefficient":0.6048,"variable":"outflow[2]"},{"coefficient":1.0,"variable":"spill[2]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[3]_out"},{"coefficient":0.6048,"variable":"outflow[3]"},{"coefficient":1.0,"variable":"spill[3]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[4]_out"},{"coefficient":0.6048,"variable":"outflow[4]"},{"coefficient":1.0,"variable":"spill[4]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[5]_out"},{"coefficient":0.6048,"variable":"outflow[5]"},{"coefficient":1.0,"variable":"spill[5]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[6]_out"},{"coefficient":-0.6048,"variable":"outflow[5]"},{"coefficient":0.6048,"variable":"outflow[6]"},{"coefficient":-1.0,"variable":"spill[5]"},{"coefficient":1.0,"variable":"spill[6]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[7]_out"},{"coefficient":0.6048,"variable":"outflow[7]"},{"coefficient":1.0,"variable":"spill[7]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[8]_out"},{"coefficient":0.6048,"variable":"outflow[8]"},{"coefficient":1.0,"variable":"spill[8]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[9]_out"},{"coefficient":-0.6048,"variable":"outflow[8]"},{"coefficient":0.6048,"variable":"outflow[9]"},{"coefficient":-1.0,"variable":"spill[8]"},{"coefficient":1.0,"variable":"spill[9]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[10]_out"},{"coefficient":0.6048,"variable":"outflow[10]"},{"coefficient":1.0,"variable":"spill[10]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[11]_out"},{"coefficient":0.6048,"variable":"outflow[11]"},{"coefficient":1.0,"variable":"spill[11]"},{"coefficient":-0.6048,"variable":"inflow[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":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_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}}]} \ No newline at end of file diff --git a/examples/HydroPowerModels/bolivia/SOCWRConicPowerModel.mof.json b/examples/HydroPowerModels/bolivia/SOCWRConicPowerModel.mof.json index 14d2ff7..811bd1c 100644 --- a/examples/HydroPowerModels/bolivia/SOCWRConicPowerModel.mof.json +++ b/examples/HydroPowerModels/bolivia/SOCWRConicPowerModel.mof.json @@ -1,21020 +1 @@ -{ - "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 - } - } - ] -} +{"name":"MathOptFormat Model","version":{"major":1,"minor":7},"variables":[{"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]_in","primal_start":0.0},{"name":"reservoir[1]_out","primal_start":0.0},{"name":"reservoir[2]_in","primal_start":0.0},{"name":"reservoir[2]_out","primal_start":0.0},{"name":"reservoir[3]_in","primal_start":0.0},{"name":"reservoir[3]_out","primal_start":0.0},{"name":"reservoir[4]_in","primal_start":0.0},{"name":"reservoir[4]_out","primal_start":0.0},{"name":"reservoir[5]_in","primal_start":0.0},{"name":"reservoir[5]_out","primal_start":0.0},{"name":"reservoir[6]_in","primal_start":0.0},{"name":"reservoir[6]_out","primal_start":0.0},{"name":"reservoir[7]_in","primal_start":0.0},{"name":"reservoir[7]_out","primal_start":0.0},{"name":"reservoir[8]_in","primal_start":0.0},{"name":"reservoir[8]_out","primal_start":0.0},{"name":"reservoir[9]_in","primal_start":0.0},{"name":"reservoir[9]_out","primal_start":0.0},{"name":"reservoir[10]_in","primal_start":0.0},{"name":"reservoir[10]_out","primal_start":0.0},{"name":"reservoir[11]_in","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":"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":"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":1.0,"variable":"reservoir[1]_out"},{"coefficient":0.6048,"variable":"outflow[1]"},{"coefficient":-0.6048,"variable":"outflow[2]"},{"coefficient":1.0,"variable":"spill[1]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[2]_out"},{"coefficient":0.6048,"variable":"outflow[2]"},{"coefficient":1.0,"variable":"spill[2]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[3]_out"},{"coefficient":0.6048,"variable":"outflow[3]"},{"coefficient":1.0,"variable":"spill[3]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[4]_out"},{"coefficient":0.6048,"variable":"outflow[4]"},{"coefficient":1.0,"variable":"spill[4]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[5]_out"},{"coefficient":0.6048,"variable":"outflow[5]"},{"coefficient":1.0,"variable":"spill[5]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[6]_out"},{"coefficient":-0.6048,"variable":"outflow[5]"},{"coefficient":0.6048,"variable":"outflow[6]"},{"coefficient":-1.0,"variable":"spill[5]"},{"coefficient":1.0,"variable":"spill[6]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[7]_out"},{"coefficient":0.6048,"variable":"outflow[7]"},{"coefficient":1.0,"variable":"spill[7]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[8]_out"},{"coefficient":0.6048,"variable":"outflow[8]"},{"coefficient":1.0,"variable":"spill[8]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[9]_out"},{"coefficient":-0.6048,"variable":"outflow[8]"},{"coefficient":0.6048,"variable":"outflow[9]"},{"coefficient":-1.0,"variable":"spill[8]"},{"coefficient":1.0,"variable":"spill[9]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[10]_out"},{"coefficient":0.6048,"variable":"outflow[10]"},{"coefficient":1.0,"variable":"spill[10]"},{"coefficient":-0.6048,"variable":"inflow[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":1.0,"variable":"reservoir[11]_out"},{"coefficient":0.6048,"variable":"outflow[11]"},{"coefficient":1.0,"variable":"spill[11]"},{"coefficient":-0.6048,"variable":"inflow[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":2.338129891598134}},{"function":{"type":"Variable","name":"inflow[2]"},"set":{"type":"EqualTo","value":19.049733526468252}},{"function":{"type":"Variable","name":"inflow[3]"},"set":{"type":"EqualTo","value":0.48408174580858665}},{"function":{"type":"Variable","name":"inflow[4]"},"set":{"type":"EqualTo","value":5.40128586100095}},{"function":{"type":"Variable","name":"inflow[5]"},"set":{"type":"EqualTo","value":9.16293594438752}},{"function":{"type":"Variable","name":"inflow[6]"},"set":{"type":"EqualTo","value":13.401595443549056}},{"function":{"type":"Variable","name":"inflow[7]"},"set":{"type":"EqualTo","value":0.6835222599450383}},{"function":{"type":"Variable","name":"inflow[8]"},"set":{"type":"EqualTo","value":8.002953930720434}},{"function":{"type":"Variable","name":"inflow[9]"},"set":{"type":"EqualTo","value":6.459871302494316}},{"function":{"type":"Variable","name":"inflow[10]"},"set":{"type":"EqualTo","value":1.8616228172257083}},{"function":{"type":"Variable","name":"inflow[11]"},"set":{"type":"EqualTo","value":3.210450288504671}},{"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}}]} \ No newline at end of file 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/case_manifest.json b/examples/HydroPowerModels/bolivia/case_manifest.json new file mode 100644 index 0000000..9ec3c38 --- /dev/null +++ b/examples/HydroPowerModels/bolivia/case_manifest.json @@ -0,0 +1,105 @@ +{ + "case": "Bolivia (upstream case, unmodified)", + "costs": { + "active_deficit_cost_derivation": "cost_deficit 60 USD/MWh * baseMVA 100", + "active_deficit_cost_usd_per_pu_stage": 6000.0, + "reactive_balance": "hard" + }, + "demand": { + "active_load_factor": 0.6, + "deterministic": true, + "reactive_load_factor": 0.6, + "uncertainty": "none; inflow uncertainty only" + }, + "forbidden_case_files": [ + "demand.csv", + "demand_scenarios.csv", + "demand_noise.csv" + ], + "frozen_on": "2026-08-02", + "horizon": { + "lookahead_stages": 30, + "reporting_stages": 96, + "total_stages": 126 + }, + "initial_state": { + "effective": "empty (all reservoirs at zero)", + "empty_volume_tolerance": 1.0e-300, + "float32_is_exactly_zero": true, + "mechanism": "clamp(initial_volume, min_volume, max_volume) at engine precision", + "note": "Empty start. hydro.json carries denormal initial_volume values near 9e-316; both engines clamp the initial state into [min_volume, max_volume] and evaluate it at working precision, which leaves every reservoir at zero. No 70%-of-capacity repair is applied — the published result was produced from the raw bytes.", + "raw_initial_volume_max": 9.23059684e-316 + }, + "input_hashes": { + "PowerModels.json": "1ff598447957f9fc17ca570415bf5b9b5b14e1292ea3bd3163db0ad79911a782", + "hydro.json": "b25ce1c7bafcfaf907091dcd1007949c79a79974c9a33020b2587400d756b29a", + "inflows.csv": "5afb275dff3fc879e3e93b6510b81295834faad0bcd2bd1fc070a8e3e6653c77" + }, + "method": { + "sddp_backward_formulation": "SOCWRConicPowerModel", + "sddp_forward_formulation": "ACPPowerModel", + "tsddr_formulation": "ACPPowerModel", + "tsddr_target_activation": "stretchedsigmoid", + "tsddr_target_mode": "strict" + }, + "protocol": { + "indices_sha256": "ff229968f2d3b5d1ec66dc0d9f7b340785d26fa3def79f9fd9c544b6b1c9110c", + "inflow_scenarios": 15, + "rng": "StableRNG(seed); rand(1:nCen, 126, 500)", + "scenario_ids": "1:500 (global column ids; shards must preserve them)", + "scenarios": 500, + "seed": 20260706, + "stages": 126, + "uncertainty": "inflow only" + }, + "schema_version": 2, + "stage_models": { + "consumed_by": "build_hydropowermodels (JuMP/MAIN stage subproblems)", + "exports": { + "ACPPowerModel": { + "active_deficit_terms": 28, + "constraints": 884, + "hydro_balance_inflow_coefficient": 0.6048, + "hydro_balances": 11, + "matches_case_K": true, + "objective_sense": "min", + "sha256": "60d64f12efbc1c274b28e8d89c50c455aaaeaa3dc7b4208166aa8daa87079f21", + "variables": 353 + }, + "DCPPowerModel": { + "active_deficit_terms": 28, + "constraints": 391, + "hydro_balance_inflow_coefficient": 0.6048, + "hydro_balances": 11, + "matches_case_K": true, + "objective_sense": "min", + "sha256": "4fc1e35fd4b3cc0d854f63a202f8838be0e32dd925a909c6a7dea1a1c7a32fdb", + "variables": 198 + }, + "SOCWRConicPowerModel": { + "active_deficit_terms": 28, + "constraints": 1123, + "hydro_balance_inflow_coefficient": 0.6048, + "hydro_balances": 11, + "matches_case_K": true, + "objective_sense": "min", + "sha256": "531a20c6e4a7e0faffdda808d56a5a0ab0782135abc48b71f7c201a190db270f", + "variables": 385 + } + }, + "generator": "export_subproblem_mof.jl", + "note": "One-stage subproblem exports generated by export_subproblem_mof.jl from the frozen inputs through HydroPowerModels with stage_hours = 168, so the hydro-balance inflow coefficient is the case's K = 0.6048. The JuMP/MAIN workflow loads these files as its stage subproblems; SDDP builds through HydroPowerModels and the ExaModels engine builds its own model." + }, + "topology_counts": { + "branches": 31, + "buses": 28, + "generators": 34, + "hydro_units": 11, + "loads": 26 + }, + "water_balance": { + "K": 0.6048, + "K_derivation": "0.0036 * stage_hours", + "stage_hours": 168 + } +} 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/eval_paired_exa.jl b/examples/HydroPowerModels/eval_paired_exa.jl new file mode 100644 index 0000000..224e53a --- /dev/null +++ b/examples/HydroPowerModels/eval_paired_exa.jl @@ -0,0 +1,470 @@ +#!/usr/bin/env julia + +# Paired evaluation of a trained strict TS-DDR checkpoint on the frozen Bolivia +# protocol, with the per-stage physical decisions recorded. +# +# This is the evaluator that produced the published TS-DDR distribution. It does +# NOT reimplement the rollout: it calls the production +# `DecisionRulesExa.rollout_tsddr` with the trainer's exact stage configuration +# and attaches a `stage_recorder`, which reads the solution the rollout has +# already computed. The per-column costs therefore average to the same panel mean +# the trainer's own evaluation reports for the same checkpoint. +# +# Four CSVs are always written, in the same schema as the SDDP evaluator's +# `DR_PHYSICAL_AUDIT=1` output so the two can be differenced column by column and +# stage by stage: +# +#