diff --git a/.github/dependabot.yml b/.github/dependabot.yml index 2124afe..44cfebb 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -11,3 +11,9 @@ updates: directory: "/" schedule: interval: "weekly" + ignore: + # The v5→v7 bump silently broke coverage uploads ("Missing Head Commit" + # on PRs). 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 852dc10..c3e707b 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -19,12 +19,13 @@ jobs: permissions: # needed to allow julia-actions/cache to proactively delete old caches that it has created actions: write contents: read + id-token: write # OIDC token for tokenless Codecov uploads (see codecov step) strategy: fail-fast: false matrix: version: - '1.10' - # - 'nightly' + - '1.12' os: - ubuntu-latest arch: @@ -39,8 +40,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: the dependabot bump to v7 (2026-06-25) silently broke + # uploads — Codecov has no commit newer than 2026-06-15, which is what + # produces "Missing Head Commit" on PRs. v5 is the last version verified + # to upload from this workflow. Before re-bumping, migrate deliberately + # (e.g. OIDC: `use_oidc: true` + `id-token: write` permission) 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; if uploads fail with an OIDC error, + # either install the app 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: a silent upload failure hid this breakage for weeks. + fail_ci_if_error: true diff --git a/.gitignore b/.gitignore index c019973..cfb7f58 100644 --- a/.gitignore +++ b/.gitignore @@ -55,3 +55,7 @@ plan/ *_cuts.json settings.json *.sh +*-backup +*.cuts.json.stale_stronggrid +*strong.json +.claude/settings.local.json diff --git a/README.md b/README.md index 710b710..86d8ebe 100644 --- a/README.md +++ b/README.md @@ -54,22 +54,25 @@ using DecisionRules, JuMP, DiffOpt, Flux using SCS # 1) Build per-stage subproblems (DiffOpt-enabled) and collect: -# subproblems, state_params_in, state_params_out, uncertainty_sampler, uncertainties_structure +# subproblems, state_params_in, state_params_out, uncertainty_samples # 2) Build the deterministic equivalent over the full horizon det = DiffOpt.diff_model(() -> DiffOpt.diff_optimizer(SCS.Optimizer)) -det, uncertainties_structure_det = DecisionRules.deterministic_equivalent!( +det, uncertainty_samples_det = DecisionRules.deterministic_equivalent!( det, subproblems, state_params_in, state_params_out, Float64.(initial_state), - uncertainties_structure, + uncertainty_samples, ) +# deterministic_equivalent! remaps state_params_in/state_params_out in place. +# Copy those arrays first if you also need the original stage-wise refs later. + # 3) Train a TS-DDR policy end-to-end -num_uncertainties = length(uncertainty_sampler()[1]) # number of uncertainty components per stage +num_uncertainties = length(uncertainty_samples[1]) # number of uncertainty components per stage policy = Chain( Dense(DecisionRules.policy_input_dim(num_uncertainties, length(initial_state)), 64, relu), Dense(64, length(initial_state)), @@ -79,9 +82,9 @@ DecisionRules.train_multistage( policy, initial_state, det, - state_in_det, - state_out_det, - uncertainty_sampler; + state_params_in, + state_params_out, + uncertainty_samples_det; num_batches=100, num_train_per_batch=32, optimizer=Flux.Adam(1e-3), @@ -97,7 +100,7 @@ Single shooting solves one optimization per stage and rolls forward using the re ```julia using DecisionRules, Flux -num_uncertainties = length(uncertainty_sampler()[1]) +num_uncertainties = length(uncertainty_samples[1]) policy = Chain( Dense(DecisionRules.policy_input_dim(num_uncertainties, length(initial_state)), 64, relu), Dense(64, length(initial_state)), @@ -109,7 +112,7 @@ DecisionRules.train_multistage( subproblems, state_params_in, state_params_out, - uncertainty_sampler; + uncertainty_samples; num_batches=100, num_train_per_batch=32, optimizer=Flux.Adam(1e-3), @@ -126,7 +129,7 @@ Multiple shooting partitions the horizon into windows of length `window_size`. E using DecisionRules, Flux, DiffOpt using SCS -num_uncertainties = length(uncertainty_sampler()[1]) +num_uncertainties = length(uncertainty_samples[1]) policy = Chain( Dense(DecisionRules.policy_input_dim(num_uncertainties, length(initial_state)), 64, relu), Dense(64, length(initial_state)), @@ -149,10 +152,7 @@ DecisionRules.train_multiple_shooting( policy, initial_state, windows, - state_params_in, - state_params_out, - uncertainty_sampler; - window_size=24, # e.g., 6, 24, ... + uncertainty_samples; num_batches=100, num_train_per_batch=32, optimizer=Flux.Adam(1e-3), @@ -168,7 +168,8 @@ The training loops record metrics through a per-sample `SampleLog` cache and a p ```julia using DecisionRules, Random -# Materialize a FIXED held-out evaluation set once, before training +# Materialize a FIXED held-out evaluation set once, before training. +# Use stage-wise subproblems and parameter refs, not DE-remapped refs. Random.seed!(1234) eval_scenarios = [DecisionRules.sample(uncertainty_samples) for _ in 1:8] @@ -178,7 +179,7 @@ rollout_eval = RolloutEvaluation( policy_state=:realized, ) -train_multistage(policy, initial_state, det, state_in_det, state_out_det, uncertainty_sampler; +train_multistage(policy, initial_state, det, state_params_in, state_params_out, uncertainty_samples_det; num_batches=100, record=(sample_log, iter, model) -> begin rollout_eval(iter, model) @@ -202,6 +203,57 @@ Each evaluation reports (a) the rollout objective **excluding** the target-slack Per-sample debugging hooks can be attached with `SampleLog(on_sample=(s, models, log) -> ...)`; the training loop calls the hook after each sample's solve with the live JuMP model(s). The previous `record_loss=(iter, model, loss, tag) -> ...` keyword keeps working as a deprecated adapter. +## Strict mode and reachable policies + +The standard TS-DDR target constraint uses slack: + +```math +x_t + \delta_t = \hat{x}_t, +\qquad +\text{objective} += C_\delta \|\delta_t\|. +``` + +Slack makes training robust to unreachable targets, but it also makes the dual +signal depend on the target-penalty calibration. Strict mode removes the slack: + +```math +x_t = \hat{x}_t. +``` + +The resulting dual is the clean shadow price of imposing the target. The price +of that cleaner signal is feasibility: every policy target must be reachable +from the state used to condition the policy. + +This is automatic in the hydro strict subproblem path because each stage is +solved sequentially and the policy receives the realized previous reservoir +state. It is also possible in regular deterministic equivalents when the target +trajectory is rolled out from the true initial state using a reachable policy: + +```math +\hat{x}_0 = x_0,\qquad +\hat{x}_t = \pi_\theta(w_t, \hat{x}_{t-1}),\qquad +\hat{x}_t \in R(\hat{x}_{t-1}, w_t). +``` + +By induction, all targets are feasible, and the strict equalities force the +realized trajectory to match that reachable path. See +[`examples/HydroPowerModels`](examples/HydroPowerModels) and the +DecisionRulesExa.jl companion for the GPU strict regular-DE implementation. + +The reachable map ``R(\hat x_{t-1}, w_t)`` depends on the state, and that +dependence **must be differentiated**. Treating the interval endpoints as +constants still trains and still lowers the loss while descending a materially +different direction — on the hydro case, a gradient carrying 6% of the true +magnitude and pointing 48 degrees away from it. Verify the complete actor +gradient against finite differences before trusting any hyperparameter +conclusion drawn on top of it. + +The policy helpers separate two architectural choices: + +- recurrent `layers` / `DR_ENCODER_LAYERS` process uncertainty history only; +- `combiner_layers` / `DR_HEAD_LAYERS` add a nonlinear feed-forward + state-to-target head without recurrence over the state input. + ## GPU acceleration with DecisionRulesExa.jl For large-scale problems where the inner NLP solve is the bottleneck (e.g., AC-OPF with hundreds of buses), [DecisionRulesExa.jl](https://github.com/LearningToOptimize/DecisionRulesExa.jl) provides a GPU-accelerated backend that replaces JuMP with [ExaModels.jl](https://github.com/exanauts/ExaModels.jl) and solves with [MadNLP.jl](https://github.com/MadNLP/MadNLP.jl) + CUDSS on GPU. @@ -222,6 +274,24 @@ Examples live in `examples/`. Run tests with: julia --project -e 'using Pkg; Pkg.test()' ``` +## Repository Map + +| Path | Purpose | +|---|---| +| `src/DecisionRules.jl` | Module entrypoint and exports | +| `src/dense_multilayer_nn.jl` | MLP helpers, state-conditioned recurrent policies, nonlinear target heads | +| `src/simulate_multistage.jl` | Stage-wise and deterministic-equivalent simulation logic | +| `src/multiple_shooting.jl` | Windowed multiple-shooting setup, simulation, and training | +| `src/utils.jl` | Target-parameter utilities, deficit construction, rollout evaluation | +| `src/integer_strategies.jl` | Strategies for extracting gradients from integer/mixed-integer models | +| `src/score_function.jl` | Score-function gradient correction for nonsmooth/integer problems | +| `src/parameter_duals.jl` | Dual/sensitivity helpers for parameterized JuMP models | +| `docs/src/` | Documenter.jl manual pages | +| `examples/inventory_control/` | Inventory-control example and dynamic-programming/SDDP comparisons | +| `examples/rocket_control/` | Rocket MPC/control example | +| `examples/Experimental/` | Research prototypes and robotics/control explorations | +| `test/runtests.jl` | Package test suite | + ## Citation If you use this package in academic work, please cite: diff --git a/docs/Project.toml b/docs/Project.toml index cadd9b3..6a67612 100644 --- a/docs/Project.toml +++ b/docs/Project.toml @@ -1,4 +1,6 @@ [deps] +CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b" +ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" DecisionRules = "47937410-f832-486f-8300-12c95b225dfc" DiffOpt = "930fe3bc-9c6b-11ea-2d94-6184641e85e7" Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4" @@ -8,9 +10,13 @@ HiGHS = "87dc4568-4c63-4d18-b0c0-bb2238e4078b" Ipopt = "b6b21f68-93f8-5de0-b562-5493be1d77c9" JuMP = "4076af6c-e467-56ae-b986-b466b2749572" Literate = "98b081ad-f1c9-55d3-8b20-4c87d4299306" +JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee" Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +SHA = "ea8e919c-243c-51af-8825-aaa63cd721ce" +StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3" Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" [compat] Documenter = "1" diff --git a/docs/make.jl b/docs/make.jl index 490de9b..d7655d5 100644 --- a/docs/make.jl +++ b/docs/make.jl @@ -2,15 +2,16 @@ using Documenter using Literate using DecisionRules -# Convert Literate.jl sources to markdown -examples_src = joinpath(@__DIR__, "src", "examples") -examples_out = joinpath(@__DIR__, "src", "examples") -for file in readdir(examples_src) - endswith(file, ".jl") || continue - Literate.markdown( - joinpath(examples_src, file), examples_out; - documenter=true, credit=false, - ) +# Convert Literate.jl sources to markdown, in place, wherever they live: a case +# study that owns a runnable walkthrough keeps it beside its prose rather than in +# a separate examples pile. +for dir in (joinpath(@__DIR__, "src", "examples"), + joinpath(@__DIR__, "src", "casestudies", "hydro")) + isdir(dir) || continue + for file in readdir(dir) + endswith(file, ".jl") || continue + Literate.markdown(joinpath(dir, file), dir; documenter=true, credit=false) + end end makedocs(; @@ -20,19 +21,35 @@ makedocs(; format=Documenter.HTML(; prettyurls=get(ENV, "CI", nothing) == "true", canonical="https://LearningToOptimize.github.io/DecisionRules.jl", + size_threshold=300 * 1024, ), pages=[ "Home" => "index.md", - "Algorithm" => "algorithm.md", - "Gradient Fallback" => "gradient_fallback.md", - "Uncertainty Sampling" => "sampling.md", - "GPU Acceleration" => "gpu_acceleration.md", - "Examples" => [ - "Hydropower Scheduling" => "examples/hydro.md", - "Rocket Control" => "examples/rocket.md", - "Stochastic Lot-Sizing (Integer Variables)" => "examples/inventory.md", + "Part I — Theory" => [ + "Multistage stochastic optimization" => "theory/multistage.md", + "The TS-DDR framework" => "algorithm.md", + "Stochastic dual dynamic programming" => "theory/sddp.md", + "Extensions: mixed gradients, critics, risk" => "theory/extensions.md", + ], + "Part II — Package Guide" => [ + "Getting started" => "guide/getting_started.md", + "Uncertainty sampling" => "sampling.md", + "Gradient fallback" => "gradient_fallback.md", + "GPU acceleration" => "gpu_acceleration.md", + "API reference" => "api.md", + ], + "Part III — Case Studies" => [ + "Battery-storage AC-OPF" => "casestudies/battery_storage_opf.md", + "Long-term hydrothermal planning" => [ + "Overview" => "casestudies/hydro/index.md", + "The problem" => "casestudies/hydro/problem.md", + "Valuing water: two approaches" => "casestudies/hydro/method.md", + "Results" => "casestudies/hydro/results.md", + "Walkthrough" => "casestudies/hydro/walkthrough.md", + ], + "Rocket control" => "examples/rocket.md", + "Stochastic lot-sizing (integer variables)" => "examples/inventory.md", ], - "API Reference" => "api.md", ], ) diff --git a/docs/src/algorithm.md b/docs/src/algorithm.md index 36c3d24..c2822ce 100644 --- a/docs/src/algorithm.md +++ b/docs/src/algorithm.md @@ -1,18 +1,23 @@ -# Algorithm +# The TS-DDR framework ```@meta CurrentModule = DecisionRules ``` -This page summarizes the TS-DDR (Two-Stage Deep Decision Rules) training algorithm. -For the full derivation, see [arXiv:2405.14973](https://arxiv.org/abs/2405.14973). +This chapter develops the TS-DDR (Two-Stage Deep Decision Rules) training +algorithm — the core of DecisionRules.jl. For the full derivation, see +[arXiv:2405.14973](https://arxiv.org/abs/2405.14973); for the general +problem class and where decision rules sit among solution methods, see +[Multistage stochastic optimization](@ref). ## Problem setting -Consider a ``T``-stage stochastic control problem where at each stage ``t`` we observe -an uncertainty realization ``w_t`` and must choose an action ``u_t`` that satisfies -stage constraints ``(u_t, x_t) \in \mathcal{X}_t(x_{t-1}, w_t)``. The goal is to -minimize the expected total cost: +Consider the ``T``-stage stochastic control problem of the previous +chapter: at each stage ``t`` we observe an uncertainty realization ``w_t`` +and must choose an action ``u_t`` that satisfies +stage constraints ``(u_t, x_t) \in \mathcal{X}_t(x_{t-1}, w_t)``. Restricting +attention to a parametric policy class, the goal is to +minimize the expected total cost over the parameters: ```math \min_\theta \; \mathbb{E}_{w_{1:T}} \left[ \sum_{t=1}^{T} c_t(x_t, u_t) \right] @@ -27,9 +32,13 @@ Instead of mapping observations directly to actions, the policy outputs **target states**: ```math -\hat{x}_{1:T} = \pi_\theta(w_{1:T}) +\hat{x}_t = \pi_\theta(w_t, \hat{x}_{t-1}), \qquad \hat{x}_0 = x_0, ``` +evaluated stage-wise with state feedback: each target is conditioned on the +previous target state during deterministic-equivalent training (or on the +realized state ``x_{t-1}`` in closed-loop rollouts). + A projection subproblem enforces feasibility by solving: ```math @@ -105,110 +114,172 @@ for k = 1, ..., ⌈T/W⌉: pass realized end-state to window k+1 ``` -**Pros**: balances coupling (within windows) with tractability; parallelizable windows. -**Cons**: continuity gaps between windows require penalty tuning. - -## Mixed gradient: score-function (REINFORCE) correction +**Pros**: balances coupling (within windows) with tractability; cheaper inner +solves than a full-horizon deterministic equivalent. +**Cons**: windows are chained sequentially during rollout/training because each +window needs the previous realized end-state; cross-window coupling is weaker +than in the full deterministic equivalent. + +## Beyond the pure dual gradient + +The dual gradient above is exact for smooth subproblems and unbiased over +fresh samples. Two extensions handle the situations where that is not +enough — **discrete decisions**, where the dual is local to a fixed +integer assignment and a score-function (REINFORCE) correction restores +the missing signal, and **small sample budgets**, where a control-variate +critic reduces the estimator's variance without moving its optimum. Both +are developed, together with a risk-averse change-of-measure variant, in +[Extensions: mixed gradients, critics, and risk](@ref); the score-function +correction is exercised in the +[Stochastic Lot-Sizing with Fixed Ordering Costs](@ref) case study. -For problems with integer variables or non-smooth subproblems, the dual -gradient can be biased — it is local to a fixed integer assignment and cannot -see the effect of discrete switches (e.g., opening a setup variable). +## Penalty annealing -DecisionRules provides a **score-function (REINFORCE)** correction that mixes -the dual gradient with a model-free policy gradient estimated from stage-wise -rollouts under perturbed targets. +The target penalty ``\lambda`` is critical: too small and the optimizer ignores +targets (no gradient); too large and the problem becomes ill-conditioned. DecisionRules.jl +supports a **penalty annealing schedule** that ramps ``\lambda`` during training: -### How the score-function estimator works +``` +Phase 1 (warmup): λ × 0.1 — let the policy explore +Phase 2 (nominal): λ × 1.0 — standard training +Phase 3 (tighten): λ × 10.0 — sharpen target tracking +Phase 4 (lock): λ × 30.0 — final precision +``` -1. **Perturb**: add Gaussian noise to the policy targets: - ``\tilde{x}_t = \hat{x}_t(\theta) + \delta_t``, where - ``\delta_t \sim \mathcal{N}(0, \sigma^2 I)``. +This is the `default_annealed` schedule, activated with `penalty_schedule=:default_annealed`. -2. **Rollout**: solve the stage-wise subproblems with the perturbed targets to - obtain realized costs ``R_m`` for ``m = 1, \ldots, M`` rollouts. These - rollouts solve the models exactly as built (MIPs stay MIPs), so the costs - reflect true integer-feasible decisions. +## Strict mode: penalty-free gradient signal -3. **Advantage**: center the costs ``A_m = R_m - \bar{R}`` (mean baseline - reduces variance without changing the expected gradient). +The standard TS-DDR formulation uses a penalty ``C_\delta \|\delta_t\|`` to +penalize deviations from the policy's targets. While effective, the penalty +introduces a trade-off: the dual ``\lambda_t`` conflates the **economic shadow +price** with a **penalty-correction term**. At high penalty, the gradient +signal tells the policy "reduce ``\delta``" rather than "be economically +optimal." -4. **Surrogate loss**: the differentiable scalar whose gradient recovers the - REINFORCE estimate: +**Strict mode** eliminates this coupling entirely by replacing the slack +constraint ``x_t + \delta_t = \hat{x}_t`` with a **hard equality**: ```math -L_{\text{sf}}(\theta) -\;=\; -\frac{1}{M} \sum_{m=1}^{M} - A_m - \sum_{t=1}^{T} - \left\langle - \frac{\delta_{m,t}}{\sigma^2},\; - \hat{x}_{t+1}(\theta) - \right\rangle. +x_t = \hat{x}_t \quad :\lambda_t ``` -This is the standard score-function estimator for Gaussian perturbations. -The key identity is -``\nabla_\theta \log p(\delta_t \mid \theta) = \delta_t / \sigma^2`` -for a Gaussian centered at ``\hat{x}_t(\theta)``. +There are no deficit variables, no penalty term, and no penalty to tune. The +dual ``\lambda_t`` is the **pure shadow price** ``\partial Q_t / \partial +\hat{x}_t`` — the marginal value of changing the target, uncontaminated by +any regularization. -### Mixed gradient +### The condition: target reachability -The final training gradient combines both signals: +A hard equality has no slack to absorb an unreachable target, so strict mode +is well-posed under exactly one condition: **every target the policy emits +must be attainable from the state the system is in when the corresponding +stage is solved.** Formally, let ```math -\nabla L -\;=\; -\alpha\, \nabla L_{\text{dual}} -+ (1 - \alpha)\, \nabla L_{\text{sf}}, +R(x, w) \;=\; \bigl\{\, x' \;:\; \exists\, u \text{ with } + (u, x') \in \mathcal{X}(x, w) \,\bigr\} ``` -where ``\alpha \in [0, 1]`` is the `dual_weight`. - -There are two separate solve paths in the mixed-gradient training loop: - -- **Dual path**: controlled by `integer_strategy`, which determines how local - dual information is read from the deterministic equivalent - (e.g., [`FixedDiscreteIntegerStrategy`](@ref) solves the MIP, fixes integers, - re-solves the LP, and reads LP duals). -- **Score-function path**: controlled by [`ScoreFunctionConfig`](@ref), which - owns separate rollout subproblems. These are solved exactly as built, and - their realized costs define the Monte Carlo score-function term. - -### Scheduled ramp-in +denote the **one-stage reachable set** — the states attainable from ``x`` +under realization ``w`` by some admissible action. Strict mode requires +``\hat{x}_t \in R(x_{t-1}, w_t)`` at every stage, where ``x_{t-1}`` is the +*realized* state. + +A **feasibility-guaranteeing policy** enforces this by construction: it +computes (an inner approximation of) ``R`` from its input state and maps the +network output into that set, typically by scaling a sigmoid-bounded output +across the reachable interval. The bounds carry no gradient; the gradient path +is solely through the network output, exactly as in the standard TS-DDR +pipeline. Constructing ``R`` is problem-specific. It is cheap whenever the +dynamics are linear in the controls with box bounds — resource-balance +equations are the canonical case. The +[battery-storage study](@ref "Stochastic battery-storage AC optimal power flow") +derives the battery-dynamic interval and explains why a network-constrained OPF +still needs an empirical strict-feasibility gate. + +### Validity in every formulation, by induction + +Reachability of each target from the *policy's input state* is enough to make +strict mode well-posed in **all** training formulations — stage-wise +subproblems, the embedded deterministic equivalent, and the regular +deterministic equivalent alike. The argument is one induction, and the strict +equality itself is what carries it: suppose ``\hat{x}_0 = x_0`` (the known +initial state) and every policy call returns a target reachable from the state +it conditioned on, -A [`ScoreFunctionSchedule`](@ref) can ramp ``\alpha`` from 1 (pure dual) to -its final value over a warmup period. Let ``k`` be the current iteration and -``\rho_k = \operatorname{clip}((k - k_0) / r,\, 0,\, 1)``. The effective -score-function weight is ``\rho_k (1 - \alpha)``. - -This lets the DE dual gradient establish a good initial policy before -introducing the higher-variance REINFORCE signal. - -See the [Stochastic Lot-Sizing with Fixed Ordering Costs](@ref) example for a -complete worked example with integer variables and mixed gradients. - -## Penalty annealing - -The target penalty ``\lambda`` is critical: too small and the optimizer ignores -targets (no gradient); too large and the problem becomes ill-conditioned. DecisionRules.jl -supports a **penalty annealing schedule** that ramps ``\lambda`` during training: - -``` -Phase 1 (warmup): λ × 0.1 — let the policy explore -Phase 2 (nominal): λ × 1.0 — standard training -Phase 3 (tighten): λ × 10.0 — sharpen target tracking -Phase 4 (lock): λ × 30.0 — final precision +```math +\hat{x}_t = \pi_\theta(w_t, \hat{x}_{t-1}) \in R(\hat{x}_{t-1}, w_t). ``` -This is the `default_annealed` schedule, activated with `penalty_schedule=:default_annealed`. +1. Stage 1 is feasible: ``\hat{x}_1`` is reachable from the true initial + state ``x_0 = \hat{x}_0``. +2. If stages ``1, \ldots, t`` are feasible, their strict equalities force + ``x_s = \hat{x}_s`` for ``s \le t``. The state the policy conditioned on + when producing ``\hat{x}_{t+1}`` is therefore *identical* to the realized + state ``x_t``, so ``\hat{x}_{t+1} \in R(x_t, w_{t+1})`` and stage ``t+1`` + is feasible. + +The formulations differ only in *which symbol* plays the policy input. In +stage-wise rollouts the policy reads the realized state ``x_{t-1}`` directly; +in the embedded DE it reads the solver's state variables; in the regular DE it +reads its own previous target ``\hat{x}_{t-1}``. Under strict equalities these +are the same object — the induction shows previous target ``\equiv`` previous +realized state — so no formulation is a special case and none needs a separate +argument. In particular, the regular DE is *not* an exception requiring extra +structure: the strict equality **closes the loop as a consequence**, it does +not presuppose a closed loop. + +### Information pattern: closed-loop vs. open-loop + +Distinct from the well-posedness question is the **information pattern**: does +the policy read the *realized* state (closed-loop feedback) or its *own +previous target* (open-loop target generation)? This axis matters +independently of strict mode: + +- In **non-strict** training, slack lets the realized state deviate from the + target, so the two inputs genuinely differ. A regular DE trains the policy + on target feedback while the optimizer realizes something else — a + train/deploy mismatch that shows up at evaluation (below). +- Under **strict equalities** the distinction collapses: realized state and + target are identical at every stage, so target feedback and realized + feedback are the same function evaluation, and training-time DE solves and + deployment-time stage-wise rollouts traverse identical trajectories. + +Keeping the two axes separate is the point: *strict-mode validity* is about +reachability of targets; *closed- vs. open-loop* is about what information the +policy consumes. Strict mode does not require closed-loop evaluation — it +makes the question moot by forcing the two information patterns to coincide. + +### When to use strict mode + +Whenever it is applicable — a feasible initial state and a policy constructed +to emit only **one-stage reachable** targets — strict mode is the preferred +formulation. The only reason to fall back to the penalty formulation is +numerical: some solvers degrade when the additional hard equality constraints +are imposed (the equalities remove the slack that otherwise absorbs small +constraint violations during intermediate iterates). + +Everything else follows as a beneficial side effect rather than a selection +criterion: there is no penalty hyperparameter to tune, no annealing schedule, +and the dual ``\lambda_t`` is the exact shadow price of the target — the +gradient signal is uncontaminated by a regularization term. + +In the +[battery-storage AC-OPF study](@ref "Stochastic battery-storage AC optimal power flow"), +strict mode is accepted only after representative true-ACP rollouts solve with +zero load shedding. This distinguishes dynamic reachability from full network +feasibility. ## Evaluation semantics -A policy trained on the deterministic equivalent generates targets using **target-state -feedback** (each target depends on the previous *predicted* target, not the realized -state). Evaluating such a policy with **realized-state feedback** (deployment semantics) -tests a different closed-loop path and will generally report higher cost. +A policy trained on the (non-strict) deterministic equivalent generates targets +using **target-state feedback** (each target depends on the previous *predicted* +target, not the realized state). Evaluating such a policy with **realized-state +feedback** (deployment semantics) tests a different closed-loop path and will +generally report higher cost. Under strict equalities the two modes coincide — +realized states equal targets identically — so the choice below is material +only when slack is present. [`RolloutEvaluation`](@ref) supports both modes via the `policy_state` keyword: - `:target` — matches DE training semantics (fair in-sample comparator) diff --git a/docs/src/assets/bolivia_inflow.svg b/docs/src/assets/bolivia_inflow.svg new file mode 100644 index 0000000..fc65532 --- /dev/null +++ b/docs/src/assets/bolivia_inflow.svg @@ -0,0 +1,27 @@ + + + +0 + +20 + +40 + +60 + +80 +wk 1 +wk 9 +wk 17 +wk 25 +wk 33 +wk 41 + + + +wet peak · wk 2 + +dry trough · wk 28 +Reservoir inflow across the year +energy-weighted · band = p10–p90 across 15 historical scenarios + \ No newline at end of file diff --git a/docs/src/assets/bolivia_map.svg b/docs/src/assets/bolivia_map.svg new file mode 100644 index 0000000..fc1a33a --- /dev/null +++ b/docs/src/assets/bolivia_map.svg @@ -0,0 +1,83 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +Santa Cruz + +Cochabamba + +La Paz + +Oruro + +Potosí + +Sucre + +Tarija + +Trinidad +The Bolivian SIN — capacity, storage & load +satellite nodes fan each city's assets out from its bus so nothing overlaps + + +hydro + +gas thermal + +reservoir storage + +average load + +load · mining core + +230 kV corridor + +115 kV corridor + +69 kV corridor + + \ No newline at end of file diff --git a/docs/src/assets/hydro_cost_comparison.png b/docs/src/assets/hydro_cost_comparison.png deleted file mode 100644 index c806f5a..0000000 Binary files a/docs/src/assets/hydro_cost_comparison.png and /dev/null differ diff --git a/docs/src/assets/hydro_cost_distributions.png b/docs/src/assets/hydro_cost_distributions.png new file mode 100644 index 0000000..837d782 Binary files /dev/null and b/docs/src/assets/hydro_cost_distributions.png differ diff --git a/docs/src/assets/hydro_energy_price.png b/docs/src/assets/hydro_energy_price.png new file mode 100644 index 0000000..2709323 Binary files /dev/null and b/docs/src/assets/hydro_energy_price.png differ diff --git a/docs/src/assets/hydro_generation_comparison.png b/docs/src/assets/hydro_generation_comparison.png deleted file mode 100644 index b601e59..0000000 Binary files a/docs/src/assets/hydro_generation_comparison.png and /dev/null differ diff --git a/docs/src/assets/hydro_paired_differences.png b/docs/src/assets/hydro_paired_differences.png new file mode 100644 index 0000000..2deb0a7 Binary files /dev/null and b/docs/src/assets/hydro_paired_differences.png differ diff --git a/docs/src/assets/hydro_stagewise_physical.png b/docs/src/assets/hydro_stagewise_physical.png new file mode 100644 index 0000000..fd455f6 Binary files /dev/null and b/docs/src/assets/hydro_stagewise_physical.png differ diff --git a/docs/src/assets/hydro_training_convergence.png b/docs/src/assets/hydro_training_convergence.png deleted file mode 100644 index 3fd5455..0000000 Binary files a/docs/src/assets/hydro_training_convergence.png and /dev/null differ diff --git a/docs/src/assets/hydro_training_history.png b/docs/src/assets/hydro_training_history.png new file mode 100644 index 0000000..22252e0 Binary files /dev/null and b/docs/src/assets/hydro_training_history.png differ diff --git a/docs/src/assets/hydro_violation_share.png b/docs/src/assets/hydro_violation_share.png deleted file mode 100644 index 5f1d863..0000000 Binary files a/docs/src/assets/hydro_violation_share.png and /dev/null differ diff --git a/docs/src/assets/hydro_volume_comparison.png b/docs/src/assets/hydro_volume_comparison.png deleted file mode 100644 index 4e0f863..0000000 Binary files a/docs/src/assets/hydro_volume_comparison.png and /dev/null differ diff --git a/docs/src/assets/inventory_integer_results.png b/docs/src/assets/inventory_integer_results.png index 0f26dd2..9b80599 100644 Binary files a/docs/src/assets/inventory_integer_results.png and b/docs/src/assets/inventory_integer_results.png differ diff --git a/docs/src/assets/inventory_relaxed_results.png b/docs/src/assets/inventory_relaxed_results.png index 8a16f85..0556bfa 100644 Binary files a/docs/src/assets/inventory_relaxed_results.png and b/docs/src/assets/inventory_relaxed_results.png differ diff --git a/docs/src/casestudies/battery_storage_opf.md b/docs/src/casestudies/battery_storage_opf.md new file mode 100644 index 0000000..9475b34 --- /dev/null +++ b/docs/src/casestudies/battery_storage_opf.md @@ -0,0 +1,691 @@ +# Stochastic battery-storage AC optimal power flow + +```@meta +CurrentModule = DecisionRules +``` + +This chapter is the canonical specification of the battery-storage case study. +It defines the physical problem, information pattern, target-state formulations, +and comparison protocol. The full network equations are collected in +[Appendix A: AC polar formulation](@ref) and +[Appendix B: SOC-WR relaxation](@ref) so the main text can be read as an +experimental design. + +!!! note "Implementation status" + The deterministic ExaModels ACP foundation and reproducible PGLib battery + generator are implemented in the `BatteryStorageOPF` example of + [DecisionRulesExa.jl](https://github.com/LearningToOptimize/DecisionRulesExa.jl). + The stochastic TS-DDR and JuMP/SDDP implementations must conform to this + specification before they are treated as accepted results. + +## Purpose + +The experiment studies whether a policy trained with the true nonconvex AC +network can outperform an SDDP policy whose backward passes use a convex network +relaxation. The intended mechanism is **locational storage mispricing**: + +1. demand uncertainty moves scarcity between network regions; +2. congestion, losses, voltage constraints, and reactive-power limits make one + MWh of battery energy worth different amounts at different buses; +3. SOC-WR can assign different marginal values to those stored MWh than ACP; +4. the resulting SDDP policy can charge or discharge the wrong batteries even + when its algorithm has converged. + +The final comparison is therefore: + +- SDDP: SOC-WR backward passes and ACP forward simulation; +- TS-DDR: training and evaluation with ACP; +- perfect foresight (PF/WS): full-horizon ACP with the complete demand path known. + +Here **battery SoC** always means state of charge. **SOC-WR** always means the +second-order-cone relaxation in lifted voltage-product space. The abbreviation +“SOC” alone is avoided. + +## One-stage chronology + +At the start of stage ``t``: + +1. the previous battery state ``e_t`` is known; +2. the current demand atom ``\xi_t`` is observed; +3. future atoms ``\xi_{t+1:T}`` remain unknown; +4. the policy produces a target next state ``\hat e_{t+1}``; +5. an operational OPF chooses generation, network flows, charging, discharging, + the two-sided active recourse, and ``e_{t+1}``. + +Thus a nonanticipative policy has the form + +```math +\hat e_{t+1}=\pi_\theta(e_t,\xi_{1:t}), +``` + +implemented with a recurrent encoder. PF alone observes the complete path before +making its first decision. SDDP and TS-DDR receive exactly the same current +observation and state. + +The physical interstage state is the vector of battery energies. Generator +dispatch, voltages, branch flows, charge and discharge powers, and the two-sided active recourse +are stage decisions, not states. + +## Data, units, and reproducible case construction + +The network is an unmodified PGLib-OPF case. The initial public benchmark uses +`case300_ieee`; the same constructor works for every compatible PGLib case. + +All model power quantities are per unit on the case base ``S^{base}`` in MVA: + +| Quantity | Model unit | Physical conversion | +|:--|:--|:--| +| active/reactive power | pu | ``S^{base}`` MW/MVAr | +| apparent-power limit | pu | ``S^{base}`` MVA | +| battery energy | pu·h | ``S^{base}`` MWh | +| stage duration ``\Delta t`` | h | unchanged | +| voltage magnitude | pu | unchanged | +| voltage angle | rad | unchanged | + +Conversion occurs once in the data layer. Component identifiers from PGLib are +never assumed consecutive or equal to array positions. + +The default battery fleet is constructed by: + +1. selecting in-service buses with positive active load; +2. sorting the eligible original bus identifiers; +3. sampling distinct buses without replacement with `StableRNG`; +4. sizing total fleet power as a declared fraction of base active demand; +5. splitting that power equally across batteries; +6. setting energy capacity from the declared duration in hours. + +The manifest records the exact MATPOWER filename and SHA-256, PGLib release and +license, package versions, placement rule and seed, ordered battery buses, every +battery parameter, demand process, horizons, scenario seeds, and hashes. The +source-network hash, ordered placement, and battery parameters are verified on +reconstruction. + +No generator price, generator limit, branch parameter, voltage limit, or network +topology may be changed during the declared candidate ladder. Any future overlay +is a new, separately approved experiment. + +## Demand uncertainty + +Demand is the only exogenous uncertainty in the first experiment. Batteries have +no inflow: they charge by purchasing energy from the grid. + +Each bus is assigned to one of ``R`` deterministic, topology-derived regions. +At stage ``t``, atom ``a_t`` supplies a system factor ``L^{a_t}`` and regional +factors ``R_r^{a_t}``. With deterministic daily shape ``h_t``, + +```math +\begin{aligned} +p^d_{t,i} + &= p^{d,0}_i\,h_t L^{a_t}R_{r(i)}^{a_t},\\ +q^d_{t,i} + &= q^{d,0}_i\,h_t L^{a_t}R_{r(i)}^{a_t}. +\end{aligned} +``` + +The same multiplier is applied to active and reactive demand, preserving the +base power factor at every bus. The finite joint support contains a calm atom +and regional-scarcity atoms, so the location of high demand changes without +changing network data or prices. The initial process is stagewise independent, +which permits ordinary finite-support SDDP backward passes. + +Scenario generation is a pure seeded operation. Training and evaluation use +different seeds. Paired evaluation stores the stage-major atom-index matrix; +every method reads that same matrix rather than regenerating scenarios. + +## Battery model + +For battery ``b`` at stage ``t``, charge and discharge powers are continuous and +nonnegative: + +```math +0\le p^{ch}_{t,b}\le \bar p^{ch}_b,\qquad +0\le p^{dis}_{t,b}\le \bar p^{dis}_b. +``` + +The active injection at its host bus is + +```math +p^{bat}_{t,b}=p^{dis}_{t,b}-p^{ch}_{t,b}. +``` + +The first model uses unity power factor: a battery neither injects nor absorbs +reactive power. Its energy balance is + +```math +e_{t+1,b} +=(1-\sigma_b\Delta t)e_{t,b} ++\eta^{ch}_b\Delta t\,p^{ch}_{t,b} +-\frac{\Delta t}{\eta^{dis}_b}p^{dis}_{t,b}, +``` + +with + +```math +\underline e_b\le e_{t,b}\le\bar e_b. +``` + +Here ``\eta^{ch}_b,\eta^{dis}_b\in(0,1]`` are efficiencies and ``\sigma_b`` is +the hourly self-discharge rate; the data must satisfy +``0\le\sigma_b\Delta t<1``. + +The continuous formulation has no binary charge/discharge mode. A nonnegative +throughput price penalizes +``p^{ch}_{t,b}+p^{dis}_{t,b}``, making simultaneous operation economically +dominated when the remaining costs are well formed. Simultaneous operation must +still be measured and reported; binary mode variables are introduced only if +that audit invalidates the continuous model. + +### One-stage reachable energy + +Ignoring the network but enforcing battery power and energy limits, the reachable +interval from ``e_{t,b}`` is + +```math +\begin{aligned} +\ell_{t,b} +&=\max\left\{\underline e_b,\, + (1-\sigma_b\Delta t)e_{t,b} + -\frac{\Delta t}{\eta^{dis}_b}\bar p^{dis}_b\right\},\\ +u_{t,b} +&=\min\left\{\bar e_b,\, + (1-\sigma_b\Delta t)e_{t,b} + +\eta^{ch}_b\Delta t\,\bar p^{ch}_b\right\}. +\end{aligned} +``` + +These bounds prove battery-dynamic reachability only. They do **not** prove that +the associated charge or discharge is feasible under generator, voltage, +reactive-power, or branch limits. + +## Two-sided active recourse — the complete-recourse slack + +The physical model carries a **two-sided active nodal slack**: a bounded-below, +unbounded-above nonnegative pair at **every** bus, not a fraction of local demand. +For each bus ``i`` and stage ``t``, + +```math +d^{+}_{t,i}\ge 0,\qquad d^{-}_{t,i}\ge 0, +``` + +entering only the **active** balance: + +```math +p^{d}_{t,i}-d^{+}_{t,i}+d^{-}_{t,i}+g^{s}_i v_{t,i}^2 +-\!\!\sum_{g\in i}\! p^{g}_{t,g}-\!\!\sum_{b\in i}\!(p^{dis}_{t,b}-p^{ch}_{t,b}) ++\!\!\sum_{\text{from }i}\! p^{fr}+\!\!\sum_{\text{to }i}\! p^{to}=0 . +``` + +``d^{+}`` (active deficit / injection) covers an active-power **shortfall**; +``d^{-}`` (active surplus / absorption) absorbs an active-power **excess**. Because ``d^{+}`` +can inject and ``d^{-}`` can absorb arbitrary local power, the stage subproblem +has **relatively complete recourse**: it is feasible for every incoming SoC and +every dynamically reachable battery target, in **both** the charging and +discharging directions. A target that forces a battery to *charge* at a +network-constrained bus is served by local ``d^{+}``; a target that forces it to +*discharge* into a bus with saturated outgoing branches is absorbed by local +``d^{-}``. This is the classical multistage load-deficit device that lets any +non-anticipative algorithm converge without hitting an infeasible subproblem. + +The slack is **active-only**: it does not touch reactive power, so reactive KCL +remains a **hard equality** with no reactive slack. Batteries are unity-power- +factor, so the battery target moves only active injection; reactive feasibility +is a property of the base network and the feasible demand process, independent of +the target. + +The value of lost load is ``c^{VOLL}=10{,}000`` USD/MWh, giving stage cost + +```math +C^{shed}_t +=c^{VOLL}S^{base}\Delta t +\sum_i \bigl(d^{+}_{t,i}+d^{-}_{t,i}\bigr). +``` + +Both slacks are included in physical operating cost. They are a safety valve: an +accepted scientific run leaves both at zero within its declared numerical +tolerance. A nonzero deficit or surplus on an otherwise sensible target is a +case-design signal (the target is not network-deliverable at that operating +point)—not a solver failure. **The strict stage always solves**; the cost, not +the solver status, reports whether the target was deliverable. + +### The nodal slack is not target slack + +The two mechanisms have different meanings: + +| Mechanism | Relaxes | Unit | Included in reported physical cost? | +|:--|:--|:--|:--| +| nodal slack ``d^{\pm}`` | active nodal power balance | pu; cost from MWh | yes | +| target slack ``\delta^\pm`` | agreement with policy target | pu·h | no | + +Code, output schemas, and prose use `active_deficit`/`active_surplus` for the +first (``d^{+}``/``d^{-}``) and `target_slack` for the second. The active +recourse is an artificial active-balance device, **not** curtailed customer load: +``d^{+}`` may exceed local demand and may be positive where ``p^d = 0``, so it is +never named "load shedding" nor reported as a per-load fraction. A scientific +candidate path requires **both** directions numerically zero within tolerance. + +## Target-state projection + +The policy outputs the desired outgoing battery energy +``\hat e_{t+1,b}``; the OPF determines whether and how to realize it. + +### Strict mode + +Strict mode adds the hard equality + +```math +\hat e_{t+1,b}-e_{t+1,b}=0. +``` + +It has no target slack and no target penalty. With this orientation, the +equality multiplier is defined and finite-difference tested as + +```math +\lambda_{t,b} +=\frac{\partial Q_t}{\partial\hat e_{t+1,b}}, +``` + +up to the solver interface's documented dual convention. The implementation +must test the sign and magnitude rather than infer them from a convention. + +Strict mode is the **primary, default** production and training target because +its multiplier is an economic shadow price uncontaminated by a penalty. Backed by +the two-sided active nodal slack, strict has **complete recourse**: for every +supported PGLib case and every dynamically reachable target—including the exact +reachable endpoints—the strict stage NLP solves and reproduces the target to +within ``10^{-5}``. Battery reachability alone is not a network-feasibility proof, +but the nodal slack makes the strict solve feasible regardless: an +under-deliverable target simply carries a deficit/surplus cost. + +### Soft diagnostic mode + +Soft mode uses two nonnegative target slacks: + +```math +\hat e_{t+1,b}-e_{t+1,b} +-\delta^+_{t,b}+\delta^-_{t,b}=0,\qquad +\delta^+_{t,b},\delta^-_{t,b}\ge0. +``` + +A documented training-only penalty may combine L1 and L2 terms: + +```math +C^{target}_t +=\rho_1\sum_b(\delta^+_{t,b}+\delta^-_{t,b}) ++\frac{\rho_2}{2}\sum_b +\left[(\delta^+_{t,b})^2+(\delta^-_{t,b})^2\right]. +``` + +Soft mode is for diagnosis, warm starts, and penalty sensitivity studies. Its +penalty is excluded from physical operating cost and final policy comparisons; +target violations are reported separately. + +### Reachable target policy + +For a raw network output ``z_{t,b}``, the normalized output is mapped into the +battery interval: + +```math +\hat e_{t+1,b} +=\ell_{t,b}+(u_{t,b}-\ell_{t,b})\,y_{t,b}. +``` + +The canonical default is the project-tested stretched sigmoid + +```math +y_{t,b} +=\operatorname{clamp}\left( +\frac{\operatorname{sigmoid}(z_{t,b})-0.03}{0.94}, +0,\;1-10^{-3}\right). +``` + +It can reach the lower edge while keeping a small margin below the exact upper +edge, which avoids a known interior-point degeneracy at a store-max strict +target. A separately named `hardsigmoidsafe` activation may be retained as an +option, but must use the same safe upper margin and be tested independently. + +Reachability bounds are physical projection data, not learned functions. The +canonical gradient stops through ``\ell`` and ``u``; gradients flow through the +normalized policy output. Recurrent state is reset at every scenario boundary. + +## Stage objective and cost accounting + +For quadratic generator costs expressed in USD/hour at per-unit dispatch, the +physical stage cost is + +```math +\begin{aligned} +C^{phys}_t +={}&\Delta t\sum_g +\left(c_{2g}(p^g_{t,g})^2+c_{1g}p^g_{t,g}+c_{0g}\right)\\ +&+S^{base}\Delta t\sum_b c^{cycle}_b +\left(p^{ch}_{t,b}+p^{dis}_{t,b}\right) ++C^{shed}_t. +\end{aligned} +``` + +Every term, including ``c_{0g}``, is duration-scaled. The complete training +objective is ``C^{phys}_t+C^{target}_t`` in soft mode and ``C^{phys}_t`` in +strict mode. + +Every result reports at least: + +- generator cost; +- battery throughput cost; +- VOLL nodal-slack cost, deficit and surplus MWh; +- target penalty and target violation, if soft; +- physical operating cost; +- reporting-window and look-ahead physical costs separately. + +No target penalty is mixed into PF, SDDP-ACP, or TS-DDR-ACP operating cost. + +## Horizon and terminal treatment + +The total horizon is + +```math +T=T^{report}+T^{lookahead}. +``` + +Every method optimizes both portions. Statistical comparisons use physical cost +only over stages ``1:T^{report}``; the look-ahead cost and terminal battery SoC +are reported separately. The look-ahead buffer discourages end-of-horizon +depletion without adding a salvage value or terminal target. + +There is no default terminal salvage term or terminal energy constraint. If +either is introduced later, it must be fixed before production and identical in +PF, SDDP, and TS-DDR. + +## Methods + +### TS-DDR + +TS-DDR trains a recurrent policy for next-battery-SoC targets. Each training +sample embeds those targets in ACP projection problems. Strict training uses the +target-constraint multipliers as envelope gradients; soft training additionally +requires the declared target-penalty derivatives. + +Training and evaluation use true ACP. Checkpoints contain model parameters, +normalization, architecture, activation and upper margin, battery/process +manifests, horizon, stage duration, seeds, and source hashes. + +### SDDP + +The SDDP baseline uses the battery SoC as the resource state: + +- backward subproblems use SOC-WR and ordinary stock cuts; +- forward simulations use ACP; +- cuts are rebuilt for each frozen candidate; +- no custom cut acceptance, tolerance ladder, or penalty rewrite is allowed. + +The SDDP bound belongs to the relaxed backward model. It is not the SDDP policy's +ACP operating cost and is not the room available for TS-DDR. + +### Perfect foresight + +For each evaluation path, PF solves the full-horizon ACP after seeing every +demand atom. It provides an information-relaxation benchmark: + +```math +\operatorname{room} +=\frac{\mathbb E[C^{SDDP\text{-}ACP}] +-\mathbb E[C^{PF\text{-}ACP}]} +{\mathbb E[C^{SDDP\text{-}ACP}]}. +``` + +This room is only an upper bound on the improvement a nonanticipative policy +could attain. Because ACP is nonconvex, a locally solved PF model is an empirical +benchmark, not a rigorous mathematical lower bound unless global optimality is +certified. + +## Experimental acceptance + +A candidate proceeds to production only if: + +1. ExaModels and JuMP agree with an independent PowerModels ACP reference on + deterministic cases; +2. battery balances, AC residuals, bounds, and target equations close within + declared tolerances; +3. strict case14 and case300 paths solve (always feasible via the nodal slack) + with zero active deficit and zero active surplus within tolerance; +4. simultaneous charge/discharge is negligible; +5. ACP and SOC-WR assign materially different marginal values to energy at + relevant battery buses, and that difference changes battery behavior; +6. SDDP runs normally with clean ACP forward passes; +7. paired PF room is large enough to justify training. + +Final evaluation uses frozen manifests and the same stored scenario matrix for +all methods. It reports per-path PF, SDDP-ACP, and TS-DDR-ACP physical costs, +paired differences, a 95% confidence interval, solver failures, active recourse +(deficit and surplus), battery trajectories, binding network constraints, runtime, hardware, seeds, +and hashes. Scientific success requires the paired TS-DDR-minus-SDDP mean to be +negative with a 95% paired confidence interval excluding zero. + +## Implementation invariants + +The following are model requirements rather than tunable choices: + +- one shared ACP constraint implementation underlies deterministic, stochastic, + training, and evaluation builders; +- active and reactive demand use the same atom multiplier (power factor preserved); +- reactive balance has no independent slack; +- the active nodal slack is two-sided (deficit ``d^{+}`` and surplus ``d^{-}``), + nonnegative, unbounded above at every bus, and priced at VOLL — it gives the + strict target formulation relatively complete recourse; +- strict and soft target formulations have different variable sets; +- target penalties never enter reported physical cost; +- generator and network data remain the original PGLib values; +- CPU and GPU builders represent the same equations; +- no solver status is relabeled and failed paths are never silently discarded. + +## Appendix A: AC polar formulation + +This appendix states the complete per-stage ACP projection. Time subscripts are +omitted where unambiguous. + +### Sets and voltage variables + +Let ``N`` be buses, ``G_i`` generators at bus ``i``, ``B_i`` batteries at bus +``i``, and ``A_i`` directed branch ends leaving bus ``i``. Complex bus voltage is + +```math +V_i=v_i e^{\mathrm j\theta_i}, +\qquad \underline v_i\le v_i\le\bar v_i. +``` + +One angle is fixed in each connected reference component: + +```math +\theta_i=0,\qquad i\in N^{ref}. +``` + +### Generator limits + +```math +\underline p^g_g\le p^g_g\le\bar p^g_g,\qquad +\underline q^g_g\le q^g_g\le\bar q^g_g. +``` + +The limits and polynomial costs are taken directly from PGLib after the single +per-unit conversion. + +### General branch model + +For branch ``k=(i,j)`` let its pi-model—including series admittance, asymmetric +line charging, complex transformer tap, and phase shift—be represented by + +```math +\begin{bmatrix}I_{ij}\\I_{ji}\end{bmatrix} += +\begin{bmatrix} +Y^{ff}_k & Y^{ft}_k\\ +Y^{tf}_k & Y^{tt}_k +\end{bmatrix} +\begin{bmatrix}V_i\\V_j\end{bmatrix}. +``` + +The two complex branch flows are + +```math +S_{ij}=p_{ij}+\mathrm jq_{ij}=V_i I_{ij}^*,\qquad +S_{ji}=p_{ji}+\mathrm jq_{ji}=V_j I_{ji}^*. +``` + +These equations are the four real ACP branch-flow equalities. They retain +transformer taps and shifts and both end shunts; replacing them with a lossless +or single-ended approximation changes the model. + +For clarity, if ``Y^{ff}=a+\mathrm jb`` and +``Y^{ft}=c+\mathrm jd``, the from-end equations are + +```math +\begin{aligned} +p_{ij} +&=a v_i^2+v_iv_j[c\cos(\theta_i-\theta_j) + +d\sin(\theta_i-\theta_j)],\\ +q_{ij} +&=-b v_i^2+v_iv_j[c\sin(\theta_i-\theta_j) + -d\cos(\theta_i-\theta_j)]. +\end{aligned} +``` + +The to-end equations follow identically from ``Y^{tt}``, ``Y^{tf}``, and +``\theta_j-\theta_i``. + +### Branch limits + +Apparent-power limits are enforced at both ends: + +```math +p_{ij}^2+q_{ij}^2\le(\bar s_k)^2,\qquad +p_{ji}^2+q_{ji}^2\le(\bar s_k)^2. +``` + +Voltage angle differences satisfy + +```math +\underline\theta^\Delta_k +\le\theta_i-\theta_j +\le\bar\theta^\Delta_k. +``` + +An absent PGLib thermal limit adds no artificial finite bound. + +### Nodal power balance + +Let bus shunt admittance be ``Y_i^s=g_i^s+\mathrm jb_i^s``. Using branch flows +directed away from the bus, active and reactive KCL are + +```math +\begin{aligned} +\sum_{g\in G_i}p^g_g ++\sum_{b\in B_i}(p^{dis}_b-p^{ch}_b) +-p^{served}_i-g_i^s v_i^2 +&=\sum_{(i,j,k)\in A_i}p_{ij},\\ +\sum_{g\in G_i}q^g_g +-q^{served}_i+b_i^s v_i^2 +&=\sum_{(i,j,k)\in A_i}q_{ij}. +\end{aligned} +``` + +The battery energy equation, power and energy bounds, two-sided active-recourse +terms, target equation for the selected mode, and stage objective from the main +text complete the model. + +## Appendix B: SOC-WR relaxation + +SOC-WR retains the OPF specification—generation, batteries, demand, two-sided +active recourse, costs, KCL, thermal limits, and target equations—but replaces +the nonconvex voltage representation. + +Define the Hermitian voltage-product matrix + +```math +W=VV^*,\qquad +W_{ii}=w_i,\qquad +W_{ij}=w^R_{ij}+\mathrm jw^I_{ij}. +``` + +Voltage bounds become + +```math +(\underline v_i)^2\le w_i\le(\bar v_i)^2. +``` + +Branch flows are affine in ``W``: + +```math +\begin{aligned} +S_{ij} +&=(Y^{ff}_k)^*W_{ii}+(Y^{ft}_k)^*W_{ij},\\ +S_{ji} +&=(Y^{tt}_k)^*W_{jj}+(Y^{tf}_k)^*W_{ji},\\ +W_{ji}&=W_{ij}^*. +\end{aligned} +``` + +The exact lifted ACP model requires + +```math +(w^R_{ij})^2+(w^I_{ij})^2=w_iw_j +``` + +for every branch, together with globally consistent voltage angles around all +network cycles. SOC-WR relaxes the rank-one equality to + +```math +(w^R_{ij})^2+(w^I_{ij})^2\le w_iw_j, +``` + +which is second-order-cone representable, and does not impose global rank-one +cycle consistency. When the angle-difference interval lies inside +``(-\pi/2,\pi/2)``, its standard lifted form is + +```math +\tan(\underline\theta^\Delta_k)w^R_{ij} +\le w^I_{ij}\le +\tan(\bar\theta^\Delta_k)w^R_{ij}, +``` + +with the corresponding valid-domain conditions and strengthening used by +PowerModels. Apparent-power limits at both ends and nodal KCL are unchanged and +remain convex in the lifted variables. + +The canonical implementation is PowerModels' `SOCWRPowerModel`; independent +hand-written versions must match it on objective, bounds, flows, and storage +marginal values before use. SOC-WR is a relaxation, not an AC-feasible network +model. Its solution must be evaluated by a separate ACP forward solve. + +## Appendix C: symbols and references + +| Symbol | Meaning | +|:--|:--| +| ``p^g,q^g`` | generator active/reactive power | +| ``v,\theta,V`` | voltage magnitude, angle, complex voltage | +| ``p_{ij},q_{ij},S_{ij}`` | directed branch-end power flow | +| ``p^d,q^d`` | realized active/reactive demand | +| ``d^{+},d^{-}`` | two-sided active recourse: deficit / surplus (pu) | +| ``p^{ch},p^{dis}`` | battery charge/discharge power | +| ``e`` | battery energy state | +| ``\hat e`` | policy target for outgoing battery energy | +| ``\delta^+,\delta^-`` | soft target slacks | +| ``\Delta t`` | stage duration in hours | +| ``S^{base}`` | network power base in MVA | +| ``W`` | lifted voltage-product matrix | + +Primary references: + +- C. Coffrin et al., + [“PowerModels.jl: An Open-Source Framework for Exploring Power Flow Formulations”](https://doi.org/10.23919/PSCC.2018.8442948), + PSCC 2018. +- S. Babaeinejadsarookolaee et al., + [“The Power Grid Library for Benchmarking AC Optimal Power Flow Algorithms”](https://doi.org/10.48550/arXiv.1908.02788), + IEEE PES Task Force report. +- R. A. Jabr, + [“Radial Distribution Load Flow Using Conic Programming”](https://doi.org/10.1109/TPWRS.2006.879234), + IEEE Transactions on Power Systems, 2006. +- M. V. F. Pereira and L. M. V. G. Pinto, + [“Multi-stage Stochastic Optimization Applied to Energy Planning”](https://doi.org/10.1007/BF01582895), + Mathematical Programming, 1991. +- A. Rosemberg et al., + [“Efficiently Training Deep-Learning Parametric Policies Using Lagrangian Duality”](https://arxiv.org/abs/2405.14973), + 2024. diff --git a/docs/src/casestudies/hydro/index.md b/docs/src/casestudies/hydro/index.md new file mode 100644 index 0000000..9288eca --- /dev/null +++ b/docs/src/casestudies/hydro/index.md @@ -0,0 +1,67 @@ +# Long-term hydrothermal planning + +```@meta +CurrentModule = DecisionRules +``` + +A hydrothermal power system is operated by deciding, every week for years, how +much water to release and how much fuel to burn. Water is free but finite; fuel +is expensive but available. The whole problem is the price of water — a price +that no market quotes and that has to be inferred from what the water will be +worth later, elsewhere on the network, under inflows nobody has seen yet. + +This case study puts two ways of inferring that price against each other on a +real system, under the full nonconvex AC power flow, on identical inflow +scenarios. + +## The question + +**Stochastic dual dynamic programming** is the standard answer, and a very good +one. It builds an explicit value function from cutting planes. But cuts are only +valid if the stage problem is convex, and AC power flow is not — so in practice +the value of water is computed against a *relaxed* network and then applied to +the real one. + +**TS-DDR** needs no such relaxation. It trains a policy that outputs a target +reservoir level for each stage; the stage problem projects that target onto the +true AC feasible set, and the multiplier of the target constraint *is* the +marginal value of water, handed over by the solver at no extra cost. There is no +value function to build and nothing to convexify. + +So: **can a policy learned this way operate a real system as well as a converged +SDDP policy?** + +## The answer + +Trained from random initialisation in about eleven GPU-hours, and evaluated +against SDDP on 500 shared inflow scenarios under true AC physics: + +| | operating cost | +|---|---| +| SDDP | **313,546** | +| TS-DDR, from scratch | **314,023** | + +A difference of **+0.152%** — statistically unambiguous, practically small, and +in SDDP's favour. Not a tie, and not a win: the [Results](@ref "Results: TS-DDR versus SDDP") page says so in +those words and refuses the three obvious overstatements. + +The interesting part is not the number but the mechanism. The learned policy +**under-hedges**: it carries less water than SDDP, runs cheaper for most of the +horizon, and pays the difference back in the closing weeks when it arrives short. +That is visible stage by stage, in storage, in thermal dispatch, and in the +marginal price of energy — which is what makes the result diagnosable rather +than merely reported. + +## How to read this case study + +| page | what it covers | +|---|---| +| [The problem](@ref "The long-term hydrothermal planning problem") | the planning problem itself: reservoir dynamics, cascades, AC network physics, and why the value of water is both locational and temporal | +| [Valuing water: two approaches](@ref) | how SDDP and TS-DDR each arrive at a price for water, what each assumes, and what is held identical so the comparison is about the methods | +| [Results](@ref "Results: TS-DDR versus SDDP") | the measured comparison, its statistics, the physical mechanism behind the difference, and an honest reading | +| [Walkthrough](@ref "Walkthrough") | a runnable, few-minute version on CPU: build the stage problems, construct the policy, roll out, read the value of water, take some gradient steps | + +Everything needed to reproduce the published numbers — the case, both trained +policies, the evaluation protocol and the figures — ships with +`examples/HydroPowerModels` in this package and its companion, +DecisionRulesExa.jl. Their READMEs carry the commands. diff --git a/docs/src/casestudies/hydro/method.md b/docs/src/casestudies/hydro/method.md new file mode 100644 index 0000000..bd0cd26 --- /dev/null +++ b/docs/src/casestudies/hydro/method.md @@ -0,0 +1,180 @@ +# Valuing water: two approaches + +```@meta +CurrentModule = DecisionRules +``` + +Both methods solve the same planning problem and differ in exactly one respect: +how they decide what stored water is worth. Everything else — the network, the +demand, the inflow scenarios, the cost of shedding load, the horizon, the solver +tolerances, and the requirement that the reported dispatch satisfy the true AC +equations — is held identical, so the measured difference is attributable to the +method rather than to the setup. + +## SDDP: build the value function, but convexify to do it + +Stochastic dual dynamic programming approximates the future cost of leaving +water behind by an outer envelope of cutting planes, refined by sweeping forward +and backward through the horizon. It is the standard method for this problem and +it converges to a genuine lower bound on the cost. + +The bound is only valid if each stage problem is **convex in the incoming +state**, which AC power flow is not. The universal practical compromise, used +here, is to run the backward pass — the one that generates cuts — on a +second-order-cone relaxation of the network, and to simulate the resulting policy +forward on the true AC model. + +That compromise has a price, and naming it is the point of comparing at all. The +value of water is computed against a network that is easier to deliver power +across than the real one. Where the relaxation is loose — meshed corridors, +binding voltage limits, load far from generation — delivery is underpriced, and +storage decisions inherit the mispricing exactly where they matter most. + +Nothing else about the baseline is tuned in TS-DDR's favour or against it: cut +generation is stock SDDP, with no regularisation ladder and no retry-until-optimal +loop that would change which duals become cuts. + +## TS-DDR: skip the value function, read the price off the solver + +TS-DDR trains a policy that emits a **target** reservoir level for each stage. +The stage problem is then solved with the outgoing storage pinned to that target +by a hard equality — no slack, no penalty term. Two things follow. + +First, the dual of that equality is precisely ``\partial Q_t / \partial \hat v_t``: +the marginal value of water, delivered by the solver as a by-product of solving +the stage. There is no value function to construct, and therefore nothing to +convexify. Training and evaluation both use the **true AC model** end to end. + +Second, hard equalities are only well posed if every target the policy emits is +actually attainable in one stage. That is what the reachable policy guarantees: +a network output is mapped into the one-stage reachable interval of each +reservoir, and then clamped down the cascade so a downstream unit can never be +told to hold water that the unit above it did not release. The reachable +interval itself is a property of the water balance and is derived in +[The problem](@ref "One-stage reachable sets"); what matters for training is that +its endpoints depend on the state, and that the derivative has to go through +them. That is the next section. + +## The gradient must flow through the reachable map + +Strict mode makes the stage a projection: the policy emits a target +``\hat v_t`` and the stage problem is solved with ``v_t = \hat v_t`` enforced as +an equality. The multiplier ``\lambda_t`` of that equality is exactly +``\partial Q_t / \partial \hat v_t`` — the marginal value of water, delivered by +the solver at no extra cost. TS-DDR's actor gradient is then + +```math +\nabla_\theta \; \sum_t \bigl\langle \lambda_t,\; \hat v_t(\theta) \bigr\rangle , +``` + +so everything hinges on differentiating the map ``\theta \mapsto \hat v_t`` +**completely**. That map is not just the network and a sigmoid: it is + +```math +\hat v_{r,t} + \;=\; \ell_r(v_{t-1}, w_t) \;+\; + \bigl(u_r(v_{t-1}, w_t) - \ell_r(v_{t-1}, w_t)\bigr)\,\sigma(z_r), +``` + +followed by the cascade clamp. The bounds carry the state, so +``\partial \hat v_t / \partial v_{t-1}`` is nonzero *through them* even when the +network output ``z`` is held fixed — and since ``v_{t-1}`` is itself the previous +stage's target, this term is precisely what couples the stages. + +This is worth spelling out because getting it wrong is silent. Declaring the +bounds non-differentiable still produces a gradient, still trains, and still +reduces the loss; it simply descends a different direction. Measured on this +case over the full horizon: + +| | truncated | complete | +|---|---|---| +| ``\cos(\nabla_{\text{AD}}, \nabla_{\text{FD}})`` | 0.93 | **1.000000** | +| ``\|\nabla_{\text{AD}}\| / \|\nabla_{\text{FD}}\|`` | 0.059 | **1.000000** | +| ``\|\nabla\|`` at the same point | 28,991 | **491,674** | + +The truncated gradient is a 17-times-too-short vector pointing 48 degrees off. +The practical consequence was not a failure to train but a *wrong conclusion +about the method*: with a gradient carrying 6% of the magnitude, raising the +learning rate could not help, and a learning-rate sweep duly reported "learning +rate is not the lever". On the repaired gradient the ordering inverts and the +learning rate becomes the dominant lever. **Verify the complete actor gradient +against finite differences before spending a campaign on hyperparameters.** + +Two properties make the finite-difference check trustworthy here. The map is +piecewise affine in ``z``, so a difference taken across a kink is meaningless; +the check therefore measures the distance to the nearest kink and asserts that +the perturbation stays inside it. And the forward map must be *unchanged* by the +repair — a gradient fix that moves the policy's output is a different policy, so +the forward value is pinned bit-for-bit before the derivative is compared. + +## Training, and why it is staged + +The policy is trained from a random initialisation. Training runs in **phases**, +each a separate process that restarts from the policy the previous phase +selected. A restart is the point, not an artefact: the optimiser state, the +learning-rate schedule and its warm-up all begin again. + +The phases move two knobs in opposite directions: + +| phase | sampling per gradient step | learning rate | role | +|---|---|---|---| +| 1 | low | high | bulk descent — a noisy, cheap gradient is enough to make fast progress | +| 2 | low | high | continued descent from a better initialisation | +| 3 | raised | dropped | convergence — a precise gradient and a small step | + +The rule behind this is worth stating because it generalises: a **small sample +gives a noisy but cheap gradient**, which is what bulk descent wants; a **large +sample gives a precise one**, which is what final convergence wants. Pairing a +large sample with a small learning rate from the start is the flat quadrant — it +buys precision the optimiser cannot yet use and makes almost no progress. + +The schedule is declared as configuration and executed by a driver, so the +published run is reproduced by running the declared schedule rather than by +following a narrative. + +## Selection, and why this is not overfitting + +Learned policies invite a fair suspicion: that the reported number is the best of +many attempts on the data it was chosen with. Three properties of this study are +designed to answer it. + +**Checkpoints are selected on a small fixed panel, never on the training loss.** +The panel is a handful of scenarios with common random numbers, evaluated over +the reported horizon. Two requirements are enforced in code rather than by +convention: the evaluation must be **complete** — a mean over a scenario that +failed to solve is a mean over a different denominator, and no tolerance makes +that comparable — and it must show **no load shedding**. + +**The published claim is measured on a different, much larger protocol** — 500 +paired scenarios that no checkpoint was ever selected against. The selection +panel turns out to have been directionally right and slightly optimistic about +the level, which is what a small screening set should be expected to be, and is +why the claim does not rest on it. + +**The discarded work is reported.** One additional phase was attempted and +produced no selectable policy; it is excluded from the lineage and its cost is +included in the honest accounting of how long the result took. A time-to-policy +figure that quietly omits the attempts that failed is not a time-to-policy +figure. + +## What is held identical + +| | SDDP | TS-DDR | +|---|---|---| +| network, hydro topology, inflow scenarios | same | same | +| demand profile | same | same | +| uncertainty | inflow only | inflow only | +| initial reservoir state | same | same | +| water balance | same | same | +| price of shedding load | same | same | +| reactive balance | hard, no slack | hard, no slack | +| branch limits | apparent power, both ends | apparent power, both ends | +| horizon simulated and reported | same | same | +| evaluation scenarios | the shared paired protocol | the same scenarios | +| **model the dispatch must satisfy** | **true AC** | **true AC** | +| | | | +| model used to *value water* | convex relaxation | true AC | +| how the future enters | cutting planes | a learned target | + +The line in the middle is the whole experiment. Above it, the two are the same +problem; below it, they are two different answers to what water is worth. diff --git a/docs/src/casestudies/hydro/problem.md b/docs/src/casestudies/hydro/problem.md new file mode 100644 index 0000000..b8de6df --- /dev/null +++ b/docs/src/casestudies/hydro/problem.md @@ -0,0 +1,301 @@ +# The long-term hydrothermal planning problem + +```@meta +CurrentModule = DecisionRules +``` + +**Long-term hydrothermal dispatch (LTHD)** is the coordinated operation of +hydro reservoirs and thermal generation on an AC transmission network over +a multi-year horizon under inflow and demand uncertainty — an instance of +the general problem of [Multistage stochastic optimization](@ref) with the +state given by stored water, the uncertainty by river inflows, and the +stage feasibility set by a nonconvex AC optimal power flow. The system the +case study runs on is presented in +[Results](@ref "Results: TS-DDR versus SDDP"); how each policy arrives at a price for water is +[Valuing water: two approaches](@ref); a runnable version is +[Walkthrough](@ref). + +## Stages, state, uncertainty, decisions + +Time is discretized into **weekly stages** ``t = 1, \ldots, T`` (each stage +the case study trains on ``T`` stages spanning several years, and reports over +a shorter window so the reported horizon is free of end-of-horizon effects). At +each stage: + +- **State** — the vector of reservoir volumes + ``x_t = (v_{r,t})_{r \in \mathcal{R}} \in \mathbb{R}^{n_{\mathrm{hyd}}}``, + the only quantity carried between stages. +- **Uncertainty** — the vector of river inflows + ``w_t = (w_{r,t})_{r \in \mathcal{R}}``, revealed at the start of the + stage. Inflows are strongly seasonal and spatially correlated across the + basin, so realizations are drawn as *joint* scenarios (see + [Uncertainty Sampling](@ref)). Demand follows a fixed profile: inflow is the + only uncertainty, which keeps the comparison a statement about how the two + methods value **water**. +- **Decisions** — the stage dispatch ``u_t``: thermal generation + ``p_{g,t}`` (and reactive ``q_{g,t}``), turbined outflow ``q_{r,t}``, + spillage ``s_{r,t}``, load-shedding (deficit) variables, and the AC + power-flow variables (bus voltage magnitudes and angles). + +## Reservoir dynamics and cascades + +Volumes evolve by **water balance**. Rivers form **cascades**: water +released by an upstream plant arrives at its downstream neighbour within +the same weekly stage (travel times are short relative to the stage +length). For each reservoir ``r``, + +```math +v_{r,t} \;=\; v_{r,t-1} + + K \Bigl( w_{r,t} - q_{r,t} + + \sum_{u \in \mathcal{U}_r} q_{u,t} \Bigr) + - s_{r,t} + \sum_{u \in \mathcal{S}_r} s_{u,t}, +\qquad +v_{r,t} \in [\underline{v}_r,\, \overline{v}_r], +``` + +where + +- ``K`` is the **flow-to-volume conversion factor**: the volume accumulated by + a unit flow sustained over one stage. It therefore scales with the stage + duration, which for long-term planning is long — the case study uses weekly + stages — and the whole water balance is proportional to it; +- note that **turbine flow is scaled by ``K`` and spill is not**: inflow and + turbined outflow are rates (m³/s) while spill is already carried as a volume + in this formulation. The asymmetry is HydroPowerModels' convention and is + reproduced exactly by every engine here; +- ``\mathcal{U}_r`` is the set of plants whose **turbined** water feeds + ``r``, and ``\mathcal{S}_r`` the set whose **spilled** water does — the + two sets need not coincide (some diversions bypass the downstream + turbine intake); +- turbine flow and spill obey their own bounds, + ``q_{r,t} \in [\underline{q}_r, \overline{q}_r]`` and + ``s_{r,t} \ge 0``. + +In the Bolivian system three cascade links are active: **COR → SIS** +(turbine-only: only COR's turbined water reaches SIS) and +**ZON → CHU** and **TAQ1 → TAQ2** (turbine *and* spill). COR is the +system's one large seasonal reservoir; SIS, immediately downstream, is a +run-of-river plant with negligible storage, so every hectometre COR +releases is worth SIS's production factor *in addition to* COR's own — +storage decisions at the head of a cascade are leveraged decisions. + +The water balance is the **only intertemporal coupling** in the problem: +water not released this week is available next week. Everything else — +power flow, generation limits — is contained within the stage. + +## Hydro-to-electric coupling + +A hydro plant converts outflow to active power through its +**production factor** ``\rho_r`` (MW per unit of turbined flow): + +```math +p_{r,t} \;=\; \rho_r \, q_{r,t}, +\qquad 0 \le p_{r,t} \le \rho_r\, \overline{q}_r . +``` + +The production factor differs by an order of magnitude across plants +(in the case study from ``\rho = 1.2`` to ``9.7``), which is why *where* +the system stores and releases water matters as much as *how much*: a +hectometre of water is not a fungible commodity but a location- and +plant-specific quantity of energy. + +## Network physics: AC optimal power flow + +Within each stage, the dispatch must satisfy the full **AC power-flow** +equations on the transmission network ``(\mathcal{N}, \mathcal{E})``. In +polar form, with complex voltage ``V_i = |V_i| e^{j\theta_i}`` at bus +``i`` and admittances ``G, B``: + +```math +\begin{aligned} +&\sum_{g \in \mathcal{G}_i} p_{g,t} + \sum_{r \in \mathcal{R}_i} p_{r,t} + - P^{d}_{i,t} + \Delta_{i,t} + = |V_i| \sum_{k} |V_k| \bigl( G_{ik} \cos\theta_{ik} + B_{ik} \sin\theta_{ik} \bigr), + \\[2pt] +&\sum_{g \in \mathcal{G}_i} q_{g,t} - Q^{d}_{i,t} + = |V_i| \sum_{k} |V_k| \bigl( G_{ik} \sin\theta_{ik} - B_{ik} \cos\theta_{ik} \bigr), +\end{aligned} +\qquad \forall i \in \mathcal{N}, +``` + +with ``\theta_{ik} = \theta_i - \theta_k``, together with voltage bands +``|V_i| \in [\underline{V}_i, \overline{V}_i]``, branch thermal (apparent +power) limits, and generator capability bounds. ``P^d_{i,t}, Q^d_{i,t}`` +are the stage-``t`` bus loads and ``\Delta_{i,t} \ge 0`` is the **deficit** +(unserved load) at bus ``i``. + +These equations are **nonconvex** in the voltage variables. That single +fact drives the methodological fork of this case study: the true cost of +delivering power across a stressed network — losses, reactive support, +voltage margin — is a property of this nonconvex set, and any method that +replaces it with a convex surrogate is pricing delivery on a network that +does not quite exist. We write the whole within-stage feasible set +compactly as ``(x_t, u_t) \in \mathcal{F}_t(w_t)``. + +## Stage cost and objective + +The stage cost is thermal fuel plus a penalty on unserved load: + +```math +c_t(x_t, u_t) \;=\; +\sum_{g \in \mathcal{G}} C_g\bigl(p_{g,t}\bigr) +\;+\; C_{\Delta} \sum_{i \in \mathcal{N}} \Delta_{i,t}, +``` + +with ``C_g`` the (convex, typically affine or quadratic) fuel cost of +thermal unit ``g`` and ``C_\Delta`` the deficit cost, set well above the +most expensive generator so that shedding load is always the last resort. +Hydro production itself is free at the stage level — its cost is +*opportunity cost*, visible only through the intertemporal coupling. + +The planning problem is then exactly the general problem of +[Multistage stochastic optimization](@ref): + +```math +\min_{\pi \in \Pi} \;\; +\mathbb{E}_{w_{1:T}} \Bigl[ \sum_{t=1}^{T} c_t\bigl(x_t^\pi, u_t^\pi\bigr) \Bigr] +\quad \text{s.t.} \quad +\text{water balance},\;\; +(x^\pi_t, u^\pi_t) \in \mathcal{F}_t(w_t) \;\; \forall t, +``` + +over nonanticipative policies ``\pi``. + +## Why this is a planning problem: the value of water + +The economics of LTHD are concentrated in one quantity: the marginal +**value of water**, +``-\partial\, \mathbb{E}[V_{t+1}]/\partial v_{r,t}`` — the expected future +fuel cost avoided by holding one more unit of volume in reservoir ``r`` +now. A *myopic* (greedy) operator, minimizing each week in isolation, +implicitly sets this value to zero and fails in three distinct ways: + +1. **Water has a time value.** Free hydro spent to shave this week's fuel + bill is hydro missing at the seasonal demand peak, when its replacement + is the most expensive thermal unit on the system. When the demand peak + falls in the *dry* season — as in the Bolivian case — the mistake is + maximal: the water most tempting to spend is exactly the water that + will be scarcest when needed. +2. **Relief is locational.** Stored hydro relieves network stress only if + it is stored *upstream of the right plants* and released *in the right + weeks*; through the production factors and the cascade topology, the + same volume is worth different energy in different places. A greedy + dispatch cannot see the future congestion it should be positioning + against. +3. **The forecast is a fan.** Each release is committed before the next + inflow is known. A planning policy hedges across the scenario + distribution; a greedy rule effectively bets on a point forecast and + is caught out by dry sequences. + +The case study does not train a greedy baseline — these failure modes are +structural, not empirical claims — but they explain what any competent +method must accomplish: **bank wet-season inflow, carry it across the +network, and release it against the dry-season peak, hedged across +scenarios.** + +## One-stage reachable sets + +A concept used throughout the strict TS-DDR formulation +(see [Strict mode: penalty-free gradient signal](@ref)) is the +**one-stage reachable set** of the water balance: the set of next-stage +volume vectors attainable from state ``x_{t-1}`` under inflow ``w_t`` by +*some* admissible choice of turbine flows and spills, + +```math +R(x_{t-1}, w_t) \;=\; +\Bigl\{ x_t \;:\; \exists\, (q_t, s_t) \in + [\underline{q}, \overline{q}] \times [0, \overline{s}] + \;\text{ s.t. water balance holds and } x_t \in [\underline{v}, \overline{v}] +\Bigr\}. +``` + +Because the water balance is *linear* in ``(q_t, s_t)``, the per-reservoir +reachable set is an interval whose endpoints follow from substituting the +extreme releases — the property that makes penalty-free (strict) training +practical for hydro. + +### Per-unit reachable bounds + +For reservoir ``r`` at state ``v_{r}`` under inflow ``w_{r}``, the highest +attainable next volume corresponds to minimum outflow plus the worst-case +(maximal) upstream contribution, and the lowest to maximum outflow: + +```math +u_r \;=\; \min\Bigl(\overline{v}_r,\; + v_r + K w_r - K \underline{q}_r + + \sum_{u \in \mathcal{U}_r} K \overline{q}_u\Bigr), +\qquad +\ell_r \;=\; \max\bigl(\underline{v}_r,\; + v_r + K w_r - K \overline{q}_r - \overline{s}_r\bigr), +``` + +with ``\overline{s}_r`` the spill bound; when spillage is unbounded, +``\ell_r = \underline{v}_r`` — the reservoir can always be drawn down to its +physical minimum. A policy that must emit attainable targets therefore has a +natural construction available: squash an unconstrained output into this +interval, + +```math +\hat{v}_r \;=\; \ell_r + (u_r - \ell_r)\,\sigma(z_r), +``` + +The bounds ``\ell_r, u_r`` are functions of the incoming state and the realized +inflow, and they **are differentiated**. An earlier implementation declared them +non-differentiable, which silently truncated ``\partial \hat v_r / \partial +v_r`` to the ``\sigma`` term alone; measured against finite differences over the +full 126-stage horizon, that truncated gradient carried 5.9% of the true +magnitude and pointed 48 degrees away from it, and the error compounds with the +horizon. Restoring the path through ``\ell_r`` and ``u_r`` reproduces the finite +difference to `cos = 1.000000` and `‖AD‖/‖FD‖ = 1.000000`. See +[The gradient must flow through the reachable map](@ref). + +### Cascade-aware clamping + +The fixed upstream term ``\sum_u K \overline{q}_u`` in ``u_r`` is an +**overestimate** whenever an upstream unit stores water: its actual release +is then smaller than ``K \overline{q}_u``, so the fixed bound can exceed the +true reachable set and render a strict subproblem infeasible. After +computing the raw sigmoid targets for all units, the policy therefore clamps +downstream targets against the release actually implied upstream. For each +cascade link ``u \to d``, the implied upstream release is + +```math +R_u \;=\; K w_u + v_u - \hat{v}_u , +``` + +and the maximum contribution reaching ``d`` is ``\max(0, R_u)`` for +turbine-plus-spill links and ``\min(K \overline{q}_u,\, \max(0, R_u))`` for +turbine-only links. The downstream target is clamped to + +```math +\hat{v}_d \;\le\; \min\bigl(\overline{v}_d,\; + v_d + K w_d - K \underline{q}_d + \text{max\_contrib}\bigr). +``` + +Two assumptions are documented for this scheme: + +- **Single-level cascades**: the release formula ``R_u`` omits the upstream + unit's own incoming cascade contribution, which is conservative + (underestimates the release) for multi-level chains — and exact for the + Bolivian topology, whose three links are all single-level. +- **The clamp is a real dependence, not a projection.** Where it binds, the + downstream reachable set genuinely moves with the upstream decision — one more + unit released above is one more unit the unit below can hold — and where the + turbine cap binds instead, it does not. Both branches matter to any method that + differentiates through this map; see + [Valuing water: two approaches](@ref "The gradient must flow through the reachable map"). + +With these bounds and clamps, a target chosen inside the interval is reachable in +one stage from the state it was conditioned on — the condition under which a hard +target equality is well posed at all (see +[Validity in every formulation, by induction](@ref)). + +## Further reading + +- Molzahn & Hiskens, *A survey of relaxations and approximations of the + power flow equations*, Foundations and Trends in Electric Energy + Systems (2019) — where and why conic relaxations of AC power flow are + (in)exact. +- Pereira & Pinto, *Multi-stage stochastic optimization applied to energy + planning*, Mathematical Programming 52 (1991) — the origin of SDDP, in + exactly this application domain. diff --git a/docs/src/casestudies/hydro/results.md b/docs/src/casestudies/hydro/results.md new file mode 100644 index 0000000..6602bda --- /dev/null +++ b/docs/src/casestudies/hydro/results.md @@ -0,0 +1,212 @@ +# Results: TS-DDR versus SDDP + +```@meta +CurrentModule = DecisionRules +``` + +The system is the Bolivian national grid — 28 buses, 31 branches, 34 generators +and 11 hydro units in three cascades — operated over weekly stages under the full +AC power-flow equations. + +```@raw html +The Bolivian interconnected system +``` + +Two features of the instance make the planning problem bite. The cascades are +leveraged: water released by the large seasonal reservoir at the head of a chain +is worth its own production factor *plus* that of the run-of-river plant +immediately below it, so where water is stored matters as much as how much. And +the demand peak falls in the **dry** season, so the water most tempting to spend +is exactly the water that will be scarcest when it is needed. + +```@raw html +Seasonal inflow +``` + +Both policies were evaluated on the same 500 inflow scenarios, drawn once and +shared by every engine. Pairing is what makes the comparison decidable: the +spread of cost across scenarios is about 6,000, while the quantity being measured +is a mean difference of about 480. Comparing unpaired distributions of that shape +would need orders of magnitude more scenarios. + +## The comparison + +| policy | mean operating cost | standard deviation | +|---|---|---| +| SDDP | **313,546.09** | 5,925.42 | +| TS-DDR, trained from scratch | **314,023.62** | 5,998.37 | + +Paired difference, TS-DDR − SDDP, over 500 scenarios: + +| | | +|---|---| +| mean | **+477.53** | +| standard error | 16.25 | +| *t* | 29.38 | +| 95% confidence interval | **[+445.60, +509.46]** | +| relative | **+0.152299%**, CI **[+0.142115%, +0.162483%]** | +| scenarios where TS-DDR is cheaper | **29 of 500** | +| load shed, either policy | none | +| scenarios solved | 500 / 500, both | + +Time to policy, from random initialisation on a single GPU: **10.97 hours** +across three phases and 890 gradient updates. A fourth phase was attempted, +produced no selectable policy, and is excluded from the lineage; including its +cost, the whole search took 11.82 hours. + +```@raw html +From-scratch training history +``` + +The training figure keeps three quantities apart on purpose, because they are +routinely conflated. The **stochastic training loss** is one noisy sample per +update, drawn faintly and smoothed over a fixed number of sampled trajectories — +not a fixed number of updates, since the sample size changes between phases and a +fixed-update window would change the curve's noise for reasons unrelated to +learning. The smoothing resets at each restart. The **fixed-panel evaluation** +that actually selects checkpoints lives on its own axis below, because it differs +in horizon, in sampling and in level; plotting the two together invites reading a +dip in a noisy sample as progress. Evaluations that failed to complete are marked +as refused rather than quietly averaged in. + +## What the difference means + +**TS-DDR is more expensive than SDDP here, by a small but statistically +unambiguous margin.** The gap is 0.15% of operating cost. Its significance — +*t* = 29.4 — is a property of the paired design and the sample size, not of the +effect's size: the difference is fifteen times smaller than the standard +deviation of either policy's own cost distribution. + +Three statements would be wrong, and are not made: + +- **not** that the two policies are equal. They are distinguishable, decisively; +- **not** that TS-DDR beat SDDP. It did not, on the mean. It is cheaper on 29 + scenarios and its best case beats SDDP by 1,657, but the confidence interval + excludes zero by a wide margin; +- **not** that 0.15% is negligible. Whether it matters is an operational question + about the system being planned, not a statistical one. + +What can be said is the honest claim, and it is still an interesting one: **a +policy learned from scratch in eleven GPU-hours, with no value function and no +convex relaxation anywhere in its path, operates this system within 0.15% of a +converged SDDP policy that was given a relaxation to build its cuts with.** + +```@raw html +Cost distributions +Paired differences +``` + +The absolute distributions overlap almost completely — which is the point of the +paired design, since the difference between them is far smaller than either one's +spread. The paired differences resolve what the overlay cannot. + +## Where the difference comes from + +The aggregate hides the mechanism. Cumulatively, TS-DDR runs **cheaper** than +SDDP through most of the horizon — by about 1,700 at its widest — and the entire +final difference is incurred in the closing weeks. + +| stage | cumulative Δcost | thermal MW T/S | hydro MW T/S | reservoir 2 storage T/S | +|---|---|---|---|---| +| 1 | −40 | 204.3 / 207.3 | 285.1 / 283.6 | 6.8 / 7.5 | +| 12 | −577 | 208.5 / 211.6 | 280.0 / 277.4 | 102.5 / 104.0 | +| 48 | −860 | 209.8 / 212.7 | 277.6 / 274.8 | 2.6 / 5.8 | +| 62 | −1,689 | 201.9 / 208.4 | 286.3 / 279.6 | 110.5 / 115.7 | +| 90 | −2 | 214.1 / 212.3 | 272.9 / 274.8 | 3.3 / 5.3 | +| 96 | **+478** | 211.8 / 195.3 | 275.7 / 292.6 | 0.2 / 0.4 | + +The policy **under-hedges**. It carries persistently less water than SDDP — +concentrated in the system's large seasonal reservoir — spends it to run cheaper +early, and arrives at the closing weeks short, substituting thermal generation +for hydro exactly when hydro is most valuable. + +```@raw html +Stagewise physical comparison +``` + +The same story appears in the price of energy, and it appears *cyclically* rather +than as a single drift. The difference in marginal cost tracks the reservoir +cycle: TS-DDR prices energy **below** SDDP while the reservoirs are refilling, +and **above** SDDP in the weeks just after each storage peak, when it is drawing +down a stock it did not build as high. + +Every run of at least three consecutive stages of one sign, with its mean +difference — shorter flips are sampling noise on a ten-scenario mean and are not +listed: + +| stages | sign | mean difference | +|---|---|---| +| 1–5 | TS-DDR cheaper | −25.1 | +| 7–15 | TS-DDR cheaper | −33.5 | +| 20–30 | **TS-DDR dearer** | +14.0 | +| 34–39 | TS-DDR cheaper | −11.9 | +| 41–44 | TS-DDR cheaper | −20.0 | +| 46–48 | TS-DDR cheaper | −11.4 | +| 50–59 | TS-DDR cheaper | −38.8 | +| 61–64 | TS-DDR cheaper | −29.7 | +| 65–83 | **TS-DDR dearer** | +10.8 | +| 88–90 | **TS-DDR dearer** | +12.8 | +| 93–96 | **TS-DDR dearer** | +23.5 | + +Reservoir storage peaks near stages 15 and 63, and the two long dear bands open +at 20 and 65 — just after each peak, when the policy is drawing down a stock it +did not build as high. The final band is the largest, and it is where the +cumulative cost difference is actually paid. + +This table is printed by `plot_hydro_results.jl` alongside the figure, so it is +regenerated from the evidence rather than transcribed once. + +The two price *levels* differ by well under a percent and are not distinguishable +by eye, which is why the difference is drawn on its own axis below them rather +than left to the reader to infer from two overlaid curves. + +```@raw html +Marginal cost of energy +``` + +This also means a **short-horizon evaluation would have ranked TS-DDR ahead of +SDDP**. Only the full reported horizon exposes the under-hedge — a good reason to +fix the reporting window before running the comparison rather than after seeing +it. + +## An aside on the initial state + +The reservoirs start empty. This was very nearly "repaired" to a fraction of +capacity, on the assumption that an empty start would force load shedding and +make the comparison vacuous. The assumption was tested and is false: across the +full evaluation the per-bus load-shedding slack sits at its zero bound at every +stage for both policies, within interior-point tolerance and never above it. The +system is operable from empty, so the inputs were left alone. + +It is a small thing, but it is the kind of assumption that quietly becomes a +modelling change if nobody measures it. + +## What transfers + +Stated without pretending these are universal hyperparameters: + +1. **Verify the complete policy gradient against finite differences before a long + run.** A truncated gradient still trains and still lowers the loss; it simply + descends the wrong direction, and every hyperparameter conclusion drawn on top + of it is wrong too. This study cost itself a campaign's worth of conclusions + that way; the correction is + [documented](@ref "The gradient must flow through the reachable map"). +2. **Keep the training signal and the selection signal apart** — different + horizon, different sampling, different level. Select on one of them only. +3. **Select on complete evaluations.** A silently dropped scenario changes the + denominator, and no tolerance makes the result comparable. +4. **Treat restarts as transients.** Raising the learning rate at a restart makes + things worse before better; a stopping rule that does not know this will kill + the phase inside the dip. +5. **Couple the sample size and the learning rate**, and move both. +6. **Finish on one fresh, larger protocol** the policy was never selected on. +7. **Report the discarded work.** + +## Reproducing this + +Both trained policies ship with the packages, so the comparison can be verified +without retraining either one: verify the case, regenerate the stage models, +evaluate both policies on the shared protocol, merge, and plot. Retraining from +scratch runs the declared schedule; retraining the baseline runs SDDP to +convergence. Both take hours. The commands are in the example READMEs of +`DecisionRules.jl` and `DecisionRulesExa.jl`. diff --git a/docs/src/casestudies/hydro/walkthrough.jl b/docs/src/casestudies/hydro/walkthrough.jl new file mode 100644 index 0000000..8d2501f --- /dev/null +++ b/docs/src/casestudies/hydro/walkthrough.jl @@ -0,0 +1,199 @@ +# # Walkthrough +# +# This walkthrough builds the Bolivian hydrothermal planning problem, constructs +# the feasibility-guaranteeing policy that strict TS-DDR needs, and takes a few +# gradient steps — on CPU, in a few minutes, on a horizon short enough to watch. +# +# It is deliberately *not* the published run. That took eleven GPU-hours over 126 +# stages. The point here is that every piece of it is visible in a script you can +# execute, and that the pieces are the ones the result depends on. Where this +# simplifies, it says so. +# +# The case, the numbers and the honest reading of the comparison are in +# [Results](@ref "Results: TS-DDR versus SDDP"); the mathematics is in +# [The long-term hydrothermal planning problem](@ref). + +# ## Setup +# +# Run from `examples/HydroPowerModels`, whose `Project.toml` carries everything +# used below. + +using DecisionRules +using JuMP, DiffOpt, Ipopt +using Flux +using Random +using Statistics + +HYDRO_DIR = joinpath(pkgdir(DecisionRules), "examples", "HydroPowerModels") #hide +nothing #hide + +# ## 1. The system +# +# The case is the Bolivian national grid operated over weekly stages: a +# transmission network with thermal units, and a set of reservoirs linked into +# cascades, driven by historical inflow scenarios. Three files describe it — the +# network, the hydro topology, and the inflows. + +CASE_DIR = joinpath(HYDRO_DIR, "bolivia") + +# ## 2. Build the stage problems +# +# `build_hydropowermodels` reads one serialized stage model per stage — produced +# from the case by `export_subproblem_mof.jl` through HydroPowerModels — and +# re-parameterizes it: the incoming reservoir state becomes a parameter, the +# inflow becomes a parameter, and in **strict** mode the outgoing state is bound +# to a target parameter by a hard equality. +# +# A short horizon keeps this runnable; the published run uses 126. + +include(joinpath(HYDRO_DIR, "load_hydropowermodels.jl")) +include(joinpath(HYDRO_DIR, "hydro_reachable_policy.jl")) + +NUM_STAGES = 3 + +diff_optimizer = () -> DiffOpt.diff_optimizer( + optimizer_with_attributes(Ipopt.Optimizer, "print_level" => 0), +) + +subproblems, state_params_in, state_params_out, uncertainty_samples, + initial_volumes, max_volume, hydro_meta = build_hydropowermodels( + CASE_DIR, "ACPPowerModel.mof.json"; + num_stages = NUM_STAGES, optimizer = diff_optimizer, strict = true, +) + +(stages = length(subproblems), reservoirs = hydro_meta.nHyd, + inflow_scenarios = length(uncertainty_samples[1]), K = hydro_meta.K) + +# In strict mode there are **no slack variables on the target** and no penalty +# term. The dual of `reservoir_out == target` is therefore the clean marginal +# value of water, ``\partial Q_t / \partial \hat v_t``, with no penalty noise +# mixed into it. That is the entire reason strict mode exists. +# +# It is only well posed if every target the policy emits is reachable in one +# stage — otherwise the equality makes the stage infeasible. Hence the policy. + +# ## 3. The reachable policy +# +# `hydro_reachable_policy` maps an unconstrained network output into the +# one-stage reachable interval of each reservoir, +# +# ```math +# \hat v_r \;=\; \ell_r(v, w) + \bigl(u_r(v, w) - \ell_r(v, w)\bigr)\,\sigma(z_r), +# ``` +# +# and then applies a cascade clamp, so a downstream target can never assume more +# water than the upstream unit actually released. +# +# Two details carry the published result: +# +# * the activation is a **stretched** sigmoid onto `[0, 1 - 1e-3]`, not a plain +# one. A plain sigmoid cannot attain the ends of the interval, and the good +# policy on this case puts a substantial share of its targets exactly at a +# feasibility extreme; +# * the bounds ``\ell_r, u_r`` depend on the incoming state, and that dependence +# **is differentiated**. Treating it as constant still trains and still lowers +# the loss, while descending a direction 48 degrees off the true gradient. + +Random.seed!(42) +policy = hydro_reachable_policy(hydro_meta, [128, 128]; combiner_layers = [256, 256]) +nothing #hide + +# The encoder is an LSTM over the **inflow** sequence only; the reservoir state +# enters through the state-conditioned head, not through the recurrence. + +# ## 4. One rollout +# +# A rollout threads the realized state: the policy sees the state it actually +# reached, emits a target, the stage problem projects that target onto the +# feasible set, and the realized outgoing state becomes the next stage's input. + +# Written as a function rather than a bare loop: at top level (and inside a +# documentation `@example` block) a `for` introduces its own scope, so a +# loop-carried `total_cost += ...` would fail with `UndefVarError`. This is a +# recurring Julia trap in exactly this kind of script. + +function rollout(policy, scenario) + state = Float64.(initial_volumes) + total = 0.0 + for t in 1:NUM_STAGES + for (j, param) in enumerate(state_params_in[t]) + set_parameter_value(param, state[j]) + end + for (param, val) in scenario[t] + set_parameter_value(param, val) + end + + w = Float32.([val for (_, val) in scenario[t]]) + target = policy(vcat(w, Float32.(state))) + for j in 1:hydro_meta.nHyd + set_parameter_value(state_params_out[t][j][1], Float64(target[j])) + end + + optimize!(subproblems[t]) + @assert termination_status(subproblems[t]) in + (MOI.LOCALLY_SOLVED, MOI.OPTIMAL, MOI.ALMOST_LOCALLY_SOLVED) + total += objective_value(subproblems[t]) + + for j in 1:hydro_meta.nHyd + state[j] = value(state_params_out[t][j][2]) + end + end + return total, state +end + +scenario = [uncertainty_samples[t][1] for t in 1:NUM_STAGES] +total_cost, final_state = rollout(policy, scenario) +total_cost + +# Every stage solved, from an untrained policy: the reachable map did its job and +# no emitted target was infeasible. That property is what makes hard target +# equalities usable at all. + +# ## 5. The marginal value of water +# +# The multiplier of the target equality is what TS-DDR differentiates, and it +# comes straight off the solved stage — no extra machinery: + +lambda = [DecisionRules.pdual(state_params_out[NUM_STAGES][j][1]) + for j in 1:hydro_meta.nHyd] +round.(lambda; digits = 3) + +# A negative entry means holding one more unit in that reservoir *lowers* future +# cost — water has value there. The spread across reservoirs is the locational +# content that the production factors and the cascade topology create: a cubic +# metre of water is not a fungible commodity. + +# ## 6. A few training steps +# +# `train_multistage` assembles the loop: sample a scenario, roll out, collect the +# multipliers, backpropagate through the policy, step the optimizer. Three +# iterations here; the published run took 890 across three restarted stages. + +# `uncertainty_samples` is passed DIRECTLY: `DecisionRules.sample` has an +# overload for it that draws one inflow scenario per stage, which is exactly the +# per-stage joint sampling this case needs. + +DecisionRules.train_multistage( + policy, initial_volumes, subproblems, + state_params_in, state_params_out, uncertainty_samples; + num_train_per_batch = 2, + num_batches = 3, + optimizer = Flux.Adam(1e-3), +) + +# Three updates on three stages will not produce a good policy, and the number +# above is not meaningful on its own — it is one noisy sample of a stochastic +# objective, and the trap this case study keeps returning to: the training loss, +# the training objective and the fixed-panel evaluation are three different +# quantities, and only the last one selects a policy. + +# ## Where to go from here +# +# The published run is the same construction at full scale — a longer horizon, +# a training schedule of several phases, and a GPU. How each method arrives at a +# price for water is [Valuing water: two approaches](@ref); what the comparison +# measured, and what it does and does not say, is [Results](@ref "Results: TS-DDR versus SDDP"). +# +# To actually run it, the example READMEs of `DecisionRules.jl` and +# `DecisionRulesExa.jl` carry the commands, from verifying the case through to +# regenerating the figures. diff --git a/docs/src/casestudies/hydro/walkthrough.md b/docs/src/casestudies/hydro/walkthrough.md new file mode 100644 index 0000000..e9b99a5 --- /dev/null +++ b/docs/src/casestudies/hydro/walkthrough.md @@ -0,0 +1,218 @@ +```@meta +EditURL = "walkthrough.jl" +``` + +# Walkthrough + +This walkthrough builds the Bolivian hydrothermal planning problem, constructs +the feasibility-guaranteeing policy that strict TS-DDR needs, and takes a few +gradient steps — on CPU, in a few minutes, on a horizon short enough to watch. + +It is deliberately *not* the published run. That took eleven GPU-hours over 126 +stages. The point here is that every piece of it is visible in a script you can +execute, and that the pieces are the ones the result depends on. Where this +simplifies, it says so. + +The case, the numbers and the honest reading of the comparison are in +[Results](@ref "Results: TS-DDR versus SDDP"); the mathematics is in +[The long-term hydrothermal planning problem](@ref). + +## Setup + +Run from `examples/HydroPowerModels`, whose `Project.toml` carries everything +used below. + +````@example walkthrough +using DecisionRules +using JuMP, DiffOpt, Ipopt +using Flux +using Random +using Statistics + +HYDRO_DIR = joinpath(pkgdir(DecisionRules), "examples", "HydroPowerModels") #hide +nothing #hide +```` + +## 1. The system + +The case is the Bolivian national grid operated over weekly stages: a +transmission network with thermal units, and a set of reservoirs linked into +cascades, driven by historical inflow scenarios. Three files describe it — the +network, the hydro topology, and the inflows. + +````@example walkthrough +CASE_DIR = joinpath(HYDRO_DIR, "bolivia") +```` + +## 2. Build the stage problems + +`build_hydropowermodels` reads one serialized stage model per stage — produced +from the case by `export_subproblem_mof.jl` through HydroPowerModels — and +re-parameterizes it: the incoming reservoir state becomes a parameter, the +inflow becomes a parameter, and in **strict** mode the outgoing state is bound +to a target parameter by a hard equality. + +A short horizon keeps this runnable; the published run uses 126. + +````@example walkthrough +include(joinpath(HYDRO_DIR, "load_hydropowermodels.jl")) +include(joinpath(HYDRO_DIR, "hydro_reachable_policy.jl")) + +NUM_STAGES = 3 + +diff_optimizer = () -> DiffOpt.diff_optimizer( + optimizer_with_attributes(Ipopt.Optimizer, "print_level" => 0), +) + +subproblems, state_params_in, state_params_out, uncertainty_samples, + initial_volumes, max_volume, hydro_meta = build_hydropowermodels( + CASE_DIR, "ACPPowerModel.mof.json"; + num_stages = NUM_STAGES, optimizer = diff_optimizer, strict = true, +) + +(stages = length(subproblems), reservoirs = hydro_meta.nHyd, + inflow_scenarios = length(uncertainty_samples[1]), K = hydro_meta.K) +```` + +In strict mode there are **no slack variables on the target** and no penalty +term. The dual of `reservoir_out == target` is therefore the clean marginal +value of water, ``\partial Q_t / \partial \hat v_t``, with no penalty noise +mixed into it. That is the entire reason strict mode exists. + +It is only well posed if every target the policy emits is reachable in one +stage — otherwise the equality makes the stage infeasible. Hence the policy. + +## 3. The reachable policy + +`hydro_reachable_policy` maps an unconstrained network output into the +one-stage reachable interval of each reservoir, + +```math +\hat v_r \;=\; \ell_r(v, w) + \bigl(u_r(v, w) - \ell_r(v, w)\bigr)\,\sigma(z_r), +``` + +and then applies a cascade clamp, so a downstream target can never assume more +water than the upstream unit actually released. + +Two details carry the published result: + +* the activation is a **stretched** sigmoid onto `[0, 1 - 1e-3]`, not a plain + one. A plain sigmoid cannot attain the ends of the interval, and the good + policy on this case puts a substantial share of its targets exactly at a + feasibility extreme; +* the bounds ``\ell_r, u_r`` depend on the incoming state, and that dependence + **is differentiated**. Treating it as constant still trains and still lowers + the loss, while descending a direction 48 degrees off the true gradient. + +````@example walkthrough +Random.seed!(42) +policy = hydro_reachable_policy(hydro_meta, [128, 128]; combiner_layers = [256, 256]) +nothing #hide +```` + +The encoder is an LSTM over the **inflow** sequence only; the reservoir state +enters through the state-conditioned head, not through the recurrence. + +## 4. One rollout + +A rollout threads the realized state: the policy sees the state it actually +reached, emits a target, the stage problem projects that target onto the +feasible set, and the realized outgoing state becomes the next stage's input. + +Written as a function rather than a bare loop: at top level (and inside a +documentation `@example` block) a `for` introduces its own scope, so a +loop-carried `total_cost += ...` would fail with `UndefVarError`. This is a +recurring Julia trap in exactly this kind of script. + +````@example walkthrough +function rollout(policy, scenario) + state = Float64.(initial_volumes) + total = 0.0 + for t in 1:NUM_STAGES + for (j, param) in enumerate(state_params_in[t]) + set_parameter_value(param, state[j]) + end + for (param, val) in scenario[t] + set_parameter_value(param, val) + end + + w = Float32.([val for (_, val) in scenario[t]]) + target = policy(vcat(w, Float32.(state))) + for j in 1:hydro_meta.nHyd + set_parameter_value(state_params_out[t][j][1], Float64(target[j])) + end + + optimize!(subproblems[t]) + @assert termination_status(subproblems[t]) in + (MOI.LOCALLY_SOLVED, MOI.OPTIMAL, MOI.ALMOST_LOCALLY_SOLVED) + total += objective_value(subproblems[t]) + + for j in 1:hydro_meta.nHyd + state[j] = value(state_params_out[t][j][2]) + end + end + return total, state +end + +scenario = [uncertainty_samples[t][1] for t in 1:NUM_STAGES] +total_cost, final_state = rollout(policy, scenario) +total_cost +```` + +Every stage solved, from an untrained policy: the reachable map did its job and +no emitted target was infeasible. That property is what makes hard target +equalities usable at all. + +## 5. The marginal value of water + +The multiplier of the target equality is what TS-DDR differentiates, and it +comes straight off the solved stage — no extra machinery: + +````@example walkthrough +lambda = [DecisionRules.pdual(state_params_out[NUM_STAGES][j][1]) + for j in 1:hydro_meta.nHyd] +round.(lambda; digits = 3) +```` + +A negative entry means holding one more unit in that reservoir *lowers* future +cost — water has value there. The spread across reservoirs is the locational +content that the production factors and the cascade topology create: a cubic +metre of water is not a fungible commodity. + +## 6. A few training steps + +`train_multistage` assembles the loop: sample a scenario, roll out, collect the +multipliers, backpropagate through the policy, step the optimizer. Three +iterations here; the published run took 890 across three restarted stages. + +`uncertainty_samples` is passed DIRECTLY: `DecisionRules.sample` has an +overload for it that draws one inflow scenario per stage, which is exactly the +per-stage joint sampling this case needs. + +````@example walkthrough +DecisionRules.train_multistage( + policy, initial_volumes, subproblems, + state_params_in, state_params_out, uncertainty_samples; + num_train_per_batch = 2, + num_batches = 3, + optimizer = Flux.Adam(1e-3), +) +```` + +Three updates on three stages will not produce a good policy, and the number +above is not meaningful on its own — it is one noisy sample of a stochastic +objective, and the trap this case study keeps returning to: the training loss, +the training objective and the fixed-panel evaluation are three different +quantities, and only the last one selects a policy. + +## Where to go from here + +The published run is the same construction at full scale — a longer horizon, +a training schedule of several phases, and a GPU. How each method arrives at a +price for water is [Valuing water: two approaches](@ref); what the comparison +measured, and what it does and does not say, is [Results](@ref "Results: TS-DDR versus SDDP"). + +To actually run it, the example READMEs of `DecisionRules.jl` and +`DecisionRulesExa.jl` carry the commands, from verifying the case through to +regenerating the figures. + diff --git a/docs/src/examples/hydro.jl b/docs/src/examples/hydro.jl deleted file mode 100644 index e7bf3fd..0000000 --- a/docs/src/examples/hydro.jl +++ /dev/null @@ -1,481 +0,0 @@ -# # Hydropower Scheduling -# -# This example trains target-setting decision rules for the Bolivia -# long-term hydrothermal dispatch (LTHD) problem — both **TS-DDR** (deep, -# LSTM-based) and **TS-LDR** (linear) — and compares them against an SDDP -# baseline with inconsistent formulations. -# -# The Bolivia system has **10 hydro plants**, **96 monthly stages**, and -# **AC power flow** constraints. Inflow uncertainty is sampled from 47 -# historical scenarios. -# -# ## Overview of the TS-DDR approach -# -# Classical stochastic programming (e.g., SDDP) constructs piecewise-linear -# value-function approximations. TS-DDR takes a different route: a neural -# network policy ``\pi_\theta`` maps observations to **target states**, and a -# projection subproblem at each stage enforces physical feasibility while -# tracking those targets as closely as possible. -# -# The key insight is that the gradient of the projection subproblem with -# respect to the target parameters is available through Lagrange duality -# (or equivalently, implicit differentiation of the KKT conditions). -# This avoids differentiating through the full optimization solver. -# -# ## Problem formulation -# -# At each stage ``t``, the operator observes inflows ``w_t`` and the current -# reservoir state ``x_{t-1}``. The policy predicts target volumes: -# -# ```math -# \hat{x}_t = \pi_\theta(w_{1:t},\, x_{t-1}). -# ``` -# -# A stage subproblem projects onto the feasible set: -# -# ```math -# \begin{aligned} -# q_t(x_{t-1},\, w_t;\; \hat{x}_t) -# \;=\; -# \min_{x_t, u_t, \delta_t} -# \quad & -# c_t(x_t, u_t) + C_\delta\, \|\delta_t\| \\ -# \text{s.t.}\quad -# & x_t = x_{t-1} + w_t - \text{turbined}_t - \text{spilled}_t, -# && \text{(reservoir balance)} \\ -# & x_t + \delta_t = \hat{x}_t, -# && : \lambda_t \quad \text{(target constraint)} \\ -# & \text{AC-OPF}(u_t), -# && \text{(power flow)} \\ -# & x_t \in [0, \bar{x}],\; u_t \ge 0. -# \end{aligned} -# ``` -# -# The slack variable ``\delta_t`` absorbs infeasible targets; ``\lambda_t`` is -# the dual multiplier that provides the gradient signal. -# -# ## Gradient computation: the envelope theorem -# -# By the envelope theorem, the sensitivity of the optimal value with respect -# to the target parameter is simply the dual: -# -# ```math -# \frac{\partial q_t}{\partial \hat{x}_t} -# \;=\; -\lambda_t. -# ``` -# -# Combined with backpropagation through the policy network, the full gradient -# of the expected cost is: -# -# ```math -# \nabla_\theta \mathbb{E}[Q] -# \;\approx\; -# \frac{1}{S} \sum_{s=1}^{S} \sum_{t=1}^{T} -# \lambda_t^s \odot \nabla_\theta \hat{x}_t^s(\theta), -# ``` -# -# where ``S`` is the number of sampled trajectories per batch and ``\odot`` -# denotes elementwise multiplication. - -# ## Problem setup -# -# The JuMP subproblems are built from a MOF file (exported from PowerModels.jl) -# plus hydro data (reservoir limits, inflow scenarios). Each subproblem contains: -# - AC optimal power flow constraints -# - Reservoir balance: `vol_out = vol_in + inflow - turbined - spilled` -# - Target-slack deficit variables penalizing deviation from the policy's targets -# -# The helper `build_hydropowermodels` reads the case data, creates one JuMP model -# per stage, and parameterizes the initial volumes and inflows so they can be set -# at each training sample. - -using DecisionRules -using JuMP, DiffOpt, Ipopt -using Flux -using Statistics, Random - -# Load the problem builder (reads MOF + hydro JSON + inflow CSV). -# -# ```julia -# include("load_hydropowermodels.jl") -# ``` - -# ## Building the stage-wise subproblems -# -# Each subproblem is wrapped with `DiffOpt.diff_optimizer` so that Lagrange duals -# and implicit sensitivities are available for training. - -# ```julia -# diff_optimizer = () -> DiffOpt.diff_optimizer( -# optimizer_with_attributes(Ipopt.Optimizer, "print_level" => 0, "linear_solver" => "mumps") -# ) -# -# subproblems, state_params_in, state_params_out, uncertainty_samples, initial_state, max_volume = -# build_hydropowermodels( -# "bolivia", "ACPPowerModel.mof.json"; -# num_stages=96, -# optimizer=diff_optimizer, -# penalty_l1=:auto, penalty_l2=:auto, -# ) -# ``` - -# ## Policy architecture -# -# The policy is a [`StateConditionedPolicy`](@ref) with two components: -# -# 1. **Encoder** — a stack of LSTM cells that processes only the uncertainty -# (inflow) sequence, capturing temporal dependencies across stages. -# 2. **Combiner** — a Dense layer that merges the encoded uncertainty with the -# previous state to produce the next target. -# -# At each stage the policy receives ``[w_t;\; x_{t-1}]`` and outputs -# target reservoir volumes ``\hat{x}_t``: -# -# ``` -# ┌─────────┐ ┌────────────────┐ ┌──────────────┐ -# │ w_t │─────▶│ LSTM encoder │─────▶│ │ -# └─────────┘ └────────────────┘ │ Dense │──▶ x̂_t -# ┌─────────┐ │ combiner │ -# │ x_{t-1} │─────────────────────────────▶│ │ -# └─────────┘ └──────────────┘ -# ``` -# -# The LSTM carries hidden state across stages, giving the policy memory of -# past inflows. The activation is `sigmoid` (bounding outputs to ``[0,1]``, -# which is then scaled by the feasibility mapping). - -# ```julia -# models = state_conditioned_policy( -# num_uncertainties, num_hydro, num_hydro, [128, 128]; -# activation=sigmoid, encoder_type=Flux.LSTM, -# ) -# ``` - -# ## TS-LDR: Linear Decision Rules -# -# As a baseline, we also train a **linear** policy (TS-LDR). This uses -# `dense_multilayer_nn` with identity activation — a composition of linear -# layers equivalent to a single affine map: -# -# ```math -# \hat{x}_t = W [w_{1:t};\; x_{t-1}] + b. -# ``` -# -# TS-LDR uses the same target-setting framework and training pipeline as -# TS-DDR. The only difference is the policy class: linear maps have fewer -# parameters and cannot capture nonlinear inflow patterns, but they are a -# natural baseline from the classical LDR literature. - -# ```julia -# num_inputs = DecisionRules.policy_input_dim(num_uncertainties, num_hydro) -# models = dense_multilayer_nn(num_inputs, num_hydro, [64, 64]; activation=identity) -# ``` - -# ## Training pipeline 1: Deterministic Equivalent -# -# The deterministic equivalent (DE) couples all 96 stages into a **single NLP** -# for each sampled trajectory. This is the most direct formulation: the policy -# generates the full target trajectory ``\hat{x}_{1:T}`` in one forward pass, -# and a single coupled solve determines all realized states simultaneously. -# -# ### How it works -# -# ``` -# ┌──────────────────────────────────────────────────────────┐ -# │ For each sampled trajectory w_{1:T}: │ -# │ │ -# │ 1. Forward pass: x̂_{1:T} = π_θ(w_{1:T}, x_0) │ -# │ │ -# │ 2. Solve coupled NLP: │ -# │ min Σ_t c_t(x_t, u_t) + C_δ Σ_t ‖δ_t‖ │ -# │ s.t. dynamics + AC-OPF for ALL stages simultaneously │ -# │ x_t + δ_t = x̂_t(θ) ∀t (target constraint) │ -# │ │ -# │ 3. Read duals λ_t of target constraints │ -# │ Gradient: Σ_t λ_t ⊙ ∇_θ x̂_t(θ) │ -# └──────────────────────────────────────────────────────────┘ -# ``` -# -# ### Mathematical formulation -# -# ```math -# \begin{aligned} -# Q(w;\, \theta) -# \;=\; -# \min_{\{x_t, u_t, \delta_t\}_{t=1}^{T}} -# \quad & -# \sum_{t=1}^{T} c_t(x_t, u_t) -# + C_\delta \sum_{t=1}^{T} \|\delta_t\| \\ -# \text{s.t.}\quad -# & x_t = T_t(w_t,\, u_t,\, x_{t-1}), -# && t=1,\ldots,T \\ -# & x_t + \delta_t = \hat{x}_t(\theta), -# && : \lambda_t,\quad t=1,\ldots,T \\ -# & h_t(x_t, u_t) \ge 0, -# && t=1,\ldots,T -# \end{aligned} -# ``` -# -# The gradient is exact by the envelope theorem: -# -# ```math -# \nabla_\theta Q -# \;=\; -# \sum_{t=1}^{T} -# \lambda_t \odot \nabla_\theta \hat{x}_t(\theta). -# ``` -# -# **Advantages**: strongest gradient signal — full cross-stage coupling -# captures how a target at stage 3 affects costs at stage 50. -# -# **Disadvantage**: the NLP has ``96 \times (\text{AC-OPF variables})`` -# decision variables; the policy generates targets without seeing realized -# states (open-loop target generation). - -# ```julia -# det_equivalent, uncertainty_samples_det = DecisionRules.deterministic_equivalent!( -# det_model, subproblems_de, state_params_in, state_params_out, -# Float64.(initial_state), uncertainty_samples, -# ) -# -# train_multistage( -# models, initial_state, det_equivalent, -# state_params_in, state_params_out, uncertainty_samples; -# num_batches=4000, optimizer=Flux.Adam(), -# penalty_schedule=[(1,100,0.1), (101,210,1.0), (211,300,10.0), (301,4000,30.0)], -# ) -# ``` - -# ## Training pipeline 2: Stage-wise Decomposition (Single Shooting) -# -# Stage-wise decomposition solves one subproblem per stage sequentially. -# Unlike the DE, the policy operates in **closed loop**: after each stage -# solve, the realized state ``x_t`` (not the predicted target) is fed back -# as input to the next stage. -# -# ### How it works -# -# ``` -# ┌─────────────────────────────────────────────────────────────┐ -# │ For each sampled trajectory w_{1:T}: │ -# │ │ -# │ x_0 = initial state │ -# │ for t = 1, ..., T: │ -# │ x̂_t = π_θ(w_t, x_{t-1}) ← predict target │ -# │ solve stage-t subproblem ← project to feasible│ -# │ x_t = realized state from solver ← closed-loop │ -# │ accumulate c_t + C_δ ‖δ_t‖ │ -# │ │ -# │ Gradient: chain rule through all stage solves │ -# └─────────────────────────────────────────────────────────────┘ -# ``` -# -# ### Gradient chain -# -# The gradient must account for how the realized state at stage ``t`` -# depends on the targets at all earlier stages. By the chain rule: -# -# ```math -# \frac{\partial Q}{\partial \hat{x}_t} -# \;=\; -# \lambda_t -# + \sum_{k>t} -# \frac{\partial q_k}{\partial x_{k-1}} -# \cdot \prod_{j=t+1}^{k-1} -# \frac{\partial x_j}{\partial x_{j-1}} -# \cdot \frac{\partial x_t}{\partial \hat{x}_t}. -# ``` -# -# In practice, automatic differentiation (Zygote + ChainRules `rrule`s -# defined on each stage solve) handles this chain automatically. -# The `rrule` for each stage solve reads the dual ``\lambda_t`` for the -# target constraint and uses DiffOpt's implicit differentiation for the -# state-transition sensitivities. -# -# **Advantages**: closed-loop — the policy sees realized states, matching -# deployment semantics. Each solve is small (single-stage AC-OPF). -# -# **Disadvantage**: gradients weaken over long horizons because the -# chain rule multiplies many Jacobians; sequential solve prevents -# parallelism. - -# ```julia -# train_multistage( -# models, initial_state, subproblems, -# state_params_in, state_params_out, uncertainty_samples; -# num_batches=3000, optimizer=Flux.Adam(), -# penalty_schedule=:default_annealed, -# ) -# ``` - -# ## Training pipeline 3: Multiple Shooting -# -# Multiple shooting partitions the ``T``-stage horizon into ``K`` windows of -# ``W`` stages each. Within each window, a local deterministic equivalent -# couples the stages (strong gradient signal). Between windows, the realized -# end-state is passed to the next window (closed-loop continuity). -# -# ### How it works -# -# ``` -# ┌────────────────────────────────────────────────────────────────┐ -# │ Partition T=96 stages into K=⌈96/12⌉=8 windows of W=12 │ -# │ │ -# │ x_0 = initial state │ -# │ for k = 1, ..., K: │ -# │ stages = [(k-1)W+1, ..., kW] │ -# │ x̂_{stages} = π_θ(w_{stages}, x_{start_k}) │ -# │ solve window-k DE (12-stage coupled NLP) │ -# │ x_{end_k} = realized end-state from window solve │ -# │ x_{start_{k+1}} = x_{end_k} │ -# │ │ -# │ Gradient: │ -# │ Within window: duals from the coupled solve (like full DE) │ -# │ Across windows: DiffOpt chain rule through end-states │ -# └────────────────────────────────────────────────────────────────┘ -# ``` -# -# ### Gradient structure -# -# Let ``Q_k`` be the cost of window ``k``. The total cost is -# ``Q = \sum_k Q_k``. Within a window, the gradient is identical to the -# DE case (duals of the target constraints in the coupled model). Across -# windows, the chain rule threads through the realized end-state: -# -# ```math -# \frac{dQ}{d\theta} -# \;=\; -# \sum_{k=1}^{K} -# \left( -# \frac{\partial Q_k}{\partial \hat{x}_k} -# \cdot \frac{\partial \hat{x}_k}{\partial \theta} -# \;+\; -# \frac{\partial Q_k}{\partial x_{\text{start}_k}} -# \cdot \frac{d x_{\text{start}_k}}{d\theta} -# \right), -# ``` -# -# where ``\frac{d x_{\text{start}_k}}{d\theta}`` involves the chain -# through all prior windows via ``x_{\text{end}_{k-1}}``. -# -# **Advantages**: balances gradient quality (12-stage coupling) with -# tractability (8 small DEs instead of one large one); inter-window -# chain provides some closed-loop signal. -# -# **Disadvantage**: window boundaries introduce gradient discontinuities; -# the full-horizon coupling is weaker than the single DE. - -# ```julia -# windows = DecisionRules.setup_shooting_windows( -# subproblems, state_params_in, state_params_out, -# Float64.(initial_state), uncertainty_samples; -# window_size=12, -# model_factory=() -> DiffOpt.nonlinear_diff_model(ipopt_attrs), -# ) -# -# train_multiple_shooting( -# models, initial_state, windows, () -> uncertainty_samples; -# num_batches=3000, optimizer=Flux.Adam(), -# penalty_schedule=:default_annealed, -# ) -# ``` - -# ## Penalty annealing -# -# The target penalty ``C_\delta`` controls the trade-off between following -# the policy's targets and minimizing operational cost. DecisionRules -# supports a **penalty annealing schedule** that ramps the penalty multiplier -# during training: -# -# | Phase | Multiplier | Purpose | -# |:------|:----------:|:--------| -# | Warmup | ``0.1 \times C_\delta`` | Let the policy explore freely | -# | Nominal | ``1.0 \times C_\delta`` | Standard training | -# | Tighten | ``10.0 \times C_\delta`` | Sharpen target tracking | -# | Lock | ``30.0 \times C_\delta`` | Final precision | -# -# This is activated with `penalty_schedule=:default_annealed` or by passing -# an explicit list of `(start_iter, end_iter, multiplier)` tuples. - -# ## Evaluation -# -# After training, we evaluate the policy using stage-wise rollout on held-out -# scenarios. Two modes: -# - **Target feedback** (`policy_state=:target`): the policy receives its own -# predicted target as input, matching DE training semantics. -# - **Realized feedback** (`policy_state=:realized`): the policy receives the -# realized state from the solver, matching deployment semantics. -# -# The **target-violation share** measures how much cost comes from the slack -# penalty rather than actual operations — it should be small (``\le 5\%``) for -# a well-trained policy. - -# ```julia -# rollout_eval = RolloutEvaluation( -# subproblems, state_params_in, state_params_out, initial_state, eval_scenarios; -# stride=1, policy_state=:realized, -# ) -# rollout_eval(1, models) -# println("Operational cost: ", rollout_eval.last_objective_no_deficit) -# println("Violation share: ", rollout_eval.last_violation_share) -# ``` - -# ## SDDP baseline -# -# For comparison, we also train an SDDP policy using -# [SDDP.jl](https://github.com/odow/SDDP.jl) with **inconsistent -# formulations**: a convex SOC-WR relaxation for the backward pass -# (cut generation) and the nonconvex ACP formulation for the forward -# pass (simulation). This is a pragmatic approach when the true problem -# (AC-OPF) is nonconvex — SDDP requires convexity for valid cuts, so a -# convex relaxation approximates the value function while the forward pass -# evaluates under the true physics. -# -# The SDDP policy is trained for up to 2000 iterations and the learned -# cuts are saved to a JSON file, which can be loaded to simulate the -# policy under the ACP formulation. - -# ## Results -# -# The plots below compare the TS-DDR and TS-LDR training formulations and -# the SDDP baseline on the Bolivia case. Training curves, out-of-sample -# cost distributions, reservoir volume trajectories, and thermal generation -# profiles are shown. -# -# ### Training convergence (TS-DDR methods) -# -# ![Training convergence](../assets/hydro_training_convergence.png) -# -# ### Out-of-sample cost (TS-DDR methods) -# -# ![Out-of-sample cost comparison](../assets/hydro_cost_comparison.png) -# -# ### Target-violation share (TS-DDR methods) -# -# ![Violation share](../assets/hydro_violation_share.png) -# -# ### Reservoir volume comparison (all methods) -# -# ![Volume comparison](../assets/hydro_volume_comparison.png) -# -# ### Thermal generation comparison (all methods) -# -# ![Generation comparison](../assets/hydro_generation_comparison.png) -# -# ### Summary -# -# | Method | Policy | Mean Cost | Std | N | -# |:-------|:------:|----------:|----:|--:| -# | TS-DDR (DE) | LSTM | 325 540 | 6 266 | 100 | -# | TS-DDR (DE, anneal) | LSTM | 324 445 | 6 134 | 100 | -# | TS-DDR (shooting w=12) | LSTM | 323 289 | 5 593 | 100 | -# | TS-DDR (shooting w=12, anneal) | LSTM | 322 812 | 6 081 | 100 | -# | TS-DDR (stage-wise, anneal) | LSTM | 321 543 | 6 214 | 100 | -# | SDDP (SOC-WR / ACP) | cuts | 303 684 | — | 100 | -# -# All three TS-DDR methods with penalty annealing converge to similar -# costs (321K–325K). SDDP trains on 126 stages (96 + 30 margin). -# -# !!! note "Preliminary results" -# These numbers reflect the current default training scripts. -# They will be updated as the package evolves. diff --git a/docs/src/examples/hydro.md b/docs/src/examples/hydro.md deleted file mode 100644 index 6c23019..0000000 --- a/docs/src/examples/hydro.md +++ /dev/null @@ -1,488 +0,0 @@ -```@meta -EditURL = "hydro.jl" -``` - -# Hydropower Scheduling - -This example trains target-setting decision rules for the Bolivia -long-term hydrothermal dispatch (LTHD) problem — both **TS-DDR** (deep, -LSTM-based) and **TS-LDR** (linear) — and compares them against an SDDP -baseline with inconsistent formulations. - -The Bolivia system has **10 hydro plants**, **96 monthly stages**, and -**AC power flow** constraints. Inflow uncertainty is sampled from 47 -historical scenarios. - -## Overview of the TS-DDR approach - -Classical stochastic programming (e.g., SDDP) constructs piecewise-linear -value-function approximations. TS-DDR takes a different route: a neural -network policy ``\pi_\theta`` maps observations to **target states**, and a -projection subproblem at each stage enforces physical feasibility while -tracking those targets as closely as possible. - -The key insight is that the gradient of the projection subproblem with -respect to the target parameters is available through Lagrange duality -(or equivalently, implicit differentiation of the KKT conditions). -This avoids differentiating through the full optimization solver. - -## Problem formulation - -At each stage ``t``, the operator observes inflows ``w_t`` and the current -reservoir state ``x_{t-1}``. The policy predicts target volumes: - -```math -\hat{x}_t = \pi_\theta(w_{1:t},\, x_{t-1}). -``` - -A stage subproblem projects onto the feasible set: - -```math -\begin{aligned} -q_t(x_{t-1},\, w_t;\; \hat{x}_t) - \;=\; - \min_{x_t, u_t, \delta_t} - \quad & - c_t(x_t, u_t) + C_\delta\, \|\delta_t\| \\ -\text{s.t.}\quad - & x_t = x_{t-1} + w_t - \text{turbined}_t - \text{spilled}_t, - && \text{(reservoir balance)} \\ - & x_t + \delta_t = \hat{x}_t, - && : \lambda_t \quad \text{(target constraint)} \\ - & \text{AC-OPF}(u_t), - && \text{(power flow)} \\ - & x_t \in [0, \bar{x}],\; u_t \ge 0. -\end{aligned} -``` - -The slack variable ``\delta_t`` absorbs infeasible targets; ``\lambda_t`` is -the dual multiplier that provides the gradient signal. - -## Gradient computation: the envelope theorem - -By the envelope theorem, the sensitivity of the optimal value with respect -to the target parameter is simply the dual: - -```math -\frac{\partial q_t}{\partial \hat{x}_t} -\;=\; -\lambda_t. -``` - -Combined with backpropagation through the policy network, the full gradient -of the expected cost is: - -```math -\nabla_\theta \mathbb{E}[Q] -\;\approx\; -\frac{1}{S} \sum_{s=1}^{S} \sum_{t=1}^{T} - \lambda_t^s \odot \nabla_\theta \hat{x}_t^s(\theta), -``` - -where ``S`` is the number of sampled trajectories per batch and ``\odot`` -denotes elementwise multiplication. - -## Problem setup - -The JuMP subproblems are built from a MOF file (exported from PowerModels.jl) -plus hydro data (reservoir limits, inflow scenarios). Each subproblem contains: -- AC optimal power flow constraints -- Reservoir balance: `vol_out = vol_in + inflow - turbined - spilled` -- Target-slack deficit variables penalizing deviation from the policy's targets - -The helper `build_hydropowermodels` reads the case data, creates one JuMP model -per stage, and parameterizes the initial volumes and inflows so they can be set -at each training sample. - -````@example hydro -using DecisionRules -using JuMP, DiffOpt, Ipopt -using Flux -using Statistics, Random -```` - -Load the problem builder (reads MOF + hydro JSON + inflow CSV). - -```julia -include("load_hydropowermodels.jl") -``` - -## Building the stage-wise subproblems - -Each subproblem is wrapped with `DiffOpt.diff_optimizer` so that Lagrange duals -and implicit sensitivities are available for training. - -```julia -diff_optimizer = () -> DiffOpt.diff_optimizer( - optimizer_with_attributes(Ipopt.Optimizer, "print_level" => 0, "linear_solver" => "mumps") -) - -subproblems, state_params_in, state_params_out, uncertainty_samples, initial_state, max_volume = - build_hydropowermodels( - "bolivia", "ACPPowerModel.mof.json"; - num_stages=96, - optimizer=diff_optimizer, - penalty_l1=:auto, penalty_l2=:auto, - ) -``` - -## Policy architecture - -The policy is a [`StateConditionedPolicy`](@ref) with two components: - -1. **Encoder** — a stack of LSTM cells that processes only the uncertainty - (inflow) sequence, capturing temporal dependencies across stages. -2. **Combiner** — a Dense layer that merges the encoded uncertainty with the - previous state to produce the next target. - -At each stage the policy receives ``[w_t;\; x_{t-1}]`` and outputs -target reservoir volumes ``\hat{x}_t``: - -``` - ┌─────────┐ ┌────────────────┐ ┌──────────────┐ - │ w_t │─────▶│ LSTM encoder │─────▶│ │ - └─────────┘ └────────────────┘ │ Dense │──▶ x̂_t - ┌─────────┐ │ combiner │ - │ x_{t-1} │─────────────────────────────▶│ │ - └─────────┘ └──────────────┘ -``` - -The LSTM carries hidden state across stages, giving the policy memory of -past inflows. The activation is `sigmoid` (bounding outputs to ``[0,1]``, -which is then scaled by the feasibility mapping). - -```julia -models = state_conditioned_policy( - num_uncertainties, num_hydro, num_hydro, [128, 128]; - activation=sigmoid, encoder_type=Flux.LSTM, -) -``` - -## TS-LDR: Linear Decision Rules - -As a baseline, we also train a **linear** policy (TS-LDR). This uses -`dense_multilayer_nn` with identity activation — a composition of linear -layers equivalent to a single affine map: - -```math -\hat{x}_t = W [w_{1:t};\; x_{t-1}] + b. -``` - -TS-LDR uses the same target-setting framework and training pipeline as -TS-DDR. The only difference is the policy class: linear maps have fewer -parameters and cannot capture nonlinear inflow patterns, but they are a -natural baseline from the classical LDR literature. - -```julia -num_inputs = DecisionRules.policy_input_dim(num_uncertainties, num_hydro) -models = dense_multilayer_nn(num_inputs, num_hydro, [64, 64]; activation=identity) -``` - -## Training pipeline 1: Deterministic Equivalent - -The deterministic equivalent (DE) couples all 96 stages into a **single NLP** -for each sampled trajectory. This is the most direct formulation: the policy -generates the full target trajectory ``\hat{x}_{1:T}`` in one forward pass, -and a single coupled solve determines all realized states simultaneously. - -### How it works - -``` - ┌──────────────────────────────────────────────────────────┐ - │ For each sampled trajectory w_{1:T}: │ - │ │ - │ 1. Forward pass: x̂_{1:T} = π_θ(w_{1:T}, x_0) │ - │ │ - │ 2. Solve coupled NLP: │ - │ min Σ_t c_t(x_t, u_t) + C_δ Σ_t ‖δ_t‖ │ - │ s.t. dynamics + AC-OPF for ALL stages simultaneously │ - │ x_t + δ_t = x̂_t(θ) ∀t (target constraint) │ - │ │ - │ 3. Read duals λ_t of target constraints │ - │ Gradient: Σ_t λ_t ⊙ ∇_θ x̂_t(θ) │ - └──────────────────────────────────────────────────────────┘ -``` - -### Mathematical formulation - -```math -\begin{aligned} -Q(w;\, \theta) - \;=\; - \min_{\{x_t, u_t, \delta_t\}_{t=1}^{T}} - \quad & - \sum_{t=1}^{T} c_t(x_t, u_t) - + C_\delta \sum_{t=1}^{T} \|\delta_t\| \\ -\text{s.t.}\quad - & x_t = T_t(w_t,\, u_t,\, x_{t-1}), - && t=1,\ldots,T \\ - & x_t + \delta_t = \hat{x}_t(\theta), - && : \lambda_t,\quad t=1,\ldots,T \\ - & h_t(x_t, u_t) \ge 0, - && t=1,\ldots,T -\end{aligned} -``` - -The gradient is exact by the envelope theorem: - -```math -\nabla_\theta Q -\;=\; -\sum_{t=1}^{T} -\lambda_t \odot \nabla_\theta \hat{x}_t(\theta). -``` - -**Advantages**: strongest gradient signal — full cross-stage coupling -captures how a target at stage 3 affects costs at stage 50. - -**Disadvantage**: the NLP has ``96 \times (\text{AC-OPF variables})`` -decision variables; the policy generates targets without seeing realized -states (open-loop target generation). - -```julia -det_equivalent, uncertainty_samples_det = DecisionRules.deterministic_equivalent!( - det_model, subproblems_de, state_params_in, state_params_out, - Float64.(initial_state), uncertainty_samples, -) - -train_multistage( - models, initial_state, det_equivalent, - state_params_in, state_params_out, uncertainty_samples; - num_batches=4000, optimizer=Flux.Adam(), - penalty_schedule=[(1,100,0.1), (101,210,1.0), (211,300,10.0), (301,4000,30.0)], -) -``` - -## Training pipeline 2: Stage-wise Decomposition (Single Shooting) - -Stage-wise decomposition solves one subproblem per stage sequentially. -Unlike the DE, the policy operates in **closed loop**: after each stage -solve, the realized state ``x_t`` (not the predicted target) is fed back -as input to the next stage. - -### How it works - -``` - ┌─────────────────────────────────────────────────────────────┐ - │ For each sampled trajectory w_{1:T}: │ - │ │ - │ x_0 = initial state │ - │ for t = 1, ..., T: │ - │ x̂_t = π_θ(w_t, x_{t-1}) ← predict target │ - │ solve stage-t subproblem ← project to feasible│ - │ x_t = realized state from solver ← closed-loop │ - │ accumulate c_t + C_δ ‖δ_t‖ │ - │ │ - │ Gradient: chain rule through all stage solves │ - └─────────────────────────────────────────────────────────────┘ -``` - -### Gradient chain - -The gradient must account for how the realized state at stage ``t`` -depends on the targets at all earlier stages. By the chain rule: - -```math -\frac{\partial Q}{\partial \hat{x}_t} -\;=\; -\lambda_t -+ \sum_{k>t} - \frac{\partial q_k}{\partial x_{k-1}} - \cdot \prod_{j=t+1}^{k-1} - \frac{\partial x_j}{\partial x_{j-1}} - \cdot \frac{\partial x_t}{\partial \hat{x}_t}. -``` - -In practice, automatic differentiation (Zygote + ChainRules `rrule`s -defined on each stage solve) handles this chain automatically. -The `rrule` for each stage solve reads the dual ``\lambda_t`` for the -target constraint and uses DiffOpt's implicit differentiation for the -state-transition sensitivities. - -**Advantages**: closed-loop — the policy sees realized states, matching -deployment semantics. Each solve is small (single-stage AC-OPF). - -**Disadvantage**: gradients weaken over long horizons because the -chain rule multiplies many Jacobians; sequential solve prevents -parallelism. - -```julia -train_multistage( - models, initial_state, subproblems, - state_params_in, state_params_out, uncertainty_samples; - num_batches=3000, optimizer=Flux.Adam(), - penalty_schedule=:default_annealed, -) -``` - -## Training pipeline 3: Multiple Shooting - -Multiple shooting partitions the ``T``-stage horizon into ``K`` windows of -``W`` stages each. Within each window, a local deterministic equivalent -couples the stages (strong gradient signal). Between windows, the realized -end-state is passed to the next window (closed-loop continuity). - -### How it works - -``` - ┌────────────────────────────────────────────────────────────────┐ - │ Partition T=96 stages into K=⌈96/12⌉=8 windows of W=12 │ - │ │ - │ x_0 = initial state │ - │ for k = 1, ..., K: │ - │ stages = [(k-1)W+1, ..., kW] │ - │ x̂_{stages} = π_θ(w_{stages}, x_{start_k}) │ - │ solve window-k DE (12-stage coupled NLP) │ - │ x_{end_k} = realized end-state from window solve │ - │ x_{start_{k+1}} = x_{end_k} │ - │ │ - │ Gradient: │ - │ Within window: duals from the coupled solve (like full DE) │ - │ Across windows: DiffOpt chain rule through end-states │ - └────────────────────────────────────────────────────────────────┘ -``` - -### Gradient structure - -Let ``Q_k`` be the cost of window ``k``. The total cost is -``Q = \sum_k Q_k``. Within a window, the gradient is identical to the -DE case (duals of the target constraints in the coupled model). Across -windows, the chain rule threads through the realized end-state: - -```math -\frac{dQ}{d\theta} -\;=\; -\sum_{k=1}^{K} -\left( - \frac{\partial Q_k}{\partial \hat{x}_k} - \cdot \frac{\partial \hat{x}_k}{\partial \theta} - \;+\; - \frac{\partial Q_k}{\partial x_{\text{start}_k}} - \cdot \frac{d x_{\text{start}_k}}{d\theta} -\right), -``` - -where ``\frac{d x_{\text{start}_k}}{d\theta}`` involves the chain -through all prior windows via ``x_{\text{end}_{k-1}}``. - -**Advantages**: balances gradient quality (12-stage coupling) with -tractability (8 small DEs instead of one large one); inter-window -chain provides some closed-loop signal. - -**Disadvantage**: window boundaries introduce gradient discontinuities; -the full-horizon coupling is weaker than the single DE. - -```julia -windows = DecisionRules.setup_shooting_windows( - subproblems, state_params_in, state_params_out, - Float64.(initial_state), uncertainty_samples; - window_size=12, - model_factory=() -> DiffOpt.nonlinear_diff_model(ipopt_attrs), -) - -train_multiple_shooting( - models, initial_state, windows, () -> uncertainty_samples; - num_batches=3000, optimizer=Flux.Adam(), - penalty_schedule=:default_annealed, -) -``` - -## Penalty annealing - -The target penalty ``C_\delta`` controls the trade-off between following -the policy's targets and minimizing operational cost. DecisionRules -supports a **penalty annealing schedule** that ramps the penalty multiplier -during training: - -| Phase | Multiplier | Purpose | -|:------|:----------:|:--------| -| Warmup | ``0.1 \times C_\delta`` | Let the policy explore freely | -| Nominal | ``1.0 \times C_\delta`` | Standard training | -| Tighten | ``10.0 \times C_\delta`` | Sharpen target tracking | -| Lock | ``30.0 \times C_\delta`` | Final precision | - -This is activated with `penalty_schedule=:default_annealed` or by passing -an explicit list of `(start_iter, end_iter, multiplier)` tuples. - -## Evaluation - -After training, we evaluate the policy using stage-wise rollout on held-out -scenarios. Two modes: -- **Target feedback** (`policy_state=:target`): the policy receives its own - predicted target as input, matching DE training semantics. -- **Realized feedback** (`policy_state=:realized`): the policy receives the - realized state from the solver, matching deployment semantics. - -The **target-violation share** measures how much cost comes from the slack -penalty rather than actual operations — it should be small (``\le 5\%``) for -a well-trained policy. - -```julia -rollout_eval = RolloutEvaluation( - subproblems, state_params_in, state_params_out, initial_state, eval_scenarios; - stride=1, policy_state=:realized, -) -rollout_eval(1, models) -println("Operational cost: ", rollout_eval.last_objective_no_deficit) -println("Violation share: ", rollout_eval.last_violation_share) -``` - -## SDDP baseline - -For comparison, we also train an SDDP policy using -[SDDP.jl](https://github.com/odow/SDDP.jl) with **inconsistent -formulations**: a convex SOC-WR relaxation for the backward pass -(cut generation) and the nonconvex ACP formulation for the forward -pass (simulation). This is a pragmatic approach when the true problem -(AC-OPF) is nonconvex — SDDP requires convexity for valid cuts, so a -convex relaxation approximates the value function while the forward pass -evaluates under the true physics. - -The SDDP policy is trained for up to 2000 iterations and the learned -cuts are saved to a JSON file, which can be loaded to simulate the -policy under the ACP formulation. - -## Results - -The plots below compare the TS-DDR and TS-LDR training formulations and -the SDDP baseline on the Bolivia case. Training curves, out-of-sample -cost distributions, reservoir volume trajectories, and thermal generation -profiles are shown. - -### Training convergence (TS-DDR methods) - -![Training convergence](../assets/hydro_training_convergence.png) - -### Out-of-sample cost (TS-DDR methods) - -![Out-of-sample cost comparison](../assets/hydro_cost_comparison.png) - -### Target-violation share (TS-DDR methods) - -![Violation share](../assets/hydro_violation_share.png) - -### Reservoir volume comparison (all methods) - -![Volume comparison](../assets/hydro_volume_comparison.png) - -### Thermal generation comparison (all methods) - -![Generation comparison](../assets/hydro_generation_comparison.png) - -### Summary - -| Method | Policy | Mean Cost | Std | N | -|:-------|:------:|----------:|----:|--:| -| TS-DDR (DE) | LSTM | 325 540 | 6 266 | 100 | -| TS-DDR (DE, anneal) | LSTM | 324 445 | 6 134 | 100 | -| TS-DDR (shooting w=12) | LSTM | 323 289 | 5 593 | 100 | -| TS-DDR (shooting w=12, anneal) | LSTM | 322 812 | 6 081 | 100 | -| TS-DDR (stage-wise, anneal) | LSTM | 321 543 | 6 214 | 100 | -| SDDP (SOC-WR / ACP) | cuts | 303 684 | — | 100 | - -All three TS-DDR methods with penalty annealing converge to similar -costs (321K–325K). SDDP trains on 126 stages (96 + 30 margin). - -!!! note "Preliminary results" - These numbers reflect the current default training scripts. - They will be updated as the package evolves. - diff --git a/docs/src/gpu_acceleration.md b/docs/src/gpu_acceleration.md index 5cbf498..a56764c 100644 --- a/docs/src/gpu_acceleration.md +++ b/docs/src/gpu_acceleration.md @@ -138,21 +138,6 @@ The key requirements are: 3. **Return** a struct with fields `.core`, `.model`, `.horizon`, and `.target_con_range`. -The `HydroPowerModels` example in DecisionRulesExa.jl demonstrates this -pattern for a full AC-OPF problem with reservoir dynamics: - -```julia -# In examples/HydroPowerModels/hydro_power_exa.jl -prob = build_hydro_de( - data; - num_stages = 96, - backend = CUDABackend(), - formulation = :ac_polar, - deficit_cost = 1e5, - target_penalty = :auto, -) -``` - ## Parallel GPU solves When training samples are independent, multiple NLP instances can be @@ -236,18 +221,150 @@ target-deficit penalty, and target-violation share. | Stage-wise decomposition | — | JuMP only | | Multiple shooting | — | JuMP only | -## Full example: HydroPowerModels - -The `examples/HydroPowerModels/` directory in DecisionRulesExa.jl contains -a complete AC-OPF hydrothermal scheduling example for the Bolivia test case -— the same problem solved by DecisionRules.jl in the -[Hydropower Scheduling](@ref) tutorial. It demonstrates: - -- Parsing PowerModels.jl network data and hydro reservoir parameters -- Building a multi-stage deterministic-equivalent NLP in ExaModels - (DC or AC polar OPF formulations) -- L1 + L2 penalty on target slack (δ⁺/δ⁻ splitting for smooth NLP) -- GPU training with parallel MadNLP solves -- Warm-start caching to prevent cascade solver failures -- Penalty and sample-count annealing schedules -- W&B metric logging +## Embedded deterministic equivalent + +The standard `DeterministicEquivalentProblem` treats the policy's target +trajectory as an external parameter: the training loop generates +``\hat{x}_{1:T}`` outside the NLP and passes it in via `set_targets!`. +This is **open-loop** — the policy does not see the realized states +from the coupled solve. + +`EmbeddedDeterministicEquivalentProblem` embeds the policy *inside* +the NLP via a `VectorNonlinearOracle`. The NLP constraint becomes: + +```math +\pi_\theta(w_t,\, x_{t-1}^*) - x_t - \delta_t = 0 \quad \forall t +``` + +where ``x_{t-1}^*`` is the solver's realized state. This is +**closed-loop**: the policy sees realized states from the coupled solve, +and the duals ``\lambda_t`` reflect the joint (policy + physics) system. + +```julia +prob = build_embedded_deterministic_equivalent( + policy; + horizon = T, + nx = nx, + nu = nu, + nw = nw, + dynamics_eq = my_dynamics, + stage_cost = my_cost, + backend = CUDABackend(), +) + +train_tsddr_embedded( + policy, x0, prob, sampler; + num_batches = 500, + num_train_per_batch = 4, + optimizer = Flux.Adam(1f-3), + madnlp_kwargs = (print_level = MadNLP.ERROR, tol = 1e-6), +) +``` + +The oracle closures capture the policy **by reference** — updating Flux +parameters between solves automatically changes the NLP without +rebuilding it. Use `invalidate_policy_cache!` if your oracle caches +policy-dependent intermediates. + +### Strict reachable targets + +When the policy is guaranteed to produce feasible targets (e.g., via a +reachable-set mapping), the slack variables ``\delta_t`` can be removed +entirely. This is strict mode: target constraints are hard equalities, the duals +are pure shadow prices, and there is no target penalty to tune. + +There are two strict deterministic-equivalent paths. + +**Embedded strict DE** evaluates the policy inside the NLP against realized +state decision variables. + +Its constraint is simply ``x_t = \pi_\theta(w_t, x_{t-1}^*)``. Because the +policy receives the realized previous state, a reachable-set map can guarantee +that the next strict equality is dynamically feasible. + +**Regular strict DE** keeps the policy outside the NLP but rolls out targets +from the known initial state: + +```math +\hat{x}_0 = x_0,\qquad +\hat{x}_t = \pi_\theta(w_t, \hat{x}_{t-1}). +``` + +If the policy returns ``\hat{x}_t \in R(\hat{x}_{t-1}, w_t)`` at every stage, +then the entire strict DE target trajectory is feasible by induction. The solve +then enforces ``x_t = \hat{x}_t`` for every stage, so the realized state path is +exactly the reachable target path. + +For battery storage, the charge/discharge and energy bounds give a cheap +one-stage battery-dynamic interval. It is not the complete reachable set of an +AC-OPF: a target can still conflict with generation, branch, voltage, or +reactive-power limits. The +[battery-storage specification](@ref "Stochastic battery-storage AC optimal power flow") +therefore requires true-ACP zero-shedding tests before strict mode becomes the +production default. + +## Sequential rollout evaluation + +`train_tsddr` solves the full deterministic equivalent in one shot. For +deployment diagnostics, DecisionRulesExa.jl provides `RolloutEvaluation`, which +solves a one-stage ExaModels problem sequentially over a materialized scenario: + +```julia +eval = RolloutEvaluation( + stage_problem, + x0, + eval_scenarios; + horizon = T, + n_uncertainty = nw, + set_stage_parameters! = my_setter!, + realized_state = my_state_reader, + policy_state = :realized, +) +``` + +This mirrors deployment semantics: the policy can be evaluated with the +realized previous state (`policy_state = :realized`) or with its previous target +(`policy_state = :target`) to match regular-DE target-generation semantics. + +## Critic control variate + +`train_tsddr` optionally trains a scalar critic ``C(w, \hat{x})`` that +provides a learned control variate for the dual gradient signal. The +critic does not replace the NLP solve — dual multipliers remain the +primary actor gradient. The critic reduces gradient variance by +subtracting a correlated baseline. + +```julia +critic = Chain(Dense(input_dim => 128, tanh), Dense(128 => 128, tanh), Dense(128 => 1)) + +cv = ScalarCriticControlVariate(critic; + featurizer = default_critic_featurizer, + value_loss_weight = 1.0, + gradient_loss_weight = 0.0, +) + +critic_target = RolloutCriticTarget(stage_problem; + horizon = T, + n_uncertainty = nw, + set_stage_parameters! = my_setter!, + realized_state = my_state_reader, + policy_state = :target, +) + +train_tsddr(policy, x0, prob, prob.p_x0, prob.p_target, prob.p_w, sampler; + control_variate = cv, + critic_training_target = critic_target, + actor_gradient_mode = :control_variate, + critic_cv_weight = 1.0, + critic_optimizer = Flux.Adam(1f-3), +) +``` + +Two actor modes are supported: + +- `:control_variate` — subtracts ``\nabla_{\hat{x}} C`` from the dual + signal and adds it back as a differentiable surrogate. Unbiased when + the critic is exact; reduces variance otherwise. +- `:surrogate` — blends dual and critic actor gradients via explicit + weights (`dual_actor_weight`, `critic_actor_weight`). Useful when raw + duals are noisy, but no longer strictly unbiased. diff --git a/docs/src/guide/getting_started.md b/docs/src/guide/getting_started.md new file mode 100644 index 0000000..88af943 --- /dev/null +++ b/docs/src/guide/getting_started.md @@ -0,0 +1,115 @@ +# Getting started + +```@meta +CurrentModule = DecisionRules +``` + +## Installation + +```julia +using Pkg +Pkg.add("DecisionRules") +``` + +DecisionRules.jl builds policies with [Flux.jl](https://fluxml.ai) and +subproblems with [JuMP](https://jump.dev); training requires a +DiffOpt-compatible solver for the stage problems (Ipopt for smooth NLPs, +HiGHS for LPs/MIPs). For GPU-accelerated training of large NLPs, install +the companion package +[DecisionRulesExa.jl](https://github.com/LearningToOptimize/DecisionRulesExa.jl) +(see [GPU Acceleration with DecisionRulesExa.jl](@ref)). + +## Anatomy of a training run + +Every TS-DDR training run assembles the same five ingredients: + +1. **Stage subproblems** — one JuMP model per stage, wrapped with + `DiffOpt.diff_optimizer` so Lagrange duals and sensitivities are + available. The incoming state, the uncertainty, and the policy's + target state enter as *parameters*. +2. **A policy** — a Flux model mapping ``[w_t;\, x_{t-1}]`` to a target + state ``\hat{x}_t`` (see [Target-state policies](@ref)). +3. **An uncertainty sampler** — how trajectories ``w_{1:T}`` are drawn; + the three supported formats (independent pools, joint-scenario pools, + trajectory samplers) are the subject of [Uncertainty Sampling](@ref). +4. **A training formulation** — deterministic equivalent, stage-wise, + multiple shooting, or strict (see + [Three training formulations](@ref) and + [Strict mode: penalty-free gradient signal](@ref)). +5. **An evaluation protocol** — out-of-sample stage-wise rollout via + [`RolloutEvaluation`](@ref), with target- or realized-state feedback + (see [Evaluation semantics](@ref)). + +## Quick start + +```julia +using DecisionRules, JuMP, DiffOpt, Flux, Ipopt + +# Build per-stage subproblems in JuMP (DiffOpt-enabled) +# subproblems, state_params_in, state_params_out, uncertainty_samples, initial_state = ... + +# Define a policy: maps [uncertainty; state] → target state +policy = Chain( + Dense(policy_input_dim(num_uncertainties, num_states), 64, relu), + Dense(64, num_states), +) + +# Train via stage-wise decomposition +train_multistage( + policy, initial_state, subproblems, + state_params_in, state_params_out, uncertainty_samples; + num_batches=100, optimizer=Flux.Adam(1e-3), +) +``` + +## Choosing a training formulation + +| Formulation | Horizon coupling | Gradient source | +|:---|:---|:---| +| **Deterministic Equivalent** | Full horizon, one large NLP | Duals on the coupled problem | +| **Stage-wise (single shooting)** | Sequential rollout | Duals + DiffOpt per stage | +| **Multiple Shooting** | Windowed sub-horizons | DiffOpt per window, continuity penalties | +| **Strict subproblems** | Sequential rollout, no slack | Pure shadow-price duals | + +As a rule of thumb: + +- start with **stage-wise** training — closed-loop, smallest solves, + fewest assumptions; +- move to the **deterministic equivalent** (or its GPU implementation) + when the per-stage solves are large and horizon-coupled gradient signal + pays off; +- use **multiple shooting** as the middle ground on long horizons; +- switch to **strict** mode whenever you can construct a + feasibility-guaranteeing policy — one that bounds its output to the + one-stage reachable set ``R(x, w)`` of the dynamics. Constructing ``R`` + is problem-specific (cheap for resource-balance dynamics with box + bounds). The + [battery-storage AC-OPF specification](@ref "Stochastic battery-storage AC optimal power flow") + shows both the battery-dynamic interval and the additional network-feasibility + gate needed before strict mode is accepted. Strict mode eliminates the + target-slack penalty and its tuning entirely, and the dual ``\lambda_t`` + becomes the pure shadow price. + +## Robustness and hardware + +- Solver or differentiation failures during training are handled by the + pluggable [gradient fallback](@ref "Gradient Fallback") system — + by default a failed iteration logs a warning and is skipped. +- Problems with large stage NLPs train an order of magnitude + faster on GPU through + [DecisionRulesExa.jl](@ref "GPU Acceleration with DecisionRulesExa.jl"), + which implements the strict deterministic equivalent with + ExaModels + MadNLP/cuDSS. + +## Where to go next + +- Theory: + [multistage stochastic optimization](@ref "Multistage stochastic optimization"), + [the TS-DDR framework](@ref "The TS-DDR framework"), + [SDDP and inconsistent formulations](@ref "Stochastic dual dynamic programming"), + [extensions](@ref "Extensions: mixed gradients, critics, and risk"). +- Worked problems: + [stochastic battery-storage AC-OPF](@ref "Stochastic battery-storage AC optimal power flow"), + [rocket control](@ref "Rocket Control"), and + [stochastic lot-sizing](@ref "Stochastic Lot-Sizing with Fixed Ordering Costs"). +- [API Reference](@ref): every exported symbol. diff --git a/docs/src/index.md b/docs/src/index.md index 7051de0..c767864 100644 --- a/docs/src/index.md +++ b/docs/src/index.md @@ -4,27 +4,61 @@ CurrentModule = DecisionRules ``` -DecisionRules.jl trains parametric decision rules through multi-stage optimization, -implementing the **Two-Stage Deep Decision Rules (TS-DDR)** framework from -[arXiv:2405.14973](https://arxiv.org/abs/2405.14973). - -## How it works - -In multi-stage stochastic control, the feasible action at each stage comes from solving -a constrained optimization problem (OPF, MPC, hydrothermal dispatch, …). Rather than -outputting actions directly, the neural-network policy outputs **target states**. -An optimization subproblem then projects these targets onto the feasible set defined by -dynamics and constraints. Lagrange duals and implicit differentiation (via -[DiffOpt.jl](https://github.com/jump-dev/DiffOpt.jl)) provide the gradient signal to -update the policy end-to-end. - -Three training formulations are supported: - -| Formulation | Horizon coupling | Gradient source | -|:---|:---|:---| -| **Deterministic Equivalent** | Full horizon, one large NLP | Duals on the coupled problem | -| **Stage-wise (single shooting)** | Sequential rollout | Duals + DiffOpt per stage | -| **Multiple Shooting** | Windowed sub-horizons | DiffOpt per window, continuity penalties | +DecisionRules.jl trains parametric decision rules — from affine policies +to deep recurrent networks — for multistage stochastic optimization +problems whose actions come from constrained optimization subproblems +(optimal power flow, MPC, inventory control, …). It implements the +**Two-Stage Deep Decision Rules (TS-DDR)** framework of +[arXiv:2405.14973](https://arxiv.org/abs/2405.14973): the policy outputs +**target states**, a projection subproblem restores exact feasibility, and +Lagrange duals (with implicit differentiation via +[DiffOpt.jl](https://github.com/jump-dev/DiffOpt.jl) where needed) provide +the end-to-end training gradient — no differentiation through solver +iterations, no feasibility violations at deployment. + +In the **strict** formulation, the target constraints are hard equalities +and the policy is built to emit only reachable targets: no slack, no +penalty hyperparameter, and the dual ``\lambda_t`` is the pure shadow +price of the target. A GPU companion package, +[DecisionRulesExa.jl](https://github.com/LearningToOptimize/DecisionRulesExa.jl), +trains the same policies through full-horizon deterministic equivalents +with ExaModels + MadNLP/cuDSS. + +## The documentation + +**Theory.** The +[multistage stochastic optimization problem](@ref "Multistage stochastic optimization") +and where decision rules sit among solution methods; +[the TS-DDR framework](@ref "The TS-DDR framework") — target-state +policies, dual gradients, the training formulations, and strict mode with +its reachability-based feasibility guarantee; +[stochastic dual dynamic programming](@ref "Stochastic dual dynamic programming"), +including the inconsistent-formulation variant for nonconvex stage problems and +the bound-versus-forward gap; and +[extensions](@ref "Extensions: mixed gradients, critics, and risk") — +score-function corrections for integer decisions, control-variate +critics, risk-averse objectives. + +**Package guide.** [Getting started](@ref); +[uncertainty sampling formats](@ref "Uncertainty Sampling"); +[gradient fallback](@ref "Gradient Fallback"); +[GPU acceleration](@ref "GPU Acceleration with DecisionRulesExa.jl"); +[API Reference](@ref). + +**Case studies.** The flagship is +[stochastic battery-storage AC optimal power flow](@ref "Stochastic battery-storage AC optimal power flow"), which defines the +PGLib case generator, demand information pattern, battery physics, strict and +soft target projections, true ACP model, SOC-WR backward relaxation, and paired +PF/SDDP/TS-DDR evaluation protocol. [Long-term hydrothermal planning](@ref) asks whether a learned policy can +value water as well as a method built to do exactly that: on a real grid under +full AC physics, a policy trained from random initialisation in eleven GPU-hours, +with no value function and no convex relaxation anywhere in its path, operates +the system within **0.152%** of a converged SDDP baseline over 500 shared inflow +scenarios — close, measurably more expensive, and diagnosably so. Two further +studies, +[rocket control](@ref "Rocket Control") and +[stochastic lot-sizing](@ref "Stochastic Lot-Sizing with Fixed Ordering Costs"), +exercise continuous control and mixed-integer recourse. ## Installation @@ -33,32 +67,8 @@ using Pkg Pkg.add("DecisionRules") ``` -## Quick start - -```julia -using DecisionRules, JuMP, DiffOpt, Flux, Ipopt - -# Build per-stage subproblems in JuMP (DiffOpt-enabled) -# subproblems, state_params_in, state_params_out, uncertainty_samples, initial_state = ... - -# Define a policy: maps [uncertainty; state] → target state -policy = Chain( - Dense(policy_input_dim(num_uncertainties, num_states), 64, relu), - Dense(64, num_states), -) - -# Train via stage-wise decomposition -train_multistage( - policy, initial_state, subproblems, - state_params_in, state_params_out, uncertainty_samples; - num_batches=100, optimizer=Flux.Adam(1e-3), -) -``` - -See the [Algorithm](@ref) page for the mathematical formulation, the -[Uncertainty Sampling](@ref) guide for how to prepare your scenario data, the -[GPU Acceleration with DecisionRulesExa.jl](@ref) page for GPU-accelerated training, -and the examples for complete worked problems. +[Getting started](@ref) covers solver requirements, a quick-start example, +and how to choose among the training formulations. ## Citation diff --git a/docs/src/sampling.md b/docs/src/sampling.md index bacdfad..3e07a41 100644 --- a/docs/src/sampling.md +++ b/docs/src/sampling.md @@ -251,35 +251,36 @@ For callables, `sample(f::Function)` simply calls `f()`. ## Demonstrating the difference -Consider 3 hydro reservoirs with 4 historical inflow scenarios: +Consider 3 demand regions with 4 historical load-factor scenarios: ``` -Historical inflow data (columns = scenarios): +Historical load factors (columns = scenarios): ω=1 ω=2 ω=3 ω=4 -Res 1: 10 20 15 25 -Res 2: 80 120 90 110 -Res 3: 5 8 6 9 +Reg 1: 0.90 1.00 0.95 1.10 +Reg 2: 0.85 1.15 0.90 1.05 +Reg 3: 0.92 1.08 0.97 1.12 ``` **Independent sampling** draws one value per row independently. A sample -might be `(10, 120, 9)` — reservoir 1 from ω=1, reservoir 2 from ω=2, -reservoir 3 from ω=4. This combination never occurred historically and -may violate the drought-affects-all-basins correlation. +might be `(0.90, 1.15, 1.12)` — region 1 from ω=1, region 2 from ω=2, +region 3 from ω=4. This combination never occurred historically and +may violate spatial demand correlation. -**Joint sampling** picks one column: `(10, 80, 5)` or `(25, 110, 9)` — +**Joint sampling** picks one column: `(0.90, 0.85, 0.92)` or +`(1.10, 1.05, 1.12)` — always a historically observed combination. **Trajectory sampling** can additionally model temporal persistence: -if ω=1 (dry year) was drawn at stage 1, the AR(1) sampler will likely -produce below-average inflows at stage 2 as well. +if a low-demand atom was drawn at stage 1, the AR(1) sampler will likely +produce below-average demand at stage 2 as well. ``` Joint sampling (k=4 possible outcomes per stage): - Res 1 ──┐ - Res 2 ──┼── same ω ──→ one of 4 historical vectors - Res 3 ──┘ + Reg 1 ──┐ + Reg 2 ──┼── same ω ──→ one of 4 historical vectors + Reg 3 ──┘ Independent sampling (k³=64 possible outcomes per stage): @@ -307,7 +308,7 @@ maintainability. parameters from an uncertainty pool, discarding the scenario values. Used by `setup_shooting_windows` for multiple-shooting training. -## API Reference +## Docstrings ```@docs sample diff --git a/docs/src/theory/extensions.md b/docs/src/theory/extensions.md new file mode 100644 index 0000000..b33bb2c --- /dev/null +++ b/docs/src/theory/extensions.md @@ -0,0 +1,165 @@ +# Extensions: mixed gradients, critics, and risk + +```@meta +CurrentModule = DecisionRules +``` + +The dual gradient of [The TS-DDR framework](@ref) is exact for smooth +subproblems and, over fresh samples, an unbiased estimator of the +expected-cost gradient. Two practical situations call for more: +**discrete decisions**, where the dual is blind to integer switches and a +score-function (REINFORCE) correction restores the missing signal, and +**small sample budgets**, where a control-variate critic cuts the +estimator's variance without moving its optimum. Both extensions, and a +risk-averse change-of-measure variant of the gradient, ship with the +package. + +!!! note "Scope" + The battery-storage case study is continuous and is designed to use the + pure strict dual gradient after its feasibility gates; it uses none of these + extensions. The score-function correction is exercised in + [Stochastic Lot-Sizing with Fixed Ordering Costs](@ref), whose + fixed-charge (binary) ordering decisions are exactly the situation it + addresses. + +## Mixed gradient: score-function (REINFORCE) correction + +For problems with integer variables or non-smooth subproblems, the dual +gradient can be biased — it is local to a fixed integer assignment and cannot +see the effect of discrete switches (e.g., opening a setup variable). + +DecisionRules provides a **score-function (REINFORCE)** correction that mixes +the dual gradient with a model-free policy gradient estimated from stage-wise +rollouts under perturbed targets. + +### How the score-function estimator works + +1. **Perturb**: add Gaussian noise to the policy targets: + ``\tilde{x}_t = \hat{x}_t(\theta) + \delta_t``, where + ``\delta_t \sim \mathcal{N}(0, \sigma^2 I)``. + +2. **Rollout**: solve the stage-wise subproblems with the perturbed targets to + obtain realized costs ``R_m`` for ``m = 1, \ldots, M`` rollouts. These + rollouts solve the models exactly as built (MIPs stay MIPs), so the costs + reflect true integer-feasible decisions. + +3. **Advantage**: center the costs ``A_m = R_m - \bar{R}``. Because the mean + baseline ``\bar{R}`` is computed from the same ``M`` rollouts, mean-centering + reduces variance but introduces a small ``O(1/M)`` bias (effectively scaling + the estimator by ``(M-1)/M``) that vanishes as `num_rollouts` grows; a + leave-one-out baseline would be exactly unbiased. + +4. **Surrogate loss**: the differentiable scalar whose gradient recovers the + REINFORCE estimate: + +```math +L_{\text{sf}}(\theta) +\;=\; +\frac{1}{M} \sum_{m=1}^{M} + A_m + \sum_{t=1}^{T} + \left\langle + \frac{\delta_{m,t}}{\sigma^2},\; + \hat{x}_{t+1}(\theta) + \right\rangle. +``` + +This is the standard score-function estimator for Gaussian perturbations. +The key identity is +``\nabla_\theta \log p(\delta_t \mid \theta) = \delta_t / \sigma^2`` +for a Gaussian centered at ``\hat{x}_t(\theta)``. + +### Mixed gradient + +The final training gradient combines both signals: + +```math +\nabla L +\;=\; +\alpha\, \nabla L_{\text{dual}} ++ (1 - \alpha)\, \nabla L_{\text{sf}}, +``` + +where ``\alpha \in [0, 1]`` is the `dual_weight`. + +There are two separate solve paths in the mixed-gradient training loop: + +- **Dual path**: controlled by `integer_strategy`, which determines how local + dual information is read from the deterministic equivalent + (e.g., [`FixedDiscreteIntegerStrategy`](@ref) solves the MIP, fixes integers, + re-solves the LP, and reads LP duals). +- **Score-function path**: controlled by [`ScoreFunctionConfig`](@ref), which + owns separate rollout subproblems. These are solved exactly as built, and + their realized costs define the Monte Carlo score-function term. + +### Scheduled ramp-in + +A [`ScoreFunctionSchedule`](@ref) can ramp ``\alpha`` from 1 (pure dual) to +its final value over a warmup period. Let ``k`` be the current iteration and +``\rho_k = \operatorname{clip}((k - k_0) / r,\, 0,\, 1)``. The effective +score-function weight is ``\rho_k (1 - \alpha)``. + +This lets the DE dual gradient establish a good initial policy before +introducing the higher-variance REINFORCE signal. + +See the [Stochastic Lot-Sizing with Fixed Ordering Costs](@ref) example for a +complete worked example with integer variables and mixed gradients. + +## Variance reduction: control-variate critic + +The dual gradient over a batch of ``N`` sampled trajectories is the +sample-average + +```math +g \;=\; \frac{1}{N}\sum_{s=1}^{N}\sum_{t=1}^{T} + \bigl\langle \lambda^{s}_t,\; \partial \hat{x}^{s}_t/\partial\theta \bigr\rangle , +\qquad \lambda^{s}_t = \partial Q_s/\partial \hat{x}^{s}_t . +``` + +With fresh independent samples each step this is an **unbiased** estimator of +``\nabla_\theta\,\mathbb{E}[Q]`` for any ``N``. A small batch does not bias it — +it only inflates its **variance**, which sets the SGD noise floor and keeps the +policy short of the optimum. Rather than paying for a large ``N``, a +`ScalarCriticControlVariate` subtracts a learned, state-conditioned +baseline ``b^{s}_t = \nabla_{\hat{x}_t} C \approx \lambda^{s}_t`` and adds it back +as an independent-sample expectation: + +```math +g_{\text{cv}} \;=\; + \frac{1}{N}\sum_{s}\sum_t \bigl\langle \lambda^{s}_t - b^{s}_t,\; \partial\hat{x}^{s}_t/\partial\theta\bigr\rangle + \;+\; + \frac{1}{M}\sum_{j}\sum_t \bigl\langle b^{j}_t,\; \partial\hat{x}^{j}_t/\partial\theta\bigr\rangle . +``` + +**Unbiasedness.** The subtracted and added terms are two Monte-Carlo estimates of +the same expectation ``\mathbb{E}\bigl[\sum_t\langle b_t,\partial\hat{x}_t/\partial\theta\rangle\bigr]``, +so ``\mathbb{E}[g_{\text{cv}}] = \mathbb{E}[g] = \nabla_\theta\mathbb{E}[Q]``: the +critic **cannot move the optimum**. (If the add-back reuses the same samples with +``M=N``, the two terms cancel and the critic is a no-op — a fresh add-back batch, +`num_cheap_critic_samples_per_batch > 0`, is what activates it.) + +**Variance.** The reduction is governed by how well the baseline tracks the dual, + +```math +\text{Var reduction} \;\approx\; \frac{1}{1 - R^2}, \qquad +R^2 = \text{explained variance of } \lambda_t \text{ by } b_t , +``` + +so the baseline must be trained to **match the dual** (`gradient_loss_weight > 0`), +not only the scalar value (`value_loss_weight`): a value-only critic leaves +``\nabla_{\hat{x}} C`` unconstrained, ``R^2\approx 0``, and yields no reduction. The +control-variate critic is therefore a **sample-efficiency lever** — it reaches the +same risk-neutral optimum a much larger batch would, at a modest batch size. + +## Risk-averse extension (nested change-of-measure) + +The same per-stage critic supports a **risk-averse** objective by replacing the +expectation with a nested, time-consistent coherent risk measure (e.g. conditional +``\mathrm{CVaR}_\alpha``). Each stage weight becomes ``\Xi^{s}_t\,\lambda^{s}_t`` with +``\Xi^{s}_t = \prod_{u\le t}\zeta^{s}_u``, the causal product of per-node +change-of-measure densities ``\zeta_u`` (``\zeta\equiv 1`` recovers the risk-neutral +gradient above). Because each ``\zeta_u`` depends only on the distribution +*conditional* on stage ``u``, the policy never hedges against a tail already +precluded by realized uncertainty — the time-consistency property that a global +scenario re-weighting would violate. This targets tail cost at the expense of the +mean, and is a distinct objective from the risk-neutral formulation above. diff --git a/docs/src/theory/multistage.md b/docs/src/theory/multistage.md new file mode 100644 index 0000000..f5e271d --- /dev/null +++ b/docs/src/theory/multistage.md @@ -0,0 +1,196 @@ +# Multistage stochastic optimization + +```@meta +CurrentModule = DecisionRules +``` + +Everything downstream — the TS-DDR framework, the SDDP baseline, the case +studies — is an attempt to solve one problem: sequential decision making +under uncertainty, with actions constrained by an optimization-level +feasible set. What follows fixes +notation, recalls the dynamic-programming view and why it is intractable +in general, and places **decision rules** among the classical solution +families; readers fluent in multistage stochastic programming can skim to +[Decision rules](@ref decision-rules-sec) and continue with +[The TS-DDR framework](@ref). + +## Problem statement + +Consider a sequential decision problem over a finite horizon of ``T`` +stages. At each stage ``t = 1, \ldots, T``: + +1. an exogenous **uncertainty realization** ``w_t \in \mathcal{W}_t`` is + revealed (river inflows, demands, prices, disturbances); +2. the decision maker, knowing the current **state** ``x_{t-1}`` and the + realization ``w_t`` (and, in general, the whole history + ``w_{1:t} = (w_1, \ldots, w_t)``), chooses a **control** + ``u_t`` and a next state ``x_t``; +3. the pair must satisfy the stage feasibility constraints, + ``(u_t, x_t) \in \mathcal{X}_t(x_{t-1}, w_t)``, which encode both the + **dynamics** (how the state evolves) and the **static constraints** of + the stage (a network, a budget, a capacity — whatever the application + imposes within a single period); +4. a **stage cost** ``c_t(x_t, u_t)`` is incurred. + +The objective is to choose a *policy* — a rule for making each decision +from the information available when it must be made — minimizing expected +total cost: + +```math +\min_{\pi \in \Pi} \; +\mathbb{E}_{w_{1:T}} \left[ \sum_{t=1}^{T} c_t\bigl(x_t^\pi, u_t^\pi\bigr) \right] +\qquad \text{s.t.} \quad +\bigl(u_t^\pi, x_t^\pi\bigr) \in \mathcal{X}_t\bigl(x_{t-1}^\pi, w_t\bigr) +\;\; \forall t, +``` + +where ``\Pi`` is the set of **nonanticipative** policies: ``u_t^\pi`` may +depend on ``w_{1:t}`` but not on future realizations ``w_{t+1:T}``. +Nonanticipativity is what makes the problem *stochastic control* rather +than a family of deterministic problems — every decision is a hedge +against a distribution of futures, committed before those futures are +revealed. + +Two structural features of this formulation deserve emphasis, because the +solution methods differ precisely in how they treat them: + +- **Intertemporal coupling through the state.** The only channel through + which stage ``t`` affects stage ``t+1`` is ``x_t``. A resource stored in + the state (energy in a battery, inventory on a shelf, fuel in a tank) + has an *opportunity cost* — the expected future cost avoided by carrying + it forward — that no single-stage view can price. +- **Constrained actions.** The feasible set ``\mathcal{X}_t`` is itself an + optimization-level object — possibly a full nonconvex program, as in + the battery-storage AC-OPF case study. Any learned policy must produce + decisions that *satisfy it exactly*, not approximately. + +## The dynamic-programming recursion + +Under the Markovian assumption that ``(x_{t-1}, w_t)`` summarizes the +history (stagewise-independent ``w_t``, or an augmented state otherwise), +the problem admits Bellman's recursion. Define the **cost-to-go** +(or *value*) **function** at the end of stage ``t``: + +```math +V_t(x_{t-1}, w_t) \;=\; +\min_{(u_t, x_t) \in \mathcal{X}_t(x_{t-1}, w_t)} +\; c_t(x_t, u_t) + \mathbb{E}_{w_{t+1}}\bigl[ V_{t+1}(x_t, w_{t+1}) \bigr], +``` + +with ``V_{T+1} \equiv 0``. The optimal policy acts greedily against the +expected cost-to-go: at each stage it trades the immediate cost +``c_t`` against the expected future cost +``\mathbb{E}[V_{t+1}(x_t, \cdot)]`` of the state it leaves behind. In +resource-storage problems this expected cost-to-go *is* the "value of +water" (or of inventory): its negative gradient with respect to the stored +quantity is the marginal price at which storing beats releasing. + +The recursion is conceptually complete and computationally hopeless in +general: ``V_t`` is a function on the full state space, and any grid-based +representation grows exponentially with the state dimension — Bellman's +*curse of dimensionality*. Every practical method is a way of +approximating either the value function or the policy. + +## Solution families + +Three broad families dominate practice; the third is the one this package +implements. + +### Scenario trees and the deterministic equivalent + +Discretize the uncertainty into a finite **scenario tree** and attach one +copy of the decision variables to every node. The result is a single — +typically enormous — mathematical program, the **deterministic +equivalent** (DE), whose solution is exact *for the tree*. The tree grows +exponentially in ``T``, so pure scenario-tree methods are confined to +short horizons or coarse discretizations. The DE returns in +[Three training formulations](@ref) in a different role — not as a +solution method but as a *differentiable training oracle* for a policy, +evaluated one sampled trajectory at a time, which sidesteps the +exponential growth entirely. + +### Value-function approximation: SDDP + +**Stochastic dual dynamic programming** (SDDP) exploits convexity: when +each stage problem is convex in ``x_{t-1}``, the cost-to-go +``\mathbb{E}[V_{t+1}]`` is convex and can be outer-approximated by +supporting hyperplanes ("cuts") generated from stage duals. SDDP is the +workhorse of long-horizon planning under uncertainty and the baseline the +case studies compare against; +[Stochastic dual dynamic programming](@ref) develops it in detail — +including what must be done, and what is silently given up, when the true +stage problem is *nonconvex*. + +### [Decision rules](@id decision-rules-sec) + +The third family approximates the **policy** directly: restrict ``\Pi`` to +a parametric class + +```math +u_t = \pi_\theta\bigl(w_{1:t}, x_{t-1}\bigr), \qquad \theta \in \Theta, +``` + +and optimize over the finite-dimensional parameter ``\theta`` instead of +over the space of all measurable policies. Nonanticipativity holds *by +construction* — the rule only ever reads the history. The classical +instance is the **linear decision rule** (LDR/affine policy), where +``\pi_\theta`` is affine in the observations: tractable, sometimes +provably near-optimal, but limited in expressiveness. Replacing the affine +map with a deep network gives a **deep decision rule** with the opposite +profile: expressive, but raising two difficulties that the naive +"learn a network that outputs actions" approach does not survive in +constrained physical systems: + +1. **Feasibility.** A network output has no reason to satisfy + ``\mathcal{X}_t`` — and in operations, constraint violation is not a + soft error. Penalizing violations reintroduces exactly the kind of + hyperparameter tuning decision rules were supposed to avoid. +2. **Gradient signal.** If feasibility is enforced by an optimization + layer, training requires differentiating through a solver — expensive + and fragile if done by unrolling or generic implicit differentiation at + scale. + +[The TS-DDR framework](@ref) resolves both at +once: the network outputs *target states* rather than actions, a +projection subproblem restores feasibility exactly, and Lagrangian duality +supplies the training gradient at the cost of the solve itself. The +[strict variant](@ref "Strict mode: penalty-free gradient signal") +sharpens this further when targets can be guaranteed reachable by +construction. + +## What "solving" means: bounds and simulation + +Because all practical methods approximate, empirical comparisons rest on +two complementary quantities, used throughout the case studies: + +- A **lower bound** (for minimization): SDDP's cut model provides a valid + lower bound on the expected cost *of the problem its cuts actually + model*. When the cut model is a convex relaxation of a nonconvex stage + problem, + the bound is a bound on the *relaxed* problem — an important subtlety + developed in [The bound and the forward cost](@ref). +- A **simulation (forward) cost**: the expected cost of a concrete policy, + estimated by rolling it out on the *true* stage problems over sampled + scenarios. This is the only number that treats every method — cuts, + linear rules, deep rules — on identical footing, and it is the primary + metric of the case studies (see the + paired evaluation protocol in the + [battery-storage AC-OPF study](@ref "Stochastic battery-storage AC optimal power flow")). + +The gap between the two jointly measures the suboptimality of the policy +*and* the fidelity of the model used to bound it — and keeping those two +contributions separate is a recurring theme, made precise for SDDP in +[The bound and the forward cost](@ref). + +## Further reading + +- Shapiro, Dentcheva, Ruszczyński, *Lectures on Stochastic Programming* + (SIAM) — the standard reference for the general theory. +- Bertsekas, *Dynamic Programming and Optimal Control* — the + control-theoretic view of the same recursion. +- Ben-Tal et al., *Adjustable robust solutions of uncertain linear + programs* (2004) — the origin of affine decision rules. +- Rosemberg, Street, Valladão, Van Hentenryck, + [*Efficiently Training Deep-Learning Parametric Policies using + Lagrangian Duality*](https://arxiv.org/abs/2405.14973) — the TS-DDR + paper this package implements. diff --git a/docs/src/theory/sddp.md b/docs/src/theory/sddp.md new file mode 100644 index 0000000..069dd17 --- /dev/null +++ b/docs/src/theory/sddp.md @@ -0,0 +1,182 @@ +# Stochastic dual dynamic programming + +```@meta +CurrentModule = DecisionRules +``` + +Stochastic dual dynamic programming (SDDP) is the industrial standard for +long-horizon planning under uncertainty and the baseline against which the +case studies are evaluated — a fair comparison requires both methods at +the same depth. Its guarantees rest on one structural assumption, +convexity of the stage problem in the state; making that assumption +precise leads directly to the **inconsistent-formulation** variant used +when the true stage problem is nonconvex, and to the +*bound-versus-forward gap*, the quantity that measures what the +convexification gives up. (DecisionRules.jl does not implement SDDP; the +baselines use [SDDP.jl](https://github.com/odow/SDDP.jl).) + +## Cutting-plane approximation of the cost-to-go + +Recall the dynamic-programming recursion of +[Multistage stochastic optimization](@ref): the optimal stage decision +trades immediate cost against the expected cost-to-go +``\mathcal{V}_{t+1}(x_t) := \mathbb{E}_{w_{t+1}}[V_{t+1}(x_t, w_{t+1})]``. +SDDP (Pereira & Pinto, 1991) replaces ``\mathcal{V}_{t+1}`` by a +polyhedral outer approximation built from **cuts**, + +```math +\mathcal{V}_{t+1}(x) \;\ge\; \underline{\mathcal{V}}_{t+1}(x) +\;=\; \max_{k = 1, \ldots, K} \;\alpha_k + \langle \beta_k,\, x \rangle , +``` + +and iterates two passes over a sampled scenario lattice: + +- **Forward pass.** Sample a trajectory ``w_{1:T}``; solve the stage + problems in sequence with ``\underline{\mathcal{V}}_{t+1}`` in place of + the true cost-to-go, recording the visited states ``x_t``. The + accumulated stage costs of many forward passes estimate the expected + cost of the *current cut policy* — an upper-bound estimator (in + expectation) for minimization. +- **Backward pass.** At each visited state ``x_t``, re-solve the + stage-``(t{+}1)`` problems for every uncertainty realization, and read + the **dual multipliers** of the constraints through which ``x_t`` + enters (the state-coupling rows). Averaging over realizations + yields a subgradient ``\beta`` of ``\underline{\mathcal{V}}_{t+1}`` at + ``x_t`` and an intercept ``\alpha`` — a new cut, appended to the model. + +The value of the first-stage problem under the current cuts is a valid +**lower bound** on the optimal expected cost, monotonically nondecreasing +as cuts accumulate. Under standard assumptions (finite support, +stagewise independence, relatively complete recourse), the bound and the +forward-cost estimate converge to the common optimal value. + +## Where convexity enters + +Every step above leans on convexity of the stage problem in the incoming +state ``x_{t-1}``: + +1. **Cut validity.** A cut is a supporting hyperplane; it under-estimates + ``\mathcal{V}_{t+1}`` everywhere only if ``\mathcal{V}_{t+1}`` is + convex. Convexity of ``V_{t+1}(\cdot, w)`` in the state follows from + convexity of the stage feasible set and cost — and is *inherited + backwards* through the recursion. +2. **Dual attainment.** The subgradient ``\beta`` is a Lagrange + multiplier; strong duality (no duality gap) is what makes the + multiplier a subgradient of the value function rather than merely a + local sensitivity. + +If the stage problem is **nonconvex** in the state, both properties +fail: duals of a nonconvex solve are local objects, and a "cut" built +from them can *cut off* the true value function. SDDP as stated simply +does not apply. + +## Inconsistent formulations: convex cuts, nonconvex stage problems + +The pragmatic and widely used response is to run the two passes on +**different formulations** of the same stage: + +- the **backward pass** (cut generation) uses a **convex relaxation** + ``\mathcal{X}_t^{\mathrm{rel}} \supseteq \mathcal{X}_t`` of the stage + feasible set; +- the **forward pass** (state sampling and policy simulation) uses the + **true nonconvex stage problem** ``\mathcal{X}_t``. + +We refer to this as SDDP with **inconsistent formulations**. It is +well defined: the relaxed stage problem is convex in the state, so the +cuts are valid *for the relaxed problem*, and the recursion converges on +that surrogate. The forward pass then evaluates the resulting +value-function approximation against the stage problem that will +actually be operated. Concretely, the operating policy is + +```math +u_t^{\mathrm{SDDP}}(x_{t-1}, w_t) \;\in\; +\arg\min_{(u_t, x_t) \in \mathcal{X}_t(x_{t-1}, w_t)} +\; c_t(x_t, u_t) + \underline{\mathcal{V}}_{t+1}^{\mathrm{rel}}(x_t) : +``` + +true feasibility inside the stage, *relaxation-priced* future outside +it. + +### What the surrogate misprices + +The quality of this policy hinges on how well the relaxed cost-to-go +``\underline{\mathcal{V}}^{\mathrm{rel}}`` prices the *true* marginal +value of the state. Relaxation only widens the stage feasible set, so +the surrogate can realize transitions the true system cannot — it +systematically **underestimates the cost of future operation** wherever +the relaxation is loose, and therefore undervalues precisely the states +whose worth derives from relieving that future stress. Whether the +resulting error is negligible or material is a property of the +*instance and its operating regime*, not of the algorithm. The +[battery-storage AC-OPF study](@ref "Stochastic battery-storage AC optimal power flow") +tests the concrete mechanism of a conic network relaxation mispricing the +locational value of stored energy. + +## The bound and the forward cost + +The inconsistent scheme produces two headline numbers with different +epistemic status: + +- ``\underline{z}^{\mathrm{rel}}`` — the converged **backward bound**: a + valid lower bound on the expected cost of the *relaxed* multistage + problem. Because relaxation only widens each stage's feasible set, it + is also a valid lower bound on the true problem — but a *slack* one: + it is attained (if at all) by relaxed trajectories that no feasible + policy can reproduce. +- ``\hat{z}`` — the **forward simulation cost**: the Monte Carlo + estimate of the expected cost of the actual operating policy on the + true stage problems. + +Their relative difference, + +```math +\mathrm{gap} \;=\; +\frac{\hat{z} - \underline{z}^{\mathrm{rel}}} + {\underline{z}^{\mathrm{rel}}}, +``` + +is the **bound-versus-forward gap**. It conflates ordinary SDDP +suboptimality, relaxation error, and finite-cut error. It is a diagnostic, +not recoverable policy headroom: the relaxed bound can be attained only by +network states that ACP cannot realize. + +The relevant empirical room compares the SDDP ACP forward cost with a +paired perfect-foresight ACP solve over the same full horizon. Even that +quantity is only an information-relaxation upper bound on possible +nonanticipative improvement. The +[battery-storage protocol](@ref "Stochastic battery-storage AC optimal power flow") +defines both quantities and keeps them separate. + +Two disciplines keep the comparison honest, and both are enforced in the +case studies: + +1. **Bounds are horizon-specific.** A bound computed on a + ``T``-stage problem does not bound a ``T' < T``-stage simulation + metric; training and evaluation horizons must be stated and matched. +2. **Policies are compared on the forward metric only.** The only number + comparable across SDDP, TS-DDR, and any other method is the simulated + expected cost under identical stage problems and identical scenarios — + hence the paired-scenario protocol of the case studies. + +## Complementarity with decision rules + +SDDP and TS-DDR occupy dual corners of the design space. SDDP +approximates the *value function* and recovers actions by re-solving a +stage problem at operation time; its strength is a self-certifying bound +and decades of industrial hardening, and its structural commitment is +convexity of the stage model that generates cuts. TS-DDR approximates the +*policy* and needs no convexity — the projection subproblem may be an +arbitrary NLP — but it certifies nothing by itself: its quality is +established empirically, by simulation against a baseline. This is why +the case studies always report both: SDDP supplies the yardstick (a bound +and a strong incumbent policy), and the decision rule is measured against +it on the true stage problems. + +## Further reading + +- Pereira & Pinto, *Multi-stage stochastic optimization applied to energy + planning*, Mathematical Programming 52 (1991) — the original SDDP paper. +- Dowson & Kapelevich, *SDDP.jl: a Julia package for stochastic dual + dynamic programming*, INFORMS Journal on Computing 33 (2021). +- Shapiro, *Analysis of stochastic dual dynamic programming method*, + EJOR 209 (2011) — convergence analysis and statistical stopping. diff --git a/examples/BatteryStorageOPF/.gitignore b/examples/BatteryStorageOPF/.gitignore new file mode 100644 index 0000000..d21c0e8 --- /dev/null +++ b/examples/BatteryStorageOPF/.gitignore @@ -0,0 +1,18 @@ +# 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/ + +# SDDP.jl writes these into the working directory when a node fails: the whole +# subproblem in MathOptFormat and the cuts it carried. They are debugging +# evidence for one run — megabytes each — and are regenerated by rerunning it. +subproblem_*.mof.json +model_infeasible_*.cuts.json +SDDP.log + +# Figures written by the `plot_*` helpers in `battery_analysis.jl`. Their paths +# are chosen by the caller — the README's `value_curves.png` and `energy.png` +# are only examples — so the name cannot be enumerated. Scoped to this example +# directory, which tracks no image of its own. +*.png diff --git a/examples/BatteryStorageOPF/Project.toml b/examples/BatteryStorageOPF/Project.toml new file mode 100644 index 0000000..8e9d422 --- /dev/null +++ b/examples/BatteryStorageOPF/Project.toml @@ -0,0 +1,38 @@ +[deps] +CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b" +Clarabel = "61c947e1-3e6d-4ee4-985a-eec8c727bd6e" +DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" +Dates = "ade2ca70-3891-5945-98fb-dc099432e06a" +Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" +Ipopt = "b6b21f68-93f8-5de0-b562-5493be1d77c9" +JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +JuMP = "4076af6c-e467-56ae-b986-b466b2749572" +LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee" +PGLib = "07a8691f-3d11-4330-951b-3c50f98338be" +Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" +PowerModels = "c36e90e8-916a-50a6-bd94-075b64ef4655" +Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7" +Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +SCS = "c946c3f1-0d1f-5ce8-9dea-7daa1f7e2d13" +SDDP = "f4570300-c277-11e8-125c-4912f86ce65d" +SHA = "ea8e919c-243c-51af-8825-aaa63cd721ce" +StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3" +Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[compat] +CSV = "0.10" +Clarabel = "0.11" +DataFrames = "1" +Distributions = "0.25" +Ipopt = "1" +JSON = "0.21, 1" +JuMP = "1" +MathOptInterface = "1" +PGLib = "0.2" +Plots = "1" +PowerModels = "0.21" +SDDP = "1.14" +StableRNGs = "1" +julia = "1.11, 1.12" diff --git a/examples/BatteryStorageOPF/README.md b/examples/BatteryStorageOPF/README.md new file mode 100644 index 0000000..810befe --- /dev/null +++ b/examples/BatteryStorageOPF/README.md @@ -0,0 +1,499 @@ +# Battery-storage AC-OPF — JuMP / PowerModels / SDDP engine + +This example is the CPU half of the multistage battery-storage study. It does +two things: + +1. it is a **reusable toolkit** for building and diagnosing battery cases on top + of any PGLib benchmark — acquire a case, place batteries, author a demand + process, freeze it into finite support, probe the physics and the value of + stored energy, solve perfect-foresight equivalents, and train the SDDP + baseline; +2. it is the **construction of this study's own benchmark**, built with exactly + those tools and nothing else. + +The scientific narrative — what the experiment asks and what it found — lives in +the documentation. This file says how to run things and what each file is for. + +The GPU half (the ExaModels true-ACP model, the strict reachable policy and the +TS-DDR trainer) lives in `DecisionRulesExa.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. + +Everything below runs from this directory with `julia --project=.`, needs no +cluster scheduler and writes no telemetry. + +## The boundary between the packages and this example + +| owned by | what | +|---|---| +| PGLib.jl | the benchmark case and its parser | +| PowerModels.jl | buses, generators, branches, voltage variables, reference angle, Ohm's law at both ends with taps and phase shifts, shunts, angle-difference limits, apparent-power limits at both ends, nodal active and reactive balances, generator bounds and costs, and the `ACPPowerModel` / `SOCWRConicPowerModel` formulations themselves | +| SDDP.jl | policy graph, state variables, sampling, cut generation, training, simulation | +| Distributions.jl | the laws an authoring demand sampler is built from | +| this example | batteries: energy state, charge/discharge, state transition, unity-power-factor injection, throughput cost, the strict outgoing-energy target equality, the two-sided nodal active-power recourse, and the demand parameterization | + +No AC trigonometry and no SOC-WR lifted branch equation is written here. The +regression suite scans the model-building files and the diagnostics and fails if +one appears. + +## Files + +| file | role | +|---|---| +| `battery_case.jl` | the frozen case contract: canonical JSON, artifact hashes, battery parameters, the one-stage reachable interval, the **frozen finite demand support**, the battery-placement API, and the reproducible evaluation protocol. **Byte-identical copy in the Exa package.** | +| `battery_solution_schema.jl` | the shared long-format solution schema, and an engine-neutral recomputation of the physical residuals. **Byte-identical copy in the Exa package.** | +| `battery_demand.jl` | the **authoring** side of demand: the composable sampler abstraction, the deterministic profile, sampler validation, and `freeze_demand_support` | +| `build_battery_case.jl` | PGLib acquisition and validation, recourse pricing, the general case constructor, the correctness case, the research case, and the Exa mirror | +| `battery_powermodels.jl` | the battery layer on top of PowerModels: the shared problem specification, stage-model construction, the strict stage solve with its multipliers, nodal prices, binding limits, solution extraction, and the runtime provenance assertion | +| `battery_diagnostics.jl` | the diagnostic toolkit: incoming-energy sampling, the targetless probe, the fixed-outgoing-energy value curve, the multiperiod deterministic equivalent and the perfect-foresight panel | +| `battery_analysis.jl` | tables and figures over the shared schema | +| `battery_sddp.jl` | the SDDP baseline: SOC-WR backward graph, true-ACP forward graph, stock cuts, paired simulation on a protocol | +| `test/runtests.jl` | the consolidated regression suite | +| `case//` | the constructed artifacts: `network.json`, `batteries.json`, `demand.json`, `case_manifest.json`. **Not committed** — see below. | + +--- + +# The user workflow + +The whole workflow is nine calls. Everything below is a single Julia session +started with `julia --project=.`. + +```julia +include("build_battery_case.jl") # → battery_case.jl, battery_demand.jl +include("battery_diagnostics.jl") # → battery_powermodels.jl +include("battery_analysis.jl") +``` + +## 1. Obtain any PGLib case + +```julia +src = acquire_pglib_case("pglib_opf_case30_ieee") +src.report # counts, totals, connected component, generation headroom +src.versions # the PGLib / PowerModels / Julia versions the bytes came from +``` + +`acquire_pglib_case` preserves the benchmark's own component identifiers — PGLib +cases contain nonconsecutive ones — and validates that every in-service component +sits on an existing bus, that every in-service bus is connected to the reference +bus, and that the case has a positively priced generator and positive load. + +PGLib ships three libraries per benchmark and they are **different systems, not +different settings of one**. The suffix selects it: + +```julia +acquire_pglib_case("pglib_opf_case30_ieee") # typical operating condition +acquire_pglib_case("pglib_opf_case30_ieee__api") # congested (active power increase) +acquire_pglib_case("pglib_opf_case30_ieee__sad") # small angle difference +``` + +## 2. Specify or randomly sample battery locations + +```julia +# explicit +buses, prec = select_battery_buses(src.network, ExplicitPlacement([5, 12, 30])) + +# a reproducible uniform draw from the load buses +buses, prec = select_battery_buses(src.network, SampledPlacement(3; seed = 7)) + +# weighted by nominal demand +load_at = nominal_load_at_bus(src.network) +buses, prec = select_battery_buses(src.network, + SampledPlacement(3; seed = 7, weight = b -> max(0.0, get(load_at, b, 0.0)))) + +# a custom eligibility rule, and a custom placement rule +select_battery_buses(src.network, SampledPlacement(2; seed = 7); + eligible = bus -> Float64(bus["vmax"]) >= 1.06) +select_battery_buses(src.network, CallablePlacement( + (candidates, meta) -> candidates[1:2]; name = "two-lowest-ids")) +``` + +Eligibility rejects nonexistent, out-of-service and disconnected buses, and a +sampled draw is without replacement. `prec` is the manifest record: the full +eligible pool, the strategy, the seed, the weights and the selection. + +## 3. Configure capacities and initial energy + +```julia +total = sum(max(0.0, v) for v in values(nominal_load_at_bus(src.network))) +fleet, crec = battery_fleet(src.network, buses; + power = 0.04 * total, # pu, per battery + energy_hours = 2.0, # duration at full power + charge_efficiency = 0.95, discharge_efficiency = 0.95, + self_discharge = 0.999, throughput_cost = 5.0, + initial_fraction = 0.5) +``` + +Every rating accepts a scalar, a `Dict` keyed by bus, or a callable — which is +how a **sampled** capacity is expressed without the case contract depending on +Distributions.jl: + +```julia +rng = StableRNG(4) +fleet, _ = battery_fleet(src.network, buses; + power = _ -> rand(rng, Uniform(0.2, 0.4)), energy_hours = 2.0) +``` + +## 4. Define a demand sampler + +Demand is the only uncertainty. For the original PGLib load values, the realized +demand of load `i` at stage `t` is + +``` +pd[i,t] = h[i,t] * m[i,t] * pd0[i] +qd[i,t] = h[i,t] * m[i,t] * qd0[i] +``` + +with `h` a deterministic profile and `m` the uncertain multiplier. The **same** +multiplier scales active and reactive demand, so every realization preserves each +load's own power factor. + +A sampler's fundamental output is a **joint multiplier vector** over the case's +loads — not a scalar, and not an implicit collection of independent draws. + +```julia +meta = demand_meta(src.network) # load_ids, load_bus, nominal_pd/qd, num_loads +``` + +**A `Distribution`, system-wide:** + +```julia +sampler = SystemMultiplier(Uniform(0.9, 1.1)) +sampler = SystemMultiplier(DiscreteNonParametric([0.95, 1.0, 1.05], fill(1/3, 3))) +``` + +**Independent per load (a convenience, not the general interface):** + +```julia +sampler = IndependentMultiplier(LogNormal(0.0, 0.05)) +sampler = IndependentMultiplier(Dict(3 => Uniform(0.8, 1.2))) # others deterministic +``` + +**Regional finite atoms — a genuinely correlated joint vector:** + +```julia +pocket = [j for j in 1:meta.num_loads if meta.load_bus[j] in [1,3,5,6,7,8,9,14]] +sampler = GroupMultiplier( + [meta.load_ids[pocket], setdiff(meta.load_ids, meta.load_ids[pocket])], + [DiscreteNonParametric([0.96, 1.04], [0.5, 0.5]), + DiscreteNonParametric([0.99, 1.01], [0.5, 0.5])]) +``` + +**A custom callable** — the general interface every other sampler is a +convenience over: + +```julia +sampler = CallableMultiplier( + (rng, t, meta) -> 1.0 .+ 0.05 .* randn(rng, meta.num_loads) .* (t > 12); + name = "late-stage jitter") +``` + +**Explicit atoms, and stage dependence:** + +```julia +sampler = FiniteMultiplier([0.9, 1.0, 1.1], [0.25, 0.5, 0.25]) +sampler = StageMultiplier([t <= 12 ? DeterministicMultiplier(1.0) : sampler + for t in 1:24]) +``` + +**Composition** multiplies element-wise, so a system-wide level, a regional +effect and a per-load term compose without knowing about each other: + +```julia +sampler = ProductMultiplier(SystemMultiplier(Uniform(0.98, 1.02)), + GroupMultiplier(...), IndependentMultiplier(...)) +``` + +Check it before freezing: + +```julia +validate_sampler(sampler, src.network, 24) +``` + +which asserts the output dimension and load order, finiteness and +nonnegativity, exact seeded reproduction, that the sampler does not reach for the +global RNG, that every load keeps its power factor, and that any declared finite +support normalizes. + +## 5. Freeze the sampler into finite support + +**Both SDDP and TS-DDR train from finite support.** A general sampler or a +continuous `Distribution` is an *authoring mechanism*; before either method +trains, it is materialized into a frozen, hashed, stage-major support + +``` +W_t = { (w_{t,1}, p_{t,1}), …, (w_{t,K_t}, p_{t,K_t}) } +``` + +and both engines read the **same bytes**. Neither method may resample or +rediscretize the authoring law on its own — that is the boundary that makes "the +two methods faced the same stochastic program" a checkable statement. + +```julia +support = freeze_demand_support(sampler, src.network, 30; + seed = 20260805, + method = :auto, # :exact | :empirical | :auto + atoms_per_stage = 8, # for an empirical freeze + profile = diurnal_profile(30), + profile_period = 24, + stage_hours = 1.0, + protocol_seed = 20260805) +support_digest(support) +``` + +- an **explicitly discrete** sampler keeps its support and probabilities exactly + — no reweighting, no resampling, only exact-duplicate merging; +- a **continuous or general** sampler is discretized transparently: draw + `atoms_per_stage` joint vectors per stage from `StableRNG(seed)` and weight them + equally. It is reproducible from `(seed, atoms_per_stage)` alone and claims no + moment matching. A different discretizer is declared by giving the sampler a + `support` callable; there is no hidden quadrature rule. + +The frozen support records the authoring sampler's description, the seed, the +atom count, the method and the resulting atoms in `demand.json`. + +**Four distinct objects, and the README will not conflate them:** + +| object | what it is | where it lives | +|---|---|---| +| authoring sampler | an arbitrary joint law, possibly continuous | your code, never a case | +| frozen training support | finite atoms + probabilities per stage, hashed | `demand.json`, mirrored to both engines | +| screening protocol | a small set of global scenario IDs drawn from that support, used while choosing a case and selecting checkpoints | regenerated from `protocol_seed` | +| final unseen protocol | a fresh, larger paired protocol no policy was ever selected on | regenerated from the manifest, evaluated once | + +## 6. Build and verify the manifest + +```julia +case = build_case(src; dir = "case/my_case", batteries = fleet, support = support, + placement = Dict("buses" => prec, "capacity" => crec), + protocol_stages = 30, protocol_scenarios = 500) +verify("case/my_case") +``` + +`build_case` writes the four artifacts, records every hash, and reads the case +back **through the verifier** — a case that cannot be re-read is a build failure +rather than a later mystery. Two properties are deliberately fail-closed, because +both have historically corrupted a study silently: the stage duration must be +present, positive and agree with the manifest, and every artifact must hash to +what the manifest records. + +## 7. Sample incoming battery energies + +```julia +states = sample_incoming_energy(case; kind = :uniform, seed = 3, batch = 8) +sample_incoming_energy(case; kind = :fixed, level = 0.5) +sample_incoming_energy(case; kind = :distribution, dist = Beta(2, 2), seed = 3, batch = 4) +sample_incoming_energy(case; kind = :callable, callable = (rng, b, m) -> 0.25, seed = 1) +``` + +The state is sampled in NORMALIZED terms and mapped into each battery's own +bounds, so a sampler transfers unchanged to a case with different ratings. Every +resulting energy is validated. This samples **diagnostic initial states only** — +it is not the demand process and plays no part in training or evaluation. + +## 8. Run targetless single-stage probes + +```julia +p = targetless_probe(case, PowerModels.ACPPowerModel; + energy_in = states[1], stage = 19, atom = 2) +p.cost_stage, p.cost_generation, p.cost_deficit, p.cost_surplus +p.energy_out, p.p_ch, p.p_dis, p.p_bat, p.simultaneous +p.vm, p.va, p.p_fr, p.q_to, p.price_active, p.price_reactive +p.energy_in_dual # ∂Q/∂e_in — what the INHERITED energy was worth +p.residuals # recomputed independently of the engine +binding_table(p) # what stopped the network +``` + +The same call with `PowerModels.SOCWRConicPowerModel` runs the relaxation, and +`targetless_batch` sweeps incoming-energy vectors × stages × atoms, keeping every +combination including the failures. + +> **A targetless one-stage solve is myopic.** Nothing in it prices the energy +> left in a battery at the end of the stage, so it will rationally discharge as +> much as is useful and leave the battery empty. That is the definition of a +> one-stage problem, not a finding. Read it for the physics — what the network +> could deliver, what limit stopped it, what the energy the stage *inherited* was +> worth — and read the next section for the value of what is left behind. + +## 9. Inspect fixed-target value curves and nodal prices + +```julia +b = first(case.batteries) +lo, hi = reachable_interval(b, states[1][b.index], stage_hours(case)) +cmp = compare_value_curves(case; battery = b.index, energy_in = states[1], + stage = 19, atom = 2, + grid = collect(range(lo, hi; length = 9))) +value_curve_table(cmp) +plot_value_curves(cmp, "value_curves.png") +``` + +The outgoing energy is fixed by the **same hard equality the strict formulation +uses** — there is no target slack anywhere — so the reported multiplier is +`∂Q/∂e_out`, the price the model puts on carrying one more unit of energy out of +the stage. + +Three properties of the check matter: + +- **finite differences confirm the interior multipliers.** The value curve is + convex and *piecewise* smooth — a binding limit puts a kink in it — so each + interior point is classified first, and `λ` is compared against a central + difference only where the curve is locally smooth. At a kink the correct + statement is that `λ` lies *between* the one-sided slopes, and `bracketed` + records it. +- **endpoints are not evidence.** At an endpoint of the reachable interval the + target sits on a bound, `λ` is a subgradient, and two solvers may report two + valid values orders of magnitude apart. +- **points that used physical recourse are excluded.** There, part of the + marginal value is the recourse *price* — chosen to be far above any generator — + rather than the network's valuation of stored energy. + +The quantity that carries a finding is `dlambda = λ_SOC − λ_ACP`, and its +locational *ranking*: a uniform level shift changes nothing about where a policy +puts energy, a change in the order of buses changes everything. + +```julia +marginal_value_table([cmp1, cmp2, ...]) # rank_acp, rank_soc, rank_changed +``` + +## 10. Solve one multiperiod deterministic equivalent + +```julia +proto = scenario_index_matrix(case.demand, 30, 500) +de = deterministic_equivalent(case, proto[:, 1]) # true ACP +de.total_cost, de.stage_cost, de.cumulative_cost +de.energy_terminal, de.throughput, de.simultaneous +de.worst_deficit, de.worst_surplus, de.residuals +stage_cost_table(de); battery_table(de, case); price_table(de, case) +plot_energy_trajectory(de, case, "energy.png") +``` + +The whole horizon is solved at once, knowing the entire demand path: no policy, +no target, no target slack, no future-cost approximation. It is assembled from +the same per-stage builder the study trains on — one PowerModels model per stage, +all in one JuMP model, coupled only by `e_in[t+1] == e_out[t]`. + +The same call with `model_type = PowerModels.SOCWRConicPowerModel` gives the +**relaxed** perfect-foresight solve. That is a diagnostic, not a physical +reference: its cost is not attainable. + +## 11. Calculate a small perfect-foresight panel + +```julia +panel = perfect_foresight_panel(case, proto; ids = 1:8) +panel.complete, panel.mean, panel.std, panel.sem +panel_table(panel) +``` + +Every requested identifier is retained: none is replaced, dropped or renumbered, +a first-attempt failure is re-solved once with a completely fresh model, and both +statuses are recorded. If any identifier is unsolved the panel is marked +incomplete — a mean over the scenarios that happened to succeed is a mean over a +different problem. + +> **What the mean is, and is not.** The true-ACP perfect-foresight mean is a +> **wait-and-see lower bound** on the nonanticipative stochastic problem: a +> clairvoyant operator cannot be beaten by one who must decide before seeing the +> future. The gap between a policy and this bound is diagnostic **headroom**, and +> it *contains the value of future information*, which no nonanticipative policy +> — TS-DDR or SDDP — can recover. It is not a target and it is not attainable. +> The bound may be computed while screening candidates; its relationship to a +> trained policy is assessed only on **paired** paths, after that policy exists. + +## 12. Train and evaluate SDDP + +```julia +trained = train_battery_sddp(case; num_stages = 30, iteration_limit = 300) +trained.bound # over the SOC-WR relaxation, over 30 stages +assert_graph_provenance(trained.backward, PowerModels.SOCWRConicPowerModel) +assert_graph_provenance(trained.forward, PowerModels.ACPPowerModel) + +sims = simulate_battery_sddp_on(trained, proto; + ids = [b.index for b in case.batteries], columns = 1:8) +costs = [sum(s[t][:stage_objective] for t in 1:30) for s in sims] +paired_difference(costs, [panel.results[c].total_cost for c in 1:8]) +``` + +The backward pass is an actual `PowerModels.SOCWRConicPowerModel`, the forward +pass an actual `PowerModels.ACPPowerModel`, and the two are joined by SDDP.jl's +own `AlternativeForwardPass` / `AlternativePostIterationCallback`. No +`duality_handler` is overridden and no cut is filtered, retried or reweighted. + +The bound is a bound on the **SOC-WR relaxation over the horizon it was trained +on**. Quoting it beside a forward cost accumulated over a different number of +stages compares two different quantities, and nothing here invites that. + +`simulate_battery_sddp_on` replays a fixed protocol through `SDDP.Historical`, +which is what makes an SDDP cost **paired** with a perfect-foresight cost and, +later, with a TS-DDR cost. + +## 13. Where strict TS-DDR enters + +Nothing above trains a policy. Strict TS-DDR is the GPU engine's business: +`DecisionRulesExa.jl/examples/BatteryStorageOPF` reads the **same frozen case +bytes and the same frozen support**, builds the multistage true-ACP +deterministic equivalent in ExaModels, evaluates the reachable policy before each +stage, and differentiates the stage value through the strict target multiplier. +This engine's role afterwards is to replay and verify what that engine produced, +through the shared solution schema. + +--- + +## Commands + +```bash +# rebuild (and mirror) the correctness case from PGLib +DR_BAT_MIRROR=/path/to/DecisionRulesExa.jl/examples/BatteryStorageOPF \ + julia --project=. build_battery_case.jl + +# re-verify a frozen case in place: hashes, schemas, stage duration, support, protocol +julia --project=. build_battery_case.jl --verify + +# stock SDDP: SOC-WR backward, true-ACP forward, construction smoke +julia --project=. battery_sddp.jl + +# the consolidated regression suite +julia --project=. test/runtests.jl +``` + +## Environment variables + +Case construction (`build_battery_case.jl`): + +| variable | meaning | +|---|---| +| `DR_BAT_CASE` | PGLib case name (default `pglib_opf_case14_ieee`) | +| `DR_BAT_DIR` | output directory for the artifacts | +| `DR_BAT_NUM` | number of batteries to place | +| `DR_BAT_BUSES` | comma-separated explicit bus override; bypasses the seeded draw | +| `DR_BAT_SEED` | seed of the deterministic placement draw | +| `DR_BAT_HORIZON` | frozen horizon | +| `DR_BAT_PROTOCOL_SEED`, `DR_BAT_PROTOCOL_STAGES`, `DR_BAT_PROTOCOL_SCENARIOS` | the evaluation protocol the manifest records a digest for | +| `DR_BAT_MIRROR` | Exa example directory to mirror the case and shared sources into | + +SDDP smoke (`battery_sddp.jl`): `DR_BAT_SDDP_STAGES` (3), `DR_BAT_SDDP_ITERATIONS` +(10), `DR_BAT_SDDP_SIMS` (6). + +## What the recourse variables are, and are not + +Every bus carries two nonnegative, UNCAPPED variables — a deficit injection `d` +and a surplus sink `s` — which enter the ACTIVE nodal balance with opposite +signs and are priced far above any generator. They are physical operating +recourse: they are what makes a dynamically reachable battery target attainable +under the true network, and they are charged identically in the ACP model, the +SOC-WR model, both SDDP passes and the Exa engine. + +They are NOT target slack. There is no target-slack variable, no target penalty +and no soft-target formulation anywhere in the supported workflow; the strict +target is a hard equality whose multiplier is the actor signal. A policy that +uses either recourse variable materially is rejected, not priced — and a +diagnostic point that used one is excluded from the evidence rather than +reported. + +## Expected outputs + +`build_battery_case.jl` prints the case summary and the artifact, support and +protocol digests. `battery_sddp.jl` prints the SOC-WR bound over its own horizon, +the number of stock cuts created, the true-ACP forward cost over the simulated +paths, the worst recourse on any simulated stage, and one battery's energy +trajectory. The bound and the forward cost are quoted over the SAME horizon; a +bound never bounds a metric accumulated over a different number of stages. diff --git a/examples/BatteryStorageOPF/battery_analysis.jl b/examples/BatteryStorageOPF/battery_analysis.jl new file mode 100644 index 0000000..0dc32e4 --- /dev/null +++ b/examples/BatteryStorageOPF/battery_analysis.jl @@ -0,0 +1,467 @@ +# battery_analysis.jl +# +# Tables and figures for the battery-storage study. +# +# Everything here consumes the SHARED SOLUTION SCHEMA — the long +# `(scenario, stage, class, index, value)` format defined in +# `battery_solution_schema.jl` — or the named tuples the diagnostics return. +# Nothing reads a solver-specific internal layout, which is what lets one plot +# overlay a JuMP trajectory and an ExaModels trajectory without either engine +# knowing about the other. +# +# Figures are written to files rather than displayed: this study runs on cluster +# nodes without a display, and a figure that only exists in a REPL cannot be +# regenerated from the evidence. + +using DataFrames +using Plots +using Printf +using Statistics + +@isdefined(SolutionRecorder) || include(joinpath(@__DIR__, "battery_solution_schema.jl")) + +# Headless rendering: GR opens no window and writes straight to the file. +ENV["GKSwstype"] = get(ENV, "GKSwstype", "100") + +# ───────────────────────────────────────────────────────────────────────────── +# The schema as a DataFrame +# ───────────────────────────────────────────────────────────────────────────── + +""" + solution_frame(source) -> DataFrame + +Read the shared solution schema into a long `DataFrame` with columns +`scenario, stage, class, index, value`. + +# Arguments +- `source`: a path to a solution CSV, a [`SolutionRecorder`](@ref), or the + dictionary [`read_solution`](@ref) returns. + +# Notes +Long format is kept all the way to the plotting layer. Widening happens per +figure, through [`pivot_class`](@ref), because different figures widen on +different keys and a single wide table would have to guess which. +""" +function solution_frame(source) + rows = if source isa SolutionRecorder + source.rows + elseif source isa AbstractString + [(k[1], k[2], k[3], k[4], v) for (k, v) in read_solution(source)] + elseif source isa AbstractDict + [(k[1], k[2], k[3], k[4], v) for (k, v) in source] + else + error("solution_frame: unsupported source of type $(typeof(source))") + end + df = DataFrame(scenario = [r[1] for r in rows], stage = [r[2] for r in rows], + class = [r[3] for r in rows], index = [r[4] for r in rows], + value = [r[5] for r in rows]) + return sort!(df, [:scenario, :stage, :class, :index]) +end + +""" + pivot_class(df, class; scenario=nothing) -> DataFrame + +One row per stage, one column per component identifier, for a single class. + +# Notes +Column names are the component IDENTIFIERS as strings, never positions, so a +table built from a case with nonconsecutive identifiers still names the right +component. +""" +function pivot_class(df::DataFrame, class::AbstractString; scenario = nothing) + sub = scenario === nothing ? df[df.class .== class, :] : + df[(df.class .== class) .& (df.scenario .== scenario), :] + isempty(sub) && return DataFrame(stage = Int[]) + return unstack(sub, :stage, :index, :value; renamecols = i -> Symbol(string(i))) +end + +# ───────────────────────────────────────────────────────────────────────────── +# Tables +# ───────────────────────────────────────────────────────────────────────────── + +""" + stage_cost_table(result) -> DataFrame + +Per-stage cost decomposition of a [`deterministic_equivalent`](@ref) result: the +generation, throughput, deficit and surplus components, the stage total and the +running total. + +# Notes +The cumulative column is what makes a stagewise comparison readable: two policies +that differ by a fraction of a percent per stage are indistinguishable stage by +stage and obvious cumulatively. +""" +function stage_cost_table(result) + T = result.horizon + return DataFrame( + stage = 1:T, + generation = [result.stages[t].cost_generation for t in 1:T], + throughput = [result.stages[t].cost_throughput for t in 1:T], + deficit = [result.stages[t].cost_deficit for t in 1:T], + surplus = [result.stages[t].cost_surplus for t in 1:T], + total = [result.stages[t].cost_stage for t in 1:T], + cumulative = cumsum([result.stages[t].cost_stage for t in 1:T]), + ) +end + +""" + battery_table(result, case) -> DataFrame + +Per-stage, per-battery energy, charging, discharging, throughput and the +simultaneous-operation measure. + +# Notes +`simultaneous = min(p_ch, p_dis)` is reported because a continuous relaxation of +the charge/discharge complementarity CAN return a solution that does both at +once, and a positive throughput cost is the only thing making that suboptimal. A +column of zeros here is what licenses reading `p_bat` as a physical injection. +""" +function battery_table(result, case::BatteryCase) + rows = DataFrame(stage = Int[], battery = Int[], bus = Int[], + energy_in = Float64[], energy_out = Float64[], + p_ch = Float64[], p_dis = Float64[], p_bat = Float64[], + throughput = Float64[], simultaneous = Float64[]) + Δt = stage_hours(case) + for t in 1:result.horizon, b in case.batteries + s = result.stages[t] + push!(rows, (t, b.index, b.bus, s.energy_in[b.index], s.energy_out[b.index], + s.p_ch[b.index], s.p_dis[b.index], s.p_bat[b.index], + Δt * (s.p_ch[b.index] + s.p_dis[b.index]), + min(s.p_ch[b.index], s.p_dis[b.index]))) + end + return rows +end + +""" + price_table(result, case; buses=nothing) -> DataFrame + +Per-stage active and reactive nodal prices. + +# Notes +Reactive prices are reported alongside active ones because on a case where +storage matters for VOLTAGE support rather than for energy arbitrage, the +reactive price is where the mechanism shows — and a study that only tabulates +active prices would report that nothing is happening. +""" +function price_table(result, case::BatteryCase; buses = nothing) + ids = buses === nothing ? sort!([Int(b["index"]) for (_, b) in case.network["bus"]]) : + collect(Int.(buses)) + rows = DataFrame(stage = Int[], bus = Int[], price_active = Float64[], + price_reactive = Float64[], vm = Float64[], + deficit = Float64[], surplus = Float64[]) + for t in 1:result.horizon, i in ids + s = result.stages[t] + push!(rows, (t, i, get(s.price_active, i, NaN), get(s.price_reactive, i, NaN), + s.vm[i], s.deficit[i], s.surplus[i])) + end + return rows +end + +""" + value_curve_table(cmp) -> DataFrame + +The ACP-versus-SOC-WR value curve comparison of +[`compare_value_curves`](@ref), one row per grid point. + +# Notes +The column that carries the finding is `dlambda`: the difference in the MARGINAL +value of stored energy. `dcost` — the difference in the value curves themselves — +is reported beside it and is expected to be nonzero everywhere, because a +relaxation is below the true model by construction. Reading the level difference +as the mechanism is the mistake this table is laid out to prevent. +""" +function value_curve_table(cmp) + n = length(cmp.energy) + return DataFrame( + energy = cmp.energy, + reachable = cmp.acp.reachable, + endpoint = cmp.acp.endpoint, + nonsmooth = cmp.acp.nonsmooth, + value_acp = cmp.acp.value, + value_soc = cmp.soc.value, + dcost = cmp.acp.value .- cmp.soc.value, + lambda_acp = cmp.acp.lambda, + lambda_soc = cmp.soc.lambda, + dlambda = cmp.dlambda, + fd_acp = cmp.acp.fd, + fd_error_acp = cmp.acp.fd_error, + recourse_acp = cmp.acp.worst_recourse, + ) +end + +""" + marginal_value_table(comparisons) -> DataFrame + +One row per probed battery: the interior ACP and SOC-WR marginal stored-energy +values and their disagreement, with the LOCATIONAL RANK each formulation assigns. + +# Arguments +- `comparisons`: an iterable of [`compare_value_curves`](@ref) results. + +# Notes +Ranking is the point. A uniform level shift in the relaxation's marginal values +changes nothing about where a policy puts energy; a change in the ORDER of buses +does. `rank_acp != rank_soc` is the decision-level evidence that a cut built on +the relaxation would steer storage to a different place from the truth. + +Interior points only — see [`energy_value_curve`](@ref) on why a multiplier at a +reachable-interval endpoint is not comparable across solvers. +""" +function marginal_value_table(comparisons) + rows = DataFrame(battery = Int[], bus = Int[], stage = Int[], atom = Int[], + lambda_acp = Float64[], lambda_soc = Float64[], + dlambda = Float64[], rel_dlambda = Float64[], + reversal = Bool[], num_interior = Int[], + num_recourse_excluded = Int[]) + for c in comparisons + idx = c.interior + isempty(idx) && continue + λa = mean(c.acp.lambda[idx]) + λs = mean(c.soc.lambda[idx]) + push!(rows, (c.acp.battery, c.acp.bus, c.acp.stage, c.acp.atom, + λa, λs, λs - λa, (λs - λa) / max(abs(λa), 1e-8), + c.reversal, length(idx), c.num_recourse_excluded)) + end + isempty(rows) && return rows + rows.rank_acp = competerank_desc(rows.lambda_acp) + rows.rank_soc = competerank_desc(rows.lambda_soc) + rows.rank_changed = rows.rank_acp .!= rows.rank_soc + return rows +end + +""" + competerank_desc(v) -> Vector{Int} + +Descending competition rank of `v`: the largest value gets rank 1, ties share the +smaller rank. + +# Notes +Written out rather than pulled from StatsBase, which this example does not +otherwise need, and ties are handled explicitly because two buses with equal +marginal value are not "differently ranked" in any meaningful sense. +""" +function competerank_desc(v::AbstractVector) + order = sortperm(v; rev = true) + r = Vector{Int}(undef, length(v)) + prev = NaN + prev_rank = 0 + for (pos, i) in enumerate(order) + if !(v[i] ≈ prev) + prev_rank = pos + prev = v[i] + end + r[i] = prev_rank + end + return r +end + +""" + binding_table(probe; limit=20) -> DataFrame + +The binding and nearly binding limits of a probe, most binding first. +""" +function binding_table(probe; limit::Integer = 20) + rows = first(probe.binding, limit) + return DataFrame(kind = [r.kind for r in rows], index = [r.index for r in rows], + side = [r.side for r in rows], value = [r.value for r in rows], + limit = [r.limit for r in rows], slack = [r.slack for r in rows]) +end + +""" + panel_table(panel) -> DataFrame + +One row per scenario of a [`perfect_foresight_panel`](@ref), with the statuses +kept as strings so a failed scenario survives a CSV round-trip. +""" +function panel_table(panel) + return DataFrame(scenario = [r.scenario for r in panel.rows], + solved = [r.solved for r in panel.rows], + first_status = [string(r.first_status) for r in panel.rows], + status = [string(r.status) for r in panel.rows], + cost = [r.cost for r in panel.rows], + worst_deficit = [r.worst_deficit for r in panel.rows], + worst_surplus = [r.worst_surplus for r in panel.rows], + simultaneous = [r.simultaneous for r in panel.rows], + terminal_energy = [r.terminal_energy for r in panel.rows], + throughput = [r.throughput for r in panel.rows]) +end + +# ───────────────────────────────────────────────────────────────────────────── +# Figures +# ───────────────────────────────────────────────────────────────────────────── + +""" + plot_value_curves(cmp, path) -> String + +Two stacked panels: the ACP and SOC-WR value curves, and the marginal value of +stored energy under each. + +# Notes +The marginal values go on their OWN panel rather than a twin axis. The two levels +routinely differ by less than a percent while the quantity being studied is that +difference, and overlaying them on one axis makes a difference of interest look +like a coincident pair of lines. + +Reachable-interval endpoints are drawn as open markers, because a multiplier +there is a subgradient and comparing two solvers' subgradients is not evidence. +""" +function plot_value_curves(cmp, path::AbstractString) + e = cmp.energy + ok = cmp.acp.solved .& cmp.soc.solved + interior = ok .& .!cmp.acp.endpoint + + top = plot(e[ok], cmp.acp.value[ok]; label = "ACP (true)", lw = 2, + ylabel = "stage cost", legend = :topleft) + plot!(top, e[ok], cmp.soc.value[ok]; label = "SOC-WR (relaxation)", lw = 2, ls = :dash) + + bot = plot(e[interior], cmp.acp.lambda[interior]; label = "∂Q/∂e ACP", lw = 2, + xlabel = "outgoing energy of battery $(cmp.acp.battery) at bus $(cmp.acp.bus) (pu·h)", + ylabel = "marginal value", legend = :topleft) + plot!(bot, e[interior], cmp.soc.lambda[interior]; label = "∂Q/∂e SOC-WR", lw = 2, ls = :dash) + endpoints = ok .& cmp.acp.endpoint + any(endpoints) && scatter!(bot, e[endpoints], cmp.acp.lambda[endpoints]; + label = "endpoint (subgradient)", markershape = :circle, + markercolor = :white) + + fig = plot(top, bot; layout = (2, 1), size = (860, 620), + title = ["stage $(cmp.acp.stage), atom $(cmp.acp.atom)" ""]) + savefig(fig, path) + return path +end + +""" + plot_energy_trajectory(result, case, path) -> String + +Battery energy, charging and discharging over the horizon of one deterministic +equivalent. +""" +function plot_energy_trajectory(result, case::BatteryCase, path::AbstractString) + T = result.horizon + top = plot(; ylabel = "stored energy (pu·h)", legend = :topright) + bot = plot(; ylabel = "power (pu)", xlabel = "stage", legend = :topright) + for b in case.batteries + plot!(top, 1:T, [result.stages[t].energy_out[b.index] for t in 1:T]; + label = "battery $(b.index) @ bus $(b.bus)", lw = 2) + plot!(bot, 1:T, [result.stages[t].p_bat[b.index] for t in 1:T]; + label = "net injection $(b.index)", lw = 2) + end + hline!(bot, [0.0]; label = "", lc = :black, ls = :dot) + fig = plot(top, bot; layout = (2, 1), size = (860, 620)) + savefig(fig, path) + return path +end + +""" + plot_stage_costs(results, labels, path) -> String + +Stage and cumulative cost of one or more deterministic equivalents. + +# Notes +Cumulative cost is plotted as a DIFFERENCE from the first series when more than +one is given: two trajectories whose cumulative costs differ by a fraction of a +percent are one line at any readable scale, and the difference is the quantity. +""" +function plot_stage_costs(results, labels, path::AbstractString) + T = results[1].horizon + top = plot(; ylabel = "stage cost", legend = :topleft) + for (r, l) in zip(results, labels) + plot!(top, 1:T, r.stage_cost; label = l, lw = 2) + end + bot = if length(results) == 1 + plot(1:T, results[1].cumulative_cost; label = labels[1], lw = 2, + ylabel = "cumulative cost", xlabel = "stage", legend = :topleft) + else + p = plot(; ylabel = "cumulative Δcost vs $(labels[1])", xlabel = "stage", + legend = :topleft) + for (r, l) in zip(results[2:end], labels[2:end]) + plot!(p, 1:T, r.cumulative_cost .- results[1].cumulative_cost; label = l, lw = 2) + end + hline!(p, [0.0]; label = "", lc = :black, ls = :dot) + p + end + fig = plot(top, bot; layout = (2, 1), size = (860, 620)) + savefig(fig, path) + return path +end + +""" + plot_prices(result, case, path; buses=nothing) -> String + +Active and reactive nodal prices over the horizon, plus the voltage magnitude at +the same buses. +""" +function plot_prices(result, case::BatteryCase, path::AbstractString; buses = nothing) + ids = buses === nothing ? sort!(unique(b.bus for b in case.batteries)) : collect(Int.(buses)) + T = result.horizon + pa = plot(; ylabel = "active price", legend = :topleft) + pr = plot(; ylabel = "reactive price", legend = :topleft) + pv = plot(; ylabel = "|V| (pu)", xlabel = "stage", legend = :topleft) + for i in ids + plot!(pa, 1:T, [get(result.stages[t].price_active, i, NaN) for t in 1:T]; + label = "bus $i", lw = 2) + plot!(pr, 1:T, [get(result.stages[t].price_reactive, i, NaN) for t in 1:T]; + label = "bus $i", lw = 2) + plot!(pv, 1:T, [result.stages[t].vm[i] for t in 1:T]; label = "bus $i", lw = 2) + end + fig = plot(pa, pr, pv; layout = (3, 1), size = (860, 860)) + savefig(fig, path) + return path +end + +""" + plot_paired_costs(a, b, labels, path) -> String + +A cost-distribution overlay and the paired-difference histogram for two policies +evaluated on the SAME scenarios. + +# Notes +Both panels are drawn because they answer different questions and are routinely +confused. The overlay shows that the two distributions are nearly identical — a +property of the problem, not of the comparison. The paired differences show +whether one policy is systematically cheaper, which the overlay cannot resolve +when the between-scenario spread dwarfs the between-policy difference. +""" +function plot_paired_costs(a::AbstractVector, b::AbstractVector, labels, path::AbstractString) + d = Float64.(a) .- Float64.(b) + top = histogram(Float64.(a); label = labels[1], alpha = 0.5, bins = 30, + ylabel = "scenarios", legend = :topright) + histogram!(top, Float64.(b); label = labels[2], alpha = 0.5, bins = 30) + bot = histogram(d; label = "$(labels[1]) − $(labels[2])", bins = 30, + xlabel = "paired cost difference", ylabel = "scenarios", + legend = :topright) + vline!(bot, [0.0]; label = "", lc = :black, ls = :dot) + vline!(bot, [mean(d)]; label = @sprintf("mean %+.2f", mean(d)), lc = :red, lw = 2) + fig = plot(top, bot; layout = (2, 1), size = (860, 620)) + savefig(fig, path) + return path +end + +""" + plot_demand_support(case, path; stages=nothing) -> String + +The frozen demand support: the total system demand of every atom at every stage. + +# Notes +This is the figure that shows what the uncertainty actually is — how wide the +support is, whether it widens in the stressed window, and whether the +deterministic profile or the multiplier is doing the work. A study that never +plots its own uncertainty tends to discover late that it has almost none. +""" +function plot_demand_support(case::BatteryCase, path::AbstractString; stages = nothing) + ts = stages === nothing ? (1:horizon(case.demand)) : collect(Int.(stages)) + fig = plot(; xlabel = "stage", ylabel = "total active demand (pu)", legend = :topleft) + maxK = maximum(num_atoms(case.demand, t) for t in ts) + for k in 1:maxK + xs = Int[] + ys = Float64[] + for t in ts + k <= num_atoms(case.demand, t) || continue + pd, _ = realized_bus_demand(case, t, k) + push!(xs, t) + push!(ys, sum(values(pd))) + end + plot!(fig, xs, ys; label = "atom $k", lw = 2, seriestype = :steppost) + end + savefig(fig, path) + return path +end diff --git a/examples/BatteryStorageOPF/battery_case.jl b/examples/BatteryStorageOPF/battery_case.jl new file mode 100644 index 0000000..1250df5 --- /dev/null +++ b/examples/BatteryStorageOPF/battery_case.jl @@ -0,0 +1,1525 @@ +# 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/2" + +""" + 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) + -> 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. + +# 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. +""" +function scenario_index_matrix(s::DemandSupport, num_stages::Integer, num_scenarios::Integer; + seed = 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 + return m +end + +""" + protocol_digest(s::DemandSupport, num_stages, num_scenarios; seed=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. +""" +function protocol_digest(s::DemandSupport, num_stages::Integer, num_scenarios::Integer; + seed = nothing) + m = scenario_index_matrix(s, num_stages, num_scenarios; seed = seed) + 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. + "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. 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), + "sha256" => protocol_digest(demand, protocol_stages, Int(screening_scenarios); + seed = Int(screening_seed)), + ), + "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"] + gots = protocol_digest(demand, Int(scr["num_stages"]), + Int(scr["num_scenarios"]); seed = Int(scr["seed"])) + 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 diff --git a/examples/BatteryStorageOPF/battery_demand.jl b/examples/BatteryStorageOPF/battery_demand.jl new file mode 100644 index 0000000..f1e1569 --- /dev/null +++ b/examples/BatteryStorageOPF/battery_demand.jl @@ -0,0 +1,1098 @@ +# battery_demand.jl +# +# The AUTHORING side of the demand process: a composable sampler abstraction, +# the deterministic temporal profile, and the operation that freezes either of +# them into the finite support both methods train from. +# +# THE TWO OBJECTS, AND WHY THEY ARE NOT THE SAME OBJECT. +# +# authoring sampler an arbitrary joint law over per-load multipliers. May be +# continuous, may be a user callable, may be built by +# composing several pieces. Lives here, never in a case. +# frozen support a finite, stage-major list of joint multiplier vectors +# with explicit probabilities. Lives in `demand.json`, is +# hashed, and is mirrored byte-identically into both +# engines (see `battery_case.jl`). +# +# SDDP enumerates a finite support in its backward pass; TS-DDR samples atom +# indices from a finite support in its trajectories. If each were allowed to +# discretize a continuous authoring law on its own, the two would train on two +# different stochastic programs while every report still said "the same demand +# process". `freeze_demand_support` is therefore not a convenience — it is the +# boundary that makes the comparison well posed, and it is the ONLY supported +# path from a sampler to a trainable case. +# +# This file is authoring-only and is NOT mirrored into the Exa engine: that +# engine reads frozen bytes and never touches a sampler. + +using Distributions +using StableRNGs +using Statistics + +@isdefined(BatterySpec) || include(joinpath(@__DIR__, "battery_case.jl")) + +# ───────────────────────────────────────────────────────────────────────────── +# Sampler metadata +# ───────────────────────────────────────────────────────────────────────────── + +""" + demand_meta(network) -> NamedTuple + +The case description every sampler and every user callable receives. + +# Returns +A `NamedTuple` with + +- `load_ids::Vector{Int}` — LOAD identifiers, sorted ascending. This vector fixes + the order of every multiplier vector in this file and in the frozen support. +- `load_bus::Vector{Int}` — the bus of each load, in `load_ids` order. +- `nominal_pd::Vector{Float64}`, `nominal_qd::Vector{Float64}` — the original + PGLib load values ``p^{d,0}_i`` and ``q^{d,0}_i`` (pu). +- `status::Vector{Int}` — the in-service flag of each load. +- `num_loads::Int`, `baseMVA::Float64`. + +# Notes +Sorting the identifiers once, here, is what guarantees that "component `j`" +means the same load to a sampler, to the frozen support and to both engines. +Nothing downstream is permitted to re-sort or re-index; a sampler that wants a +per-bus view builds it from `load_bus`. +""" +function demand_meta(network::AbstractDict) + ids = sort!([Int(l["index"]) for (_, l) in network["load"]]) + by_id = Dict{Int,Any}(Int(l["index"]) => l for (_, l) in network["load"]) + return (load_ids = ids, + load_bus = [Int(by_id[i]["load_bus"]) for i in ids], + nominal_pd = [Float64(by_id[i]["pd"]) for i in ids], + nominal_qd = [Float64(by_id[i]["qd"]) for i in ids], + status = [Int(get(by_id[i], "status", 1)) for i in ids], + num_loads = length(ids), + baseMVA = Float64(network["baseMVA"])) +end + +# ───────────────────────────────────────────────────────────────────────────── +# The sampler interface +# ───────────────────────────────────────────────────────────────────────────── + +""" + DemandSampler + +An authoring law for the uncertain demand multiplier. + +# Interface +A concrete sampler implements + +- `sample_multiplier(s, rng, t, meta) -> Vector{Float64}` — ONE draw of the JOINT + multiplier vector ``m_{\\cdot,t}``, of length `meta.num_loads`, in + `meta.load_ids` order; +- `finite_support(s, t, meta) -> Union{Nothing,Tuple{Matrix{Float64},Vector{Float64}}}` + — the sampler's EXACT finite support at stage `t`, or `nothing` when the law is + continuous or otherwise not finitely supported; +- `describe_sampler(s) -> Dict{String,Any}` — a serializable description. + +# Notes +The fundamental output is a JOINT VECTOR, never a scalar and never an implicit +collection of independent draws. A system-wide scalar law and a set of +independent per-load laws are both expressed as samplers that happen to produce +a particular kind of vector — [`SystemMultiplier`](@ref) and +[`IndependentMultiplier`](@ref) — so correlated regional structure +([`GroupMultiplier`](@ref)) and arbitrary user laws +([`CallableMultiplier`](@ref)) are first-class rather than special cases. + +Samplers draw ONLY through the `rng` they are handed. Nothing here touches the +global random state, which is what makes a seeded freeze bit-reproducible in a +process that has done other random work. +""" +abstract type DemandSampler end + +"Exact finite support of a sampler at stage `t`, or `nothing` when it has none." +finite_support(::DemandSampler, ::Integer, ::NamedTuple) = nothing + +""" + DeterministicMultiplier(value) + +A degenerate sampler: the same multiplier vector at every stage, with +probability 1. + +# Arguments +- `value`: a `Real` applied to every load, a `Vector{<:Real}` in `load_ids` + order, or a `Dict{Int,<:Real}` keyed by LOAD identifier (missing loads take + `1.0`). + +# Notes +This is what makes "run the study with no demand uncertainty" expressible in the +same API rather than as a special code path, and it is the identity element of +[`ProductMultiplier`](@ref). +""" +struct DeterministicMultiplier <: DemandSampler + value::Any +end + +sample_multiplier(s::DeterministicMultiplier, ::Any, ::Integer, meta::NamedTuple) = + _expand_per_load(s.value, meta) + +finite_support(s::DeterministicMultiplier, ::Integer, meta::NamedTuple) = + (reshape(_expand_per_load(s.value, meta), meta.num_loads, 1), [1.0]) + +describe_sampler(s::DeterministicMultiplier) = Dict{String,Any}( + "sampler" => "deterministic", + "value" => s.value isa Real ? Float64(s.value) : + s.value isa AbstractDict ? Dict{String,Any}(string(k) => Float64(v) for (k, v) in s.value) : + Float64.(collect(s.value)), +) + +""" + SystemMultiplier(dist) + +One scalar draw per stage, applied to EVERY load. + +# Arguments +- `dist`: a `Distributions.Distribution` used at every stage, or a + `Vector{<:Distribution}` indexed by stage (stage-dependent law), or a + `Dict{Int,<:Distribution}` keyed by stage. + +# Notes +The system-wide case: demand moves up and down together. This is maximal +correlation across loads and is the sampler under which storage value is purely +temporal, with no locational component from the uncertainty itself. +""" +struct SystemMultiplier <: DemandSampler + dist::Any +end + +function sample_multiplier(s::SystemMultiplier, rng, t::Integer, meta::NamedTuple) + ξ = rand(rng, _stage_dist(s.dist, t)) + return fill(Float64(ξ), meta.num_loads) +end + +function finite_support(s::SystemMultiplier, t::Integer, meta::NamedTuple) + d = _stage_dist(s.dist, t) + d isa DiscreteNonParametric || return nothing + vals = support(d) + probs = Distributions.probs(d) + A = Matrix{Float64}(undef, meta.num_loads, length(vals)) + for (k, v) in enumerate(vals) + A[:, k] .= Float64(v) + end + return A, Float64.(collect(probs)) +end + +describe_sampler(s::SystemMultiplier) = Dict{String,Any}( + "sampler" => "system", + "distribution" => _describe_dist(s.dist), +) + +""" + IndependentMultiplier(dist) + +Independent draws, one per load. + +# Arguments +- `dist`: a `Distribution` used for every load, or a `Dict{Int,<:Distribution}` + keyed by LOAD identifier (missing loads are deterministic 1). + +# Notes +A convenience, not the general interface: independence is a particular joint law, +and it is the one under which aggregate demand concentrates as the case grows, +so on a large system it produces LESS system-level uncertainty than a +system-wide sampler with the same marginal. Choose it when locational demand +diversity is the object of study, not as a default. +""" +struct IndependentMultiplier <: DemandSampler + dist::Any +end + +function sample_multiplier(s::IndependentMultiplier, rng, ::Integer, meta::NamedTuple) + out = Vector{Float64}(undef, meta.num_loads) + for (j, id) in enumerate(meta.load_ids) + d = s.dist isa AbstractDict ? get(s.dist, id, nothing) : s.dist + out[j] = d === nothing ? 1.0 : Float64(rand(rng, d)) + end + return out +end + +describe_sampler(s::IndependentMultiplier) = Dict{String,Any}( + "sampler" => "independent", + "distribution" => _describe_dist(s.dist), +) + +""" + GroupMultiplier(groups, dists; by=:load) + +One draw per GROUP, applied jointly to every load of that group. + +# Arguments +- `groups::Vector{<:AbstractVector{Int}}`: the groups, given as LOAD identifiers + (`by = :load`) or BUS identifiers (`by = :bus`). +- `dists`: one `Distribution` per group, or a single `Distribution` used by every + group. + +# Notes +The regional sampler, and the smallest construction that produces a genuinely +CORRELATED joint vector: loads inside a region move together, regions move +independently of one another. It is what makes a demand process able to stress +one part of a network while leaving another slack — the structure that gives a +battery a locational reason to exist. + +Loads in no group take multiplier 1. Groups must be disjoint: overlapping groups +would make a load's multiplier depend on group order, which is exactly the kind +of silent ordering dependence this file exists to prevent. +""" +struct GroupMultiplier <: DemandSampler + groups::Vector{Vector{Int}} + dists::Any + by::Symbol +end + +function GroupMultiplier(groups, dists; by::Symbol = :load) + by in (:load, :bus) || throw(ArgumentError("by must be :load or :bus, got :$by")) + g = [sort!(collect(Int.(x))) for x in groups] + seen = Set{Int}() + for grp in g, id in grp + id in seen && throw(ArgumentError("group member $id appears in more than one group")) + push!(seen, id) + end + return GroupMultiplier(g, dists, by) +end + +function sample_multiplier(s::GroupMultiplier, rng, ::Integer, meta::NamedTuple) + out = fill(1.0, meta.num_loads) + key = s.by === :load ? meta.load_ids : meta.load_bus + for (gi, grp) in enumerate(s.groups) + d = s.dists isa AbstractVector ? s.dists[gi] : s.dists + ξ = Float64(rand(rng, d)) + members = Set(grp) + for j in 1:meta.num_loads + key[j] in members && (out[j] = ξ) + end + end + return out +end + +function finite_support(s::GroupMultiplier, ::Integer, meta::NamedTuple) + # A product of finitely supported group laws has a finite support: the + # Cartesian product of the groups' atoms with the product probabilities. + dists = [s.dists isa AbstractVector ? s.dists[gi] : s.dists + for gi in eachindex(s.groups)] + all(d -> d isa DiscreteNonParametric, dists) || return nothing + key = s.by === :load ? meta.load_ids : meta.load_bus + members = [Set(grp) for grp in s.groups] + vals = [Float64.(collect(support(d))) for d in dists] + ps = [Float64.(collect(Distributions.probs(d))) for d in dists] + combos = Iterators.product(map(v -> 1:length(v), vals)...) + cols = Vector{Vector{Float64}}() + probs = Float64[] + for c in combos + m = fill(1.0, meta.num_loads) + p = 1.0 + for (gi, ki) in enumerate(c) + p *= ps[gi][ki] + for j in 1:meta.num_loads + key[j] in members[gi] && (m[j] = vals[gi][ki]) + end + end + push!(cols, m) + push!(probs, p) + end + A = Matrix{Float64}(undef, meta.num_loads, length(cols)) + for (k, col) in enumerate(cols) + A[:, k] .= col + end + return A, probs +end + +describe_sampler(s::GroupMultiplier) = Dict{String,Any}( + "sampler" => "group", + "by" => String(s.by), + "groups" => [copy(g) for g in s.groups], + "distribution" => _describe_dist(s.dists), +) + +""" + JointRegionMultiplier(groups, modes, probabilities; by=:load) + +Regions that move JOINTLY: a finite set of joint outcomes over regions, each +with its own probability. + +# Arguments +- `groups`: `Vector{Vector{Int}}`, the regions, as load ids (`by=:load`) or bus + ids (`by=:bus`). Must be disjoint; a load in no region takes multiplier 1. +- `modes`: `(num_regions, K)` matrix, or a `Vector` of `K` length-`num_regions` + vectors. Column `k` is one joint outcome: what EVERY region does together. +- `probabilities`: length `K`, positive, summing to 1. + +# Notes +[`GroupMultiplier`](@ref) draws each region independently, so its joint law is +forced to be a product and its regional correlation is always zero. That is the +wrong shape for a locational storage study: the interesting demand processes are +the ones where regions are ANTI-correlated in some outcomes (one region is +stressed while another is slack — the case for putting storage in a specific +place) and correlated in others (system-wide stress, which no amount of +locational cleverness can hedge). + +Enumerating joint outcomes rather than per-region laws expresses both, exactly, +with no copula and no approximation. It is also CHEAPER: a product of `R` +regions with two atoms each has `2^R` atoms, while the joint form spends atoms +only on the outcomes that carry meaning. Since the number of atoms per stage +multiplies the cost of every SDDP backward pass, that is the difference between +a converged baseline and an unaffordable one. + +Combined with [`StageMultiplier`](@ref) — a different `JointRegionMultiplier` +per stage — the mean, the tail and the inter-region correlation all become +functions of time, which is what forces a policy to hold a genuinely +multi-dimensional strategy rather than one storage schedule replicated +everywhere. +""" +struct JointRegionMultiplier <: DemandSampler + groups::Vector{Vector{Int}} + modes::Matrix{Float64} + probabilities::Vector{Float64} + by::Symbol +end + +function JointRegionMultiplier(groups, modes, probabilities; by::Symbol = :load) + by in (:load, :bus) || throw(ArgumentError("by must be :load or :bus, got :$by")) + g = [sort!(collect(Int.(x))) for x in groups] + seen = Set{Int}() + for grp in g, id in grp + id in seen && throw(ArgumentError("region member $id appears in more than one region")) + push!(seen, id) + end + M = modes isa AbstractMatrix ? Float64.(Matrix(modes)) : + reduce(hcat, [Float64.(collect(m)) for m in modes]) + size(M, 1) == length(g) || + throw(ArgumentError("modes have $(size(M, 1)) rows for $(length(g)) regions")) + p = Float64.(collect(probabilities)) + size(M, 2) == length(p) || + throw(ArgumentError("$(size(M, 2)) modes but $(length(p)) probabilities")) + isapprox(sum(p), 1.0; atol = 1e-12) || + throw(ArgumentError("mode probabilities sum to $(sum(p)), not 1")) + all(>(0), p) || throw(ArgumentError("mode probabilities must be positive")) + all(>(0), M) || throw(ArgumentError("mode multipliers must be positive")) + return JointRegionMultiplier(g, M, p, by) +end + +"The `(num_loads, K)` multiplier matrix this sampler's modes induce." +function _region_atoms(s::JointRegionMultiplier, meta::NamedTuple) + key = s.by === :load ? meta.load_ids : meta.load_bus + members = [Set(grp) for grp in s.groups] + A = fill(1.0, meta.num_loads, size(s.modes, 2)) + for k in 1:size(s.modes, 2), (gi, mem) in enumerate(members) + for j in 1:meta.num_loads + key[j] in mem && (A[j, k] = s.modes[gi, k]) + end + end + return A +end + +finite_support(s::JointRegionMultiplier, ::Integer, meta::NamedTuple) = + (_region_atoms(s, meta), copy(s.probabilities)) + +sample_multiplier(s::JointRegionMultiplier, rng, ::Integer, meta::NamedTuple) = + _region_atoms(s, meta)[:, _sample_index(rng, s.probabilities)] + +describe_sampler(s::JointRegionMultiplier) = Dict{String,Any}( + "sampler" => "joint_region", + "by" => String(s.by), + "groups" => [copy(g) for g in s.groups], + "modes" => [Float64.(s.modes[:, k]) for k in 1:size(s.modes, 2)], + "probabilities" => copy(s.probabilities), +) + +""" + CallableMultiplier(f; name="callable", support=nothing) + +An arbitrary user law: `f(rng, t, meta) -> Vector{Float64}`. + +# Arguments +- `f`: the callable. It receives the RNG (and must draw from nothing else), the + ABSOLUTE stage index, and the [`demand_meta`](@ref) named tuple. + +# Keywords +- `name::AbstractString`: what the manifest records in place of a rule it cannot + serialize. +- `support`: an optional `(t, meta) -> (atoms, probs)` callable declaring an + exact finite support, when the user law happens to have one. + +# Notes +This is the general interface, and every other sampler in this file is a +convenience over it. The returned vector is validated on every draw — length, +finiteness, nonnegativity — because a user callable is the one place a silently +wrong dimension can enter. +""" +struct CallableMultiplier <: DemandSampler + f::Any + name::String + support::Any +end + +CallableMultiplier(f; name::AbstractString = "callable", support = nothing) = + CallableMultiplier(f, String(name), support) + +function sample_multiplier(s::CallableMultiplier, rng, t::Integer, meta::NamedTuple) + v = Float64.(collect(s.f(rng, t, meta))) + length(v) == meta.num_loads || + error("callable sampler \"$(s.name)\" returned $(length(v)) multipliers at stage $t, expected $(meta.num_loads)") + return v +end + +finite_support(s::CallableMultiplier, t::Integer, meta::NamedTuple) = + s.support === nothing ? nothing : s.support(t, meta) + +describe_sampler(s::CallableMultiplier) = Dict{String,Any}( + "sampler" => "callable", "name" => s.name, +) + +""" + FiniteMultiplier(atoms, probabilities) + +An explicitly enumerated finite law, the same at every stage. + +# Arguments +- `atoms`: `Matrix{Float64}` of size `(num_loads, K)` whose columns are the joint + multiplier vectors, or a `Vector{<:Real}` of `K` system-wide scalars. +- `probabilities`: `Vector{Float64}` of length `K`, summing to 1. + +# Notes +Freezing this sampler PRESERVES its support and probabilities exactly: no +resampling, no reweighting, no merging beyond exact duplicates. That is the +contract for a user who has already decided what the scenarios are. +""" +struct FiniteMultiplier <: DemandSampler + atoms::Any + probabilities::Vector{Float64} +end + +function FiniteMultiplier(atoms, probabilities) + p = Float64.(collect(probabilities)) + isapprox(sum(p), 1.0; atol = 1e-12) || + throw(ArgumentError("finite-support probabilities sum to $(sum(p)), not 1")) + all(>(0), p) || throw(ArgumentError("finite-support probabilities must be positive")) + return FiniteMultiplier(atoms, p) +end + +function finite_support(s::FiniteMultiplier, ::Integer, meta::NamedTuple) + A = if s.atoms isa AbstractMatrix + Float64.(Matrix(s.atoms)) + else + # A vector of scalars is a system-wide support: broadcast each atom + # across every load. + v = Float64.(collect(s.atoms)) + [v[k] for _ in 1:meta.num_loads, k in 1:length(v)] + end + size(A, 1) == meta.num_loads || + error("FiniteMultiplier atoms have $(size(A, 1)) rows, expected $(meta.num_loads)") + size(A, 2) == length(s.probabilities) || + error("FiniteMultiplier has $(size(A, 2)) atoms but $(length(s.probabilities)) probabilities") + return A, copy(s.probabilities) +end + +function sample_multiplier(s::FiniteMultiplier, rng, t::Integer, meta::NamedTuple) + A, p = finite_support(s, t, meta) + return A[:, _sample_index(rng, p)] +end + +describe_sampler(s::FiniteMultiplier) = Dict{String,Any}( + "sampler" => "finite", + "num_atoms" => length(s.probabilities), + "probabilities" => copy(s.probabilities), + "atoms" => s.atoms isa AbstractMatrix ? + [Float64.(s.atoms[:, k]) for k in 1:size(s.atoms, 2)] : + Float64.(collect(s.atoms)), +) + +""" + StageMultiplier(by_stage; default=nothing) + +A stage-dependent law: `by_stage[t]` (or `by_stage` keyed by stage) is the +sampler used at stage `t`. + +# Arguments +- `by_stage`: `Vector{<:DemandSampler}` indexed by stage, or + `Dict{Int,<:DemandSampler}` keyed by stage. + +# Keywords +- `default`: the sampler used at stages `by_stage` does not cover. `nothing` + makes an uncovered stage an error. + +# Notes +This is how "quiet early stages, uncertain stressed late stages" is expressed — +the structure the study needs in order for stored energy to have a hedging value +rather than only an arbitrage value. Each stage keeps its own exact support when +its sampler has one, so a stage-dependent finite support survives freezing +unchanged. +""" +struct StageMultiplier <: DemandSampler + by_stage::Any + default::Any +end + +StageMultiplier(by_stage; default = nothing) = StageMultiplier(by_stage, default) + +function _stage_sampler(s::StageMultiplier, t::Integer) + inner = s.by_stage isa AbstractDict ? get(s.by_stage, Int(t), nothing) : + (1 <= t <= length(s.by_stage) ? s.by_stage[t] : nothing) + inner === nothing && (inner = s.default) + inner === nothing && error("StageMultiplier has no sampler for stage $t and no default") + return inner +end + +sample_multiplier(s::StageMultiplier, rng, t::Integer, meta::NamedTuple) = + sample_multiplier(_stage_sampler(s, t), rng, t, meta) + +finite_support(s::StageMultiplier, t::Integer, meta::NamedTuple) = + finite_support(_stage_sampler(s, t), t, meta) + +function describe_sampler(s::StageMultiplier) + entries = if s.by_stage isa AbstractDict + Dict{String,Any}(string(k) => describe_sampler(v) for (k, v) in s.by_stage) + else + Dict{String,Any}(string(t) => describe_sampler(s.by_stage[t]) + for t in eachindex(s.by_stage)) + end + return Dict{String,Any}("sampler" => "stage", "stages" => entries, + "default" => s.default === nothing ? nothing : + describe_sampler(s.default)) +end + +""" + ProductMultiplier(components...) + +The composition operator: the element-wise PRODUCT of several samplers' joint +vectors. + +# Notes +Composition is multiplicative because the multiplier is multiplicative: a +system-wide factor times a regional factor is a demand that is `(system × +region)` times nominal. This is what lets a case be authored as "a common +economy-wide level, plus a regional weather effect, plus an idiosyncratic +per-load term" without any of the three needing to know about the others. + +Components are drawn from the SAME rng in order, so the composite is +reproducible from one seed. When EVERY component has an exact finite support the +product's support is their Cartesian product with product probabilities; +otherwise the product is treated as continuous and freezing discretizes it. +""" +struct ProductMultiplier <: DemandSampler + components::Vector{DemandSampler} +end + +ProductMultiplier(components::DemandSampler...) = ProductMultiplier(collect(components)) + +function sample_multiplier(s::ProductMultiplier, rng, t::Integer, meta::NamedTuple) + out = fill(1.0, meta.num_loads) + for c in s.components + out .*= sample_multiplier(c, rng, t, meta) + end + return out +end + +function finite_support(s::ProductMultiplier, t::Integer, meta::NamedTuple) + parts = [finite_support(c, t, meta) for c in s.components] + any(isnothing, parts) && return nothing + A = parts[1][1] + p = copy(parts[1][2]) + for q in parts[2:end] + B, pb = q + A2 = Matrix{Float64}(undef, meta.num_loads, size(A, 2) * size(B, 2)) + p2 = Vector{Float64}(undef, size(A, 2) * size(B, 2)) + col = 0 + for ka in 1:size(A, 2), kb in 1:size(B, 2) + col += 1 + @views A2[:, col] .= A[:, ka] .* B[:, kb] + p2[col] = p[ka] * pb[kb] + end + A = A2 + p = p2 + end + return A, p +end + +describe_sampler(s::ProductMultiplier) = Dict{String,Any}( + "sampler" => "product", + "components" => [describe_sampler(c) for c in s.components], +) + +# ── Small shared helpers ───────────────────────────────────────────────────── + +"Expand a scalar / vector / load-keyed dictionary into a per-load vector." +function _expand_per_load(value, meta::NamedTuple) + if value isa Real + return fill(Float64(value), meta.num_loads) + elseif value isa AbstractDict + return [Float64(get(value, id, 1.0)) for id in meta.load_ids] + else + v = Float64.(collect(value)) + length(v) == meta.num_loads || + error("per-load value has $(length(v)) entries, expected $(meta.num_loads)") + return v + end +end + +"Select the distribution governing stage `t` from a scalar / vector / dictionary." +function _stage_dist(dist, t::Integer) + dist isa AbstractDict && return dist[Int(t)] + dist isa AbstractVector && return dist[t] + return dist +end + +"Draw an index from an explicit probability vector using only `rand(rng)`." +function _sample_index(rng, p::AbstractVector{Float64}) + u = rand(rng) + acc = 0.0 + for i in eachindex(p) + acc += p[i] + u <= acc && return i + end + return length(p) +end + +"A serializable description of a distribution, a vector of them or a dictionary." +function _describe_dist(d) + d isa AbstractDict && return Dict{String,Any}(string(k) => _describe_dist(v) for (k, v) in d) + d isa AbstractVector && return [_describe_dist(x) for x in d] + return string(d) +end + +# ───────────────────────────────────────────────────────────────────────────── +# Deterministic temporal profile +# ───────────────────────────────────────────────────────────────────────────── + +""" + profile_matrix(profile, meta, horizon) -> Matrix{Float64} + +Materialize the deterministic temporal profile ``h_{i,t}`` as a +`(num_loads × horizon)` matrix. + +# Arguments +- `profile`: one of + - a `Real` — flat, the same at every load and stage; + - a `Vector{<:Real}` of length `horizon` — one value per stage, shared by every + load; + - a `Vector{<:Real}` of a SHORTER length `P` — a cyclic profile of period `P`, + expanded as `profile[mod1(t, P)]`; + - a `Matrix{<:Real}` of size `(num_loads, horizon)` — the fully general case; + - a callable `(load_id, t) -> Real`. + +# Notes +The profile is materialized ONCE, here, and frozen with the case. A cyclic +profile is expanded rather than stored as a period, because a horizon change +must not be able to silently reinterpret which stage is the peak. +""" +function profile_matrix(profile, meta::NamedTuple, horizon::Integer) + n = meta.num_loads + H = Int(horizon) + out = Matrix{Float64}(undef, n, H) + if profile isa Real + fill!(out, Float64(profile)) + elseif profile isa AbstractMatrix + size(profile) == (n, H) || + error("profile matrix must be $(n)×$H, got $(size(profile))") + out .= Float64.(profile) + elseif profile isa AbstractVector + v = Float64.(collect(profile)) + P = length(v) + P >= 1 || error("profile vector must be non-empty") + for t in 1:H + out[:, t] .= v[mod1(t, P)] + end + elseif profile isa Function + for t in 1:H, j in 1:n + out[j, t] = Float64(profile(meta.load_ids[j], t)) + end + else + error("unsupported profile of type $(typeof(profile))") + end + all(isfinite, out) || error("profile has a non-finite entry") + all(>=(0), out) || error("profile has a negative entry") + return out +end + +""" + diurnal_profile(horizon; amplitude=0.12, peak_hour=19, period=24) -> Vector{Float64} + +A smooth single-peak daily profile of mean 1, +``h_t = 1 + a\\cos\\!\\left(2\\pi (t - t_{peak})/P\\right)``. + +# Notes +Returned as a length-`horizon` vector rather than one period, so the caller can +see exactly which stage is the peak. Mean 1 means the profile describes the +SHAPE of demand and the sampler describes its LEVEL; keeping the two +separable is what lets a stressed late window be authored by changing the +sampler alone. +""" +function diurnal_profile(horizon::Integer; amplitude::Real = 0.12, + peak_hour::Integer = 19, period::Integer = 24) + return [1.0 + amplitude * cos(2π * (t - peak_hour) / period) for t in 1:horizon] +end + +# ───────────────────────────────────────────────────────────────────────────── +# Sampling and validation +# ───────────────────────────────────────────────────────────────────────────── + +""" + sample_multiplier_path(sampler, meta, horizon; seed) -> Matrix{Float64} + +Draw one COMPLETE multiplier path: a `(num_loads × horizon)` matrix whose column +`t` is ``m_{\\cdot,t}``. + +# Notes +Uses a `StableRNG(seed)` and nothing else, so the same seed reproduces the same +path on any platform and any Julia version. Every drawn vector is validated +before it is returned. +""" +function sample_multiplier_path(sampler::DemandSampler, meta::NamedTuple, horizon::Integer; + seed::Integer) + rng = StableRNG(seed) + out = Matrix{Float64}(undef, meta.num_loads, Int(horizon)) + for t in 1:Int(horizon) + v = sample_multiplier(sampler, rng, t, meta) + _check_multiplier(v, meta, t) + out[:, t] .= v + end + return out +end + +""" + materialize_demand_path(network, profile, multipliers) -> (pd, qd) + +Turn a multiplier path into the realized per-LOAD demand it describes. + +# Arguments +- `profile::AbstractMatrix`, `multipliers::AbstractMatrix`: both + `(num_loads × horizon)`. + +# Returns +- `pd`, `qd`: `(num_loads × horizon)` matrices in pu. + +# Notes +The same total multiplier scales the active and the reactive value of each load, +so `qd[j,t]/pd[j,t]` equals the load's nominal ratio at every stage of every +path. That invariant is asserted by [`validate_sampler`](@ref); it is the +formal content of "the uncertainty moves how much power is consumed, never what +kind". +""" +function materialize_demand_path(meta::NamedTuple, profile::AbstractMatrix, + multipliers::AbstractMatrix) + size(profile) == size(multipliers) || + error("profile $(size(profile)) and multipliers $(size(multipliers)) disagree") + total = profile .* multipliers + return meta.nominal_pd .* total, meta.nominal_qd .* total +end + +"Fail closed on a multiplier vector a sampler produced." +function _check_multiplier(v::AbstractVector, meta::NamedTuple, t::Integer) + length(v) == meta.num_loads || + error("sampler returned $(length(v)) multipliers at stage $t, expected $(meta.num_loads)") + all(isfinite, v) || error("sampler returned a non-finite multiplier at stage $t") + all(>=(0), v) || error("sampler returned a negative multiplier at stage $t") + return nothing +end + +""" + validate_sampler(sampler, network, horizon; seed=1, draws=32) -> NamedTuple + +Exercise a sampler and check every property the study relies on. + +# Checks +1. **dimension and order** — every draw has one entry per load, in `load_ids` + order; +2. **finiteness and nonnegativity** — no `NaN`, no `Inf`, no negative demand; +3. **exact seeded reproduction** — two runs from the same seed produce + bit-identical paths; +4. **no hidden global RNG state** — perturbing the GLOBAL random stream between + two seeded runs does not change the result; +5. **power-factor preservation** — the realized `qd/pd` ratio of every load + equals its nominal ratio at every stage; +6. **finite support consistency** — where the sampler declares one, its + dimensions and probabilities are valid; +7. **load order preservation** — the metadata's identifiers are sorted and + unique, and no draw reorders them. + +# Returns +A `NamedTuple` of the observed multiplier range and, when declared, the per-stage +support sizes. Failures are errors, not warnings. +""" +function validate_sampler(sampler::DemandSampler, network::AbstractDict, horizon::Integer; + seed::Integer = 1, draws::Integer = 32) + meta = demand_meta(network) + issorted(meta.load_ids) && allunique(meta.load_ids) || + error("demand_meta produced load identifiers that are not sorted and unique") + + a = sample_multiplier_path(sampler, meta, horizon; seed = seed) + # Disturb the global stream: a sampler that reaches for it will now diverge. + rand(1000) + b = sample_multiplier_path(sampler, meta, horizon; seed = seed) + a == b || error("sampler is not reproducible from its seed, or reaches for the global RNG") + + lo, hi = Inf, -Inf + for d in 1:Int(draws) + p = sample_multiplier_path(sampler, meta, horizon; seed = seed + d) + lo = min(lo, minimum(p)) + hi = max(hi, maximum(p)) + pd, qd = materialize_demand_path(meta, profile_matrix(1.0, meta, horizon), p) + for j in 1:meta.num_loads + meta.nominal_pd[j] == 0 && continue + nominal_ratio = meta.nominal_qd[j] / meta.nominal_pd[j] + for t in 1:Int(horizon) + pd[j, t] == 0 && continue + isapprox(qd[j, t] / pd[j, t], nominal_ratio; rtol = 1e-12) || + error("load $(meta.load_ids[j]) lost its power factor at stage $t") + end + end + end + + sizes = Int[] + for t in 1:Int(horizon) + fs = finite_support(sampler, t, meta) + fs === nothing && continue + A, p = fs + size(A, 1) == meta.num_loads || + error("declared support at stage $t has $(size(A, 1)) rows, expected $(meta.num_loads)") + size(A, 2) == length(p) || + error("declared support at stage $t has $(size(A, 2)) atoms but $(length(p)) probabilities") + isapprox(sum(p), 1.0; atol = 1e-12) || + error("declared support at stage $t has probabilities summing to $(sum(p))") + all(>(0), p) || error("declared support at stage $t has a non-positive probability") + push!(sizes, size(A, 2)) + end + + return (multiplier_min = lo, multiplier_max = hi, + support_sizes = isempty(sizes) ? nothing : sizes, + num_loads = meta.num_loads) +end + +# ───────────────────────────────────────────────────────────────────────────── +# Freezing +# ───────────────────────────────────────────────────────────────────────────── + +""" + freeze_demand_support(sampler, network, horizon; seed, atoms_per_stage, + method=:auto, profile=1.0, protocol_seed=seed, + stage_hours=1.0, merge_duplicates=true) + -> DemandSupport + +Turn an authoring sampler into the FROZEN finite support both methods train from. + +# Arguments +- `sampler::DemandSampler`: the authoring law. +- `network::AbstractDict`: the parsed PGLib network (supplies the load order). +- `horizon::Integer`: number of stages to freeze. + +# Keywords +- `seed::Integer`: seed of the `StableRNG` used by an empirical discretization. +- `atoms_per_stage::Integer`: ``K_t`` for an empirical discretization. Ignored by + an exact one. +- `method::Symbol`: `:auto` (exact where the sampler declares a support, + empirical elsewhere), `:exact` (require a declared support at every stage) or + `:empirical` (discretize even a declared support — for a deliberate + sub-sampling of a large exact support). +- `profile`: anything [`profile_matrix`](@ref) accepts. +- `protocol_seed::Integer`: seed of the evaluation protocol. +- `stage_hours::Real`: ``\\Delta t``. +- `profile_period::Integer`: the cycle length the deterministic profile repeats + on, recorded for [`profile_period`](@ref). It is a POLICY FEATURE only and + enters no stage problem; the profile itself is materialized stage by stage and + is not reconstructed from it. +- `merge_duplicates::Bool`: merge EXACTLY equal atoms within a stage, summing + their probabilities. + +# Returns +- A validated [`DemandSupport`](@ref), ready to be written into a case. + +# Notes +**Exact preservation.** For a sampler that declares a finite support the atoms +and probabilities are carried through unchanged — no reweighting and no +resampling — because a user who enumerated their scenarios has already decided +what the stochastic program is. + +**Empirical discretization.** For a continuous or general sampler the default is +the most transparent estimator there is: draw `atoms_per_stage` independent joint +vectors per stage from `StableRNG(seed)` and weight them equally. It converges to +the authoring law, it is reproducible from `(seed, atoms_per_stage)` alone, and +it makes no claim about matching moments. A user who wants a different +discretizer declares one by giving their sampler a `support` callable; there is +no hidden quadrature rule. + +**Duplicate merging** is by EXACT equality of the multiplier vector, so it only +ever collapses atoms that are the same point of the support — typically a +discrete sampler drawn empirically. Two atoms that differ in the last bit are +two atoms. + +The `source` record written into the support carries the sampler description, +the seed, the atom count, the method and the profile summary, so a frozen support +can always be traced back to the law it approximates. +""" +function freeze_demand_support(sampler::DemandSampler, network::AbstractDict, + horizon::Integer; + seed::Integer, + atoms_per_stage::Integer = 1, + method::Symbol = :auto, + profile = 1.0, + protocol_seed::Integer = seed, + stage_hours::Real = 1.0, + profile_period::Integer = 24, + merge_duplicates::Bool = true) + method in (:auto, :exact, :empirical) || + throw(ArgumentError("method must be :auto, :exact or :empirical, got :$method")) + meta = demand_meta(network) + H = Int(horizon) + H >= 1 || throw(ArgumentError("horizon must be at least 1")) + prof = profile_matrix(profile, meta, H) + + rng = StableRNG(seed) + atoms = Vector{Matrix{Float64}}(undef, H) + probs = Vector{Vector{Float64}}(undef, H) + exact_stages = Int[] + + for t in 1:H + declared = method === :empirical ? nothing : finite_support(sampler, t, meta) + if declared === nothing + method === :exact && + error("method = :exact but the sampler declares no finite support at stage $t") + atoms_per_stage >= 1 || + throw(ArgumentError("atoms_per_stage must be at least 1 for an empirical freeze")) + A = Matrix{Float64}(undef, meta.num_loads, Int(atoms_per_stage)) + for k in 1:Int(atoms_per_stage) + v = sample_multiplier(sampler, rng, t, meta) + _check_multiplier(v, meta, t) + A[:, k] .= v + end + p = fill(1.0 / Int(atoms_per_stage), Int(atoms_per_stage)) + atoms[t], probs[t] = A, p + else + A, p = declared + A = Float64.(Matrix(A)) + p = Float64.(collect(p)) + size(A, 1) == meta.num_loads || + error("declared support at stage $t has $(size(A, 1)) rows, expected $(meta.num_loads)") + size(A, 2) == length(p) || + error("declared support at stage $t has $(size(A, 2)) atoms but $(length(p)) probabilities") + for k in 1:size(A, 2) + _check_multiplier(view(A, :, k), meta, t) + end + atoms[t], probs[t] = A, p + push!(exact_stages, t) + end + if merge_duplicates + atoms[t], probs[t] = _merge_duplicate_atoms(atoms[t], probs[t]) + end + # Renormalize only against accumulated floating-point error, never to + # repair a support that does not sum to 1 in the first place. + s = sum(probs[t]) + isapprox(s, 1.0; atol = 1e-9) || + error("stage $t probabilities sum to $s, not 1") + probs[t] ./= s + end + + source = Dict{String,Any}( + "sampler" => describe_sampler(sampler), + "method" => String(method), + "seed" => Int(seed), + "atoms_per_stage" => Int(atoms_per_stage), + "exact_stages" => exact_stages, + "merge_duplicates" => merge_duplicates, + "profile_period" => Int(profile_period), + "profile_min" => minimum(prof), + "profile_max" => maximum(prof), + "horizon" => H, + ) + + support = DemandSupport(Float64(stage_hours), H, copy(meta.load_ids), prof, + atoms, probs, Int(protocol_seed), source) + validate_support(support) + return support +end + +""" + _merge_duplicate_atoms(A, p) -> (A', p') + +Collapse columns of `A` that are EXACTLY equal, summing their probabilities. + +# Notes +First occurrence wins the position, so the order of the surviving atoms is the +order they were generated in — which keeps an empirically frozen support's bytes +a pure function of the seed. +""" +function _merge_duplicate_atoms(A::Matrix{Float64}, p::Vector{Float64}) + seen = Dict{Vector{Float64},Int}() + cols = Vector{Vector{Float64}}() + out = Float64[] + for k in 1:size(A, 2) + col = A[:, k] + j = get(seen, col, 0) + if j == 0 + push!(cols, col) + push!(out, p[k]) + seen[col] = length(cols) + else + out[j] += p[k] + end + end + B = Matrix{Float64}(undef, size(A, 1), length(cols)) + for (k, col) in enumerate(cols) + B[:, k] .= col + end + return B, out +end + +# ───────────────────────────────────────────────────────────────────────────── +# Serialization of an authoring sampler +# ───────────────────────────────────────────────────────────────────────────── + +""" + sampler_to_dict(sampler) -> Dict{String,Any} + +Serialize a sampler to a plain dictionary (the same description the frozen +support records). +""" +sampler_to_dict(s::DemandSampler) = describe_sampler(s) + +""" + sampler_from_dict(d) -> DemandSampler + +Reconstruct a sampler from [`sampler_to_dict`](@ref). + +# Notes +Every built-in sampler round-trips. A [`CallableMultiplier`](@ref) cannot: a +Julia closure has no serialization, and inventing one that reconstructs "some +callable with the right name" would be worse than failing, because the +reconstructed object would silently be a different law. The frozen SUPPORT is +what carries a callable-authored case forward, which is exactly why the support +rather than the sampler is the thing that is frozen. +""" +function sampler_from_dict(d::AbstractDict) + kind = String(d["sampler"]) + if kind == "deterministic" + v = d["value"] + return DeterministicMultiplier(v isa AbstractDict ? + Dict(parse(Int, k) => Float64(x) for (k, x) in v) : + v isa AbstractVector ? Float64.(v) : Float64(v)) + elseif kind == "finite" + atoms = d["atoms"] + A = atoms isa AbstractVector && !isempty(atoms) && atoms[1] isa AbstractVector ? + reduce(hcat, [Float64.(a) for a in atoms]) : Float64.(collect(atoms)) + return FiniteMultiplier(A, Float64.(d["probabilities"])) + elseif kind == "joint_region" + # Round-trips exactly: unlike the group/system samplers this one carries + # plain numbers, not a Distributions.jl object. + return JointRegionMultiplier([Int.(g) for g in d["groups"]], + [Float64.(m) for m in d["modes"]], + Float64.(d["probabilities"]); + by = Symbol(d["by"])) + elseif kind == "product" + return ProductMultiplier([sampler_from_dict(c) for c in d["components"]]) + elseif kind == "stage" + stages = Dict{Int,DemandSampler}(parse(Int, k) => sampler_from_dict(v) + for (k, v) in d["stages"]) + default = d["default"] === nothing ? nothing : sampler_from_dict(d["default"]) + return StageMultiplier(stages; default = default) + elseif kind in ("system", "independent", "group") + error("sampler_from_dict: \"$kind\" carries a Distributions.jl object, which is " * + "described but not serialized; rebuild it in code, or use the frozen support") + elseif kind == "callable" + error("sampler_from_dict: a callable sampler cannot be reconstructed; " * + "the frozen support is what carries such a case forward") + else + error("sampler_from_dict: unknown sampler kind \"$kind\"") + end +end diff --git a/examples/BatteryStorageOPF/battery_diagnostics.jl b/examples/BatteryStorageOPF/battery_diagnostics.jl new file mode 100644 index 0000000..931b404 --- /dev/null +++ b/examples/BatteryStorageOPF/battery_diagnostics.jl @@ -0,0 +1,890 @@ +# battery_diagnostics.jl +# +# The diagnostic toolkit: what a user runs on a case BEFORE training anything. +# +# Everything here is built out of the production builders in +# `battery_powermodels.jl`. There is no second network model, no duplicated +# balance equation and no separate cost accounting: a diagnostic that measures a +# different model from the one the study trains on measures nothing about the +# study. The only thing these functions add is which variables are pinned and +# which are free. +# +# The five tools, and the question each answers: +# +# sample_incoming_energy what states should I probe from? +# targetless_probe what does the network do at this state, right now? +# energy_value_curve what is the stored energy WORTH here, and do the +# true model and the relaxation disagree about it? +# deterministic_equivalent what would a clairvoyant operator have done? +# perfect_foresight_panel how much headroom is there, over a protocol? +# +# The three are deliberately ordered from myopic to clairvoyant, because the +# first is the one that is easiest to over-read: a targetless ONE-STAGE solve is +# myopic and will rationally empty a battery, since nothing in it prices the +# energy it leaves behind. It diagnoses this stage's physics. It does not, by +# itself, measure the value of preserving energy — that is what +# `energy_value_curve` is for. + +using JuMP +using PowerModels +using StableRNGs +using Statistics +using Printf +import MathOptInterface as MOI + +@isdefined(BatterySpecification) || include(joinpath(@__DIR__, "battery_powermodels.jl")) + +# ───────────────────────────────────────────────────────────────────────────── +# B1 — incoming-energy sampling +# ───────────────────────────────────────────────────────────────────────────── + +""" + sample_incoming_energy(case; kind=:fixed, level=0.5, dist=nothing, + callable=nothing, explicit=nothing, seed=1, batch=1) + -> Vector{Dict{Int,Float64}} + +Reproducibly sample incoming battery-energy vectors inside their own bounds. + +# Keywords +- `kind::Symbol`: one of + - `:fixed` — every battery at the normalized state `level`; + - `:uniform` — independent uniform normalized states in `[0, 1]`; + - `:distribution` — independent draws of the NORMALIZED state from `dist` + (anything supporting `rand(rng, dist)`), clamped into `[0, 1]`; + - `:callable` — `callable(rng, battery, meta) -> normalized state`; + - `:explicit` — `explicit` is a vector of `Dict{Int,Float64}` energy vectors, + validated and returned. +- `level::Real`: the normalized state used by `:fixed`. +- `seed::Integer`: seed of the `StableRNG`. +- `batch::Integer`: how many vectors to draw. + +# Returns +- A vector of `batch` dictionaries keyed by BATTERY identifier, in pu·h. + +# Notes +The NORMALIZED state ``u_b \\in [0,1]`` maps to energy by +``e_b = \\underline e_b + u_b(\\overline e_b - \\underline e_b)``, so a sampler +expressed in normalized terms transfers unchanged to a case whose batteries have +different ratings. Every resulting energy is validated against its own bounds +before being returned. + +This samples DIAGNOSTIC INITIAL STATES only. It is not the demand process and it +plays no part in training or in evaluation; a state drawn here is a place to +stand while measuring the network, not a scenario. +""" +function sample_incoming_energy(case::BatteryCase; + kind::Symbol = :fixed, + level::Real = 0.5, + dist = nothing, + callable = nothing, + explicit = nothing, + seed::Integer = 1, + batch::Integer = 1) + kind in (:fixed, :uniform, :distribution, :callable, :explicit) || + throw(ArgumentError("kind must be :fixed, :uniform, :distribution, :callable or :explicit")) + rng = StableRNG(seed) + out = Dict{Int,Float64}[] + + if kind === :explicit + explicit === nothing && throw(ArgumentError(":explicit requires the energy vectors")) + for e in explicit + push!(out, Dict{Int,Float64}(Int(k) => Float64(v) for (k, v) in e)) + end + else + for _ in 1:Int(batch) + e = Dict{Int,Float64}() + for b in case.batteries + u = if kind === :fixed + Float64(level) + elseif kind === :uniform + rand(rng) + elseif kind === :distribution + dist === nothing && throw(ArgumentError(":distribution requires `dist`")) + clamp(Float64(rand(rng, dist)), 0.0, 1.0) + else + callable === nothing && throw(ArgumentError(":callable requires `callable`")) + Float64(callable(rng, b, (case = case,))) + end + e[b.index] = b.energy_min + u * (b.energy_max - b.energy_min) + end + push!(out, e) + end + end + + byid = Dict(b.index => b for b in case.batteries) + for e in out + Set(keys(e)) == Set(keys(byid)) || + error("incoming-energy vector covers batteries $(sort!(collect(keys(e)))), expected $(sort!(collect(keys(byid))))") + for (k, v) in e + b = byid[k] + isfinite(v) || error("battery $k: incoming energy is not finite") + b.energy_min - 1e-12 <= v <= b.energy_max + 1e-12 || + error("battery $k: incoming energy $v outside [$(b.energy_min), $(b.energy_max)]") + end + end + return out +end + +# ───────────────────────────────────────────────────────────────────────────── +# B2 — the single-stage targetless probe +# ───────────────────────────────────────────────────────────────────────────── + +""" + targetless_probe(case, model_type; energy_in, stage, atom, + optimizer=nothing, pins=nothing, silent=true) -> NamedTuple + +Solve ONE stage with the battery's charge, discharge and OUTGOING energy all +optimized, and return everything measurable about the result. + +# Arguments +- `case::BatteryCase`, `model_type::Type`: `PowerModels.ACPPowerModel` or + `PowerModels.SOCWRConicPowerModel`. + +# Keywords +- `energy_in::AbstractDict`: incoming energy per battery identifier (pu·h). +- `stage::Integer`, `atom::Integer`: which demand realization to impose. +- `optimizer`: defaults to [`acp_optimizer`](@ref) / [`socwr_optimizer`](@ref) + according to `model_type`. +- `pins::Union{Nothing,AbstractDict}`: outgoing energies to PIN by a hard + equality, per battery identifier. `nothing` leaves every battery free — the + targetless probe proper. Any battery not listed stays free. + +# Returns +A `NamedTuple` extending [`extract_stage_solution`](@ref) with + +- `residuals` — the engine-neutral physical residuals of the reported solution; +- `binding` — the binding and nearly binding limits; +- `simultaneous` — ``\\min(p^{ch}_b, p^{dis}_b)`` per battery, which is zero + exactly when the solution does not charge and discharge at once; +- `energy_in_dual` — ``\\partial Q/\\partial e_{b}^{in}``, the marginal value of + the energy the stage INHERITED; +- `pin_dual` — the multiplier of each pinned outgoing energy, i.e. + ``\\partial Q/\\partial e_b^{out}``. + +# Notes +Pinning is done with the same hard equality the strict formulation uses, so when +`pins` covers every battery the model built here is the strict stage problem. +The regression suite asserts exactly that, which is what lets one diagnostic +path serve both the free and the fixed probe without a second formulation. + +**A targetless one-stage solve is myopic.** Nothing in it prices the energy left +in a battery at the end of the stage, so it will rationally discharge as much as +is useful and leave the battery empty. That is not a defect and it is not a +finding: it is the definition of a one-stage problem. Read it for the physics — +what the network could deliver, what bound stopped it, what the energy the stage +INHERITED was worth — and read [`energy_value_curve`](@ref) for the value of what +is left behind. +""" +function targetless_probe(case::BatteryCase, model_type::Type; + energy_in::AbstractDict, + stage::Integer, + atom::Integer, + optimizer = nothing, + pins::Union{Nothing,AbstractDict} = nothing, + silent::Bool = true) + opt = optimizer === nothing ? _default_optimizer(model_type) : optimizer + pm = battery_stage_model(case, model_type; + optimizer = opt, + stage = stage, atom = atom, mode = :free, + state_in = Dict(Int(k) => Float64(v) for (k, v) in energy_in)) + assert_powermodels_provenance(pm, model_type) + + pin_con = Dict{Int,Any}() + if pins !== nothing + bat = pm.ext[:battery] + for (k, v) in pins + haskey(bat[:e_out], Int(k)) || error("pin refers to unknown battery $k") + pin_con[Int(k)] = JuMP.@constraint(pm.model, bat[:e_out][Int(k)] == Float64(v)) + end + end + + silent && JuMP.set_silent(pm.model) + JuMP.optimize!(pm.model) + sol = extract_stage_solution(pm) + + # The pin is written on the model whose objective is the physical stage cost, + # so its multiplier is already in the same units as the value curve a finite + # difference of `sol.objective` would produce — the units the strict target + # dual is reported in too. + pin_dual = Dict{Int,Float64}() + if JuMP.has_duals(pm.model) + for (k, con) in pin_con + pin_dual[k] = JuMP.dual(con) + end + end + + residuals = sol.solved ? + physical_residuals(case.network, case.batteries, stage_hours(case), sol) : + nothing + binding = sol.solved ? binding_constraints(pm, sol) : NamedTuple[] + + return merge(sol, (residuals = residuals, binding = binding, + pin_dual = pin_dual, stage = Int(stage), atom = Int(atom), + model_type = model_type)) +end + +""" + base_feasibility(case, model_type; stage, atom, optimizer=nothing, silent=true) + -> NamedTuple + +Solve the case's network with NO batteries installed, at one stage/atom demand +realization. + +# Returns +The stage solution extended with `residuals`, `binding`, `worst_recourse` and the +nodal-price spread. + +# Notes +This is the admissibility precondition of the entire strict-target construction: +the two-sided physical recourse guarantees that a dynamically reachable battery +target is attainable GIVEN that the base dispatch is feasible at the realized +demand. A case whose base problem already leans on the recourse has no such +guarantee, and every number measured on it would be measuring the recourse price +rather than the network. + +It is also the cheapest possible screen of a candidate benchmark: it answers +"does this system serve this demand at all, and what stops it" before any +battery, any horizon or any policy exists. + +`price_spread` is the ratio of the largest to the smallest active nodal price. It +is the direct locational signal: a system where every bus prices energy the same +cannot reward putting storage in one place rather than another, whatever its +topology looks like. +""" +function base_feasibility(case::BatteryCase, model_type::Type; + stage::Integer, atom::Integer, + optimizer = nothing, silent::Bool = true) + opt = optimizer === nothing ? _default_optimizer(model_type) : optimizer + t0 = time() + pm = battery_stage_model(case, model_type; + optimizer = opt, stage = stage, atom = atom, mode = :none) + assert_powermodels_provenance(pm, model_type) + silent && JuMP.set_silent(pm.model) + JuMP.optimize!(pm.model) + elapsed = time() - t0 + sol = extract_stage_solution(pm) + residuals = sol.solved ? + physical_residuals(case.network, BatterySpec[], stage_hours(case), sol) : + nothing + binding = sol.solved ? binding_constraints(pm, sol) : NamedTuple[] + prices = collect(values(sol.price_active)) + spread = isempty(prices) || minimum(prices) <= 0 ? NaN : + maximum(prices) / minimum(prices) + return merge(sol, (residuals = residuals, binding = binding, + worst_recourse = worst_recourse(sol), + price_spread = spread, elapsed = elapsed, + stage = Int(stage), atom = Int(atom), model_type = model_type)) +end + +"The solver each formulation is solved with unless the caller says otherwise." +function _default_optimizer(model_type::Type) + model_type === PowerModels.ACPPowerModel && return acp_optimizer() + model_type === PowerModels.SOCWRConicPowerModel && return socwr_optimizer() + error("no default optimizer for $model_type; pass one explicitly") +end + +""" + targetless_batch(case, model_type; states, stages, atoms, optimizer) + -> Vector{NamedTuple} + +Run [`targetless_probe`](@ref) over the Cartesian product of incoming-energy +vectors, stages and atoms. + +# Notes +Every combination is retained, including the ones that failed to solve: a batch +that silently drops its failures reports a success rate of 100 % by construction. +""" +function targetless_batch(case::BatteryCase, model_type::Type; + states::AbstractVector{<:AbstractDict}, + stages::AbstractVector{<:Integer}, + atoms::AbstractVector{<:Integer}, + optimizer = nothing) + out = NamedTuple[] + for (si, e) in enumerate(states), t in stages, k in atoms + p = targetless_probe(case, model_type; energy_in = e, stage = t, atom = k, + optimizer = optimizer) + push!(out, merge(p, (state_index = si,))) + end + return out +end + +# ───────────────────────────────────────────────────────────────────────────── +# B3 — the fixed-outgoing-energy value probe +# ───────────────────────────────────────────────────────────────────────────── + +""" + energy_value_curve(case, model_type; battery, energy_in, stage, atom, grid, + hold=nothing, optimizer=nothing, fd_tolerance=5e-3) + -> NamedTuple + +The stage value as a function of the outgoing energy of ONE battery, together +with its multiplier and a finite-difference check of that multiplier. + +# Keywords +- `battery::Integer`: which battery's outgoing energy is swept. +- `energy_in::AbstractDict`: the incoming state to sweep from. +- `grid::AbstractVector{<:Real}`: outgoing energies to solve at. Values outside + the battery's one-stage reachable interval are reported as UNREACHABLE rather + than solved, because a hard equality on an unreachable target is an infeasible + model, not an expensive one. +- `hold`: `nothing` to leave the other batteries free, or a + `Dict{Int,Float64}` pinning them too. +- `fd_tolerance::Real`: relative agreement required between an interior + multiplier and its central finite difference at a SMOOTH point. +- `kink_tolerance::Real`: relative disagreement between the one-sided slopes + above which an interior point is classified nonsmooth. + +# Returns +A `NamedTuple` with + +- `energy::Vector{Float64}`, `value::Vector{Float64}` — the value curve; +- `lambda::Vector{Float64}` — the strict target multiplier at each grid point, + i.e. ``\\partial Q/\\partial e^{out}``; +- `fd::Vector{Float64}` — the central finite difference of `value` at interior + points (`NaN` at the ends); +- `fd_error::Vector{Float64}` — relative disagreement between `lambda` and `fd` + at SMOOTH interior points; +- `fd_ok::Bool` — every smooth interior point agreed within `fd_tolerance`; +- `nonsmooth::Vector{Bool}` — the one-sided slopes disagree by more than + `kink_tolerance`, so the value curve has a kink at this point; +- `bracketed::Vector{Bool}` — at a nonsmooth point, whether the reported + multiplier lies between the two one-sided slopes, which is the correct + statement for a subgradient of a convex value function; +- `endpoint::Vector{Bool}` — the grid point sits at an endpoint of the reachable + interval, where the multiplier is a subgradient and finite differences bracket + rather than match it; +- `solved`, `status`, `residuals`, `worst_recourse`, `binding`, `prices` per + point. + +# Notes +This is the principal tool for locating buses where the SOC-WR relaxation +misprices stored energy. The interesting quantity is not the objective GAP +between the two formulations — a relaxation is below the true model everywhere +and that says nothing about decisions — but the difference in +``\\partial Q/\\partial e^{out}``: the price the two models put on carrying one +more unit of energy out of this stage. A bus where the two models disagree about +that price is a bus where a cut built on the relaxation will steer storage +differently from the truth. + +**Endpoints are not evidence.** At an endpoint of the reachable interval the +target sits on a bound, the multiplier is a subgradient, and two solvers may +report two valid values that differ by orders of magnitude. Interior points are +where a multiplier comparison means something, which is why they are the ones +finite differences are checked against. +""" +function energy_value_curve(case::BatteryCase, model_type::Type; + battery::Integer, + energy_in::AbstractDict, + stage::Integer, + atom::Integer, + grid::AbstractVector{<:Real}, + hold::Union{Nothing,AbstractDict} = nothing, + optimizer = nothing, + fd_tolerance::Real = 5e-3, + kink_tolerance::Real = 5e-2) + b = only(filter(x -> x.index == Int(battery), case.batteries)) + lo, hi = reachable_interval(b, Float64(energy_in[b.index]), stage_hours(case)) + n = length(grid) + + energy = Float64.(collect(grid)) + value = fill(NaN, n) + lambda = fill(NaN, n) + solved = falses(n) + status = Vector{Any}(undef, n) + reachable = falses(n) + endpoint = falses(n) + recourse_used = fill(NaN, n) + residuals = Vector{Any}(undef, n) + binding = Vector{Any}(undef, n) + prices = Vector{Any}(undef, n) + + for (i, e) in enumerate(energy) + # A tolerance on reachability, not on feasibility: the interval endpoints + # are computed in floating point and a grid built from them would + # otherwise fall a rounding error outside itself. + reachable[i] = lo - 1e-9 <= e <= hi + 1e-9 + endpoint[i] = reachable[i] && (abs(e - lo) <= 1e-9 || abs(e - hi) <= 1e-9) + reachable[i] || (status[i] = :unreachable; residuals[i] = nothing; + binding[i] = NamedTuple[]; prices[i] = nothing; continue) + + pins = Dict{Int,Float64}(b.index => clamp(e, lo, hi)) + hold === nothing || for (k, v) in hold + Int(k) == b.index && continue + pins[Int(k)] = Float64(v) + end + p = targetless_probe(case, model_type; energy_in = energy_in, stage = stage, + atom = atom, optimizer = optimizer, pins = pins) + status[i] = p.status + solved[i] = p.solved + residuals[i] = p.residuals + binding[i] = p.binding + prices[i] = (active = p.price_active, reactive = p.price_reactive) + if p.solved + value[i] = p.cost_stage + lambda[i] = get(p.pin_dual, b.index, NaN) + recourse_used[i] = worst_recourse(p) + end + end + + # ── Finite differences at interior grid points ─────────────────────────── + # The stage value is convex and PIECEWISE smooth in the outgoing energy: a + # binding generator, branch or voltage limit puts a kink in it. A central + # difference taken ACROSS a kink is not an approximation of anything, so the + # check first classifies each interior point by comparing its one-sided + # slopes and only compares λ against a central difference where the curve is + # locally smooth. At a kink the correct statement about a subgradient is that + # it lies BETWEEN the one-sided slopes, and that is what is recorded. + fd = fill(NaN, n) + fd_error = fill(NaN, n) + nonsmooth = falses(n) + bracketed = falses(n) + ok = true + for i in 2:(n - 1) + (solved[i - 1] && solved[i] && solved[i + 1]) || continue + endpoint[i] && continue + h⁻ = energy[i] - energy[i - 1] + h⁺ = energy[i + 1] - energy[i] + slope⁻ = (value[i] - value[i - 1]) / h⁻ + slope⁺ = (value[i + 1] - value[i]) / h⁺ + if abs(slope⁺ - slope⁻) / max(abs(slope⁻), abs(slope⁺), 1e-8) > kink_tolerance + nonsmooth[i] = true + bracketed[i] = min(slope⁻, slope⁺) - 1e-6 <= lambda[i] <= max(slope⁻, slope⁺) + 1e-6 + continue + end + # Non-uniform central difference: exact for a quadratic, which is what + # makes the check meaningful on a grid that is denser near an endpoint. + fd[i] = (h⁻^2 * value[i + 1] - h⁺^2 * value[i - 1] - + (h⁻^2 - h⁺^2) * value[i]) / (h⁻ * h⁺ * (h⁻ + h⁺)) + scale = max(abs(fd[i]), abs(lambda[i]), 1e-8) + fd_error[i] = abs(fd[i] - lambda[i]) / scale + fd_error[i] <= fd_tolerance || (ok = false) + end + + return (battery = b.index, bus = b.bus, stage = Int(stage), atom = Int(atom), + model_type = model_type, + reachable_lo = lo, reachable_hi = hi, + energy = energy, value = value, lambda = lambda, + fd = fd, fd_error = fd_error, fd_ok = ok, + nonsmooth = nonsmooth, bracketed = bracketed, + reachable = reachable, endpoint = endpoint, + solved = solved, status = status, + worst_recourse = recourse_used, residuals = residuals, + binding = binding, prices = prices) +end + +""" + compare_value_curves(case; battery, energy_in, stage, atom, grid, kwargs...) + -> NamedTuple + +Run [`energy_value_curve`](@ref) under BOTH formulations and difference their +marginal stored-energy values. + +# Returns +`(acp, soc, energy, dlambda, dlambda_interior, max_abs_dlambda, + max_rel_dlambda, reversal)` where `dlambda = λ_SOC − λ_ACP`, restricted to grid +points both formulations solved. + +# Notes +`reversal` is `true` when the two formulations disagree about the SIGN of the +marginal value at some interior point — the strongest form of mispricing, because +it means the relaxation would store energy where the true model would spend it. +A magnitude difference changes how much a policy hedges; a sign difference +changes what it does. + +`dlambda_interior` excludes two kinds of grid point, and the exclusions are the +difference between evidence and an artefact: + +- **reachable-interval endpoints**, where a multiplier is a subgradient and a + difference between two valid subgradients is not evidence of anything; +- **points that used physical recourse**, above `max_recourse` in either + formulation. There, part of the marginal value is the recourse PRICE — a number + chosen to be far above any generator — rather than the network's valuation of + stored energy, and it produces enormous, meaningless disagreements. A candidate + whose apparent mechanism lives only at such points is exactly what this phase's + review conditions say to reject. +""" +function compare_value_curves(case::BatteryCase; + battery::Integer, + energy_in::AbstractDict, + stage::Integer, + atom::Integer, + grid::AbstractVector{<:Real}, + max_recourse::Real = 1e-6, + kwargs...) + acp = energy_value_curve(case, PowerModels.ACPPowerModel; + battery = battery, energy_in = energy_in, stage = stage, + atom = atom, grid = grid, kwargs...) + soc = energy_value_curve(case, PowerModels.SOCWRConicPowerModel; + battery = battery, energy_in = energy_in, stage = stage, + atom = atom, grid = grid, kwargs...) + n = length(acp.energy) + dλ = fill(NaN, n) + for i in 1:n + (acp.solved[i] && soc.solved[i]) || continue + dλ[i] = soc.lambda[i] - acp.lambda[i] + end + clean = [i for i in 1:n if acp.solved[i] && soc.solved[i] && + acp.worst_recourse[i] <= max_recourse && + soc.worst_recourse[i] <= max_recourse] + interior = [i for i in clean if !isnan(dλ[i]) && !acp.endpoint[i] && !soc.endpoint[i]] + reversal = any(i -> sign(acp.lambda[i]) != sign(soc.lambda[i]) && + abs(acp.lambda[i]) > 1e-6 && abs(soc.lambda[i]) > 1e-6, + interior) + rel = [abs(dλ[i]) / max(abs(acp.lambda[i]), 1e-8) for i in interior] + return (acp = acp, soc = soc, energy = acp.energy, dlambda = dλ, + dlambda_interior = dλ[interior], + max_abs_dlambda = isempty(interior) ? NaN : maximum(abs, dλ[interior]), + max_rel_dlambda = isempty(rel) ? NaN : maximum(rel), + reversal = reversal, interior = interior, clean = clean, + num_recourse_excluded = count(i -> acp.solved[i] && soc.solved[i], 1:n) - + length(clean)) +end + +# ───────────────────────────────────────────────────────────────────────────── +# B4 — the multiperiod deterministic equivalent +# ───────────────────────────────────────────────────────────────────────────── + +""" + deterministic_equivalent(case, atoms; model_type=ACPPowerModel, + optimizer=nothing, energy_initial=nothing, + silent=true, time_limit=nothing) -> NamedTuple + +Solve the WHOLE horizon jointly for one complete demand path: the +perfect-foresight (wait-and-see) solution. + +# Arguments +- `atoms::AbstractVector{<:Integer}`: the atom index realized at each stage. Its + length is the horizon solved. + +# Keywords +- `model_type::Type`: `ACPPowerModel` — the physical reference — or + `SOCWRConicPowerModel`, which is a RELAXED perfect-foresight solve and is not + a physically attainable cost. +- `energy_initial`: `nothing` for the case's own ``e_{b,0}``, or a dictionary. + +# Returns +A `NamedTuple` with the solver status, the total and per-stage costs, the full +stagewise solution in the shared schema, the terminal energy, the throughput, the +simultaneous-charge audit, the recourse totals and the physical residuals. + +# Notes +There is no policy here, no target, no target slack and no future-cost +approximation: every charge, discharge and outgoing energy over the whole horizon +is chosen at once, knowing the entire demand path. The battery dynamics, the +bounds, the two-sided physical recourse and the cost accounting are the study's +own, because the model is assembled from the same per-stage builder the study +trains on — one `pm` per stage, all in ONE JuMP model, coupled only by +``e^{in}_{b,t+1} = e^{out}_{b,t}``. + +That coupling is the only thing this function writes. In particular it does not +write a network equation, and `assert_powermodels_provenance` is run on every +stage. + +**What the resulting number is.** For a single path it is the cost a clairvoyant +operator would have paid. Averaged over a protocol of paths it is a WAIT-AND-SEE +LOWER BOUND on the nonanticipative stochastic problem — see +[`perfect_foresight_panel`](@ref) for what may and may not be concluded from the +gap to a policy. + +Each stage's build replaces the JuMP objective (PowerModels' own +`objective_min_fuel_and_flow_cost` does), so the per-stage objective is captured +immediately after each build and the horizon objective is set from their sum at +the end. Reading the objective any later would return the last stage's cost. +""" +function deterministic_equivalent(case::BatteryCase, + atoms::AbstractVector{<:Integer}; + model_type::Type = PowerModels.ACPPowerModel, + optimizer = nothing, + energy_initial = nothing, + silent::Bool = true, + time_limit = nothing) + T = length(atoms) + T >= 1 || throw(ArgumentError("a deterministic equivalent needs at least one stage")) + T <= horizon(case.demand) || + throw(ArgumentError("path has $T stages but the frozen support covers $(horizon(case.demand))")) + opt = optimizer === nothing ? _default_optimizer(model_type) : optimizer + e0 = energy_initial === nothing ? + Dict{Int,Float64}(b.index => b.energy_initial for b in case.batteries) : + Dict{Int,Float64}(Int(k) => Float64(v) for (k, v) in energy_initial) + + model = JuMP.Model(opt) + silent && JuMP.set_silent(model) + time_limit === nothing || JuMP.set_time_limit_sec(model, Float64(time_limit)) + + pms = Vector{Any}(undef, T) + stage_obj = Vector{Any}(undef, T) + for t in 1:T + pms[t] = battery_stage_model(case, model_type; + jump_model = model, + stage = t, atom = atoms[t], mode = :free, + state_in = t == 1 ? e0 : nothing) + assert_powermodels_provenance(pms[t], model_type) + # Captured NOW: the next stage's build will overwrite the model objective. + stage_obj[t] = JuMP.objective_function(model) + end + + # The one thing this function writes: the interstage state coupling. + link = Dict{Tuple{Int,Int},Any}() + for t in 2:T, b in case.batteries + link[(t, b.index)] = JuMP.@constraint(model, + pms[t].ext[:battery][:e_in][b.index] == + pms[t - 1].ext[:battery][:e_out][b.index]) + end + + JuMP.@objective(model, Min, sum(stage_obj)) + JuMP.optimize!(model) + status = JuMP.termination_status(model) + ok = status in ACCEPTED_STATUSES + + stages = [extract_stage_solution(pms[t]) for t in 1:T] + residuals = ok ? [physical_residuals(case.network, case.batteries, stage_hours(case), s) + for s in stages] : nothing + cost = ok ? [s.cost_stage for s in stages] : fill(NaN, T) + total = ok ? sum(cost) : NaN + Δt = stage_hours(case) + + throughput = Dict{Int,Float64}(b.index => + sum(Δt * (stages[t].p_ch[b.index] + stages[t].p_dis[b.index]) for t in 1:T) + for b in case.batteries) + simultaneous = ok ? maximum(min(stages[t].p_ch[b.index], stages[t].p_dis[b.index]) + for t in 1:T, b in case.batteries) : NaN + worst_deficit = ok ? maximum(max(0.0, maximum(values(stages[t].deficit); init = 0.0)) for t in 1:T) : NaN + worst_surplus = ok ? maximum(max(0.0, maximum(values(stages[t].surplus); init = 0.0)) for t in 1:T) : NaN + + return (status = status, solved = ok, total_cost = total, + stage_cost = cost, cumulative_cost = ok ? cumsum(cost) : fill(NaN, T), + stages = stages, residuals = residuals, + energy_initial = e0, + energy_terminal = Dict{Int,Float64}(b.index => stages[T].energy_out[b.index] + for b in case.batteries), + throughput = throughput, simultaneous = simultaneous, + worst_deficit = worst_deficit, worst_surplus = worst_surplus, + cost_deficit = ok ? sum(s.cost_deficit for s in stages) : NaN, + cost_surplus = ok ? sum(s.cost_surplus for s in stages) : NaN, + atoms = collect(Int.(atoms)), horizon = T, model_type = model_type, + link = link, model = model) +end + +""" + record_trajectory!(rec, result, case; scenario) + +Write every stage of a [`deterministic_equivalent`](@ref) result into a +[`SolutionRecorder`](@ref) in the shared schema. +""" +function record_trajectory!(rec::SolutionRecorder, result, case::BatteryCase; + scenario::Integer) + for t in 1:result.horizon + record_stage_solution!(rec, result.stages[t], case; scenario = scenario, stage = t) + result.residuals === nothing && continue + r = result.residuals[t] + record!(rec, scenario, t, "residual_equality", 0, + max(r.branch_flow, r.active_balance, r.reactive_balance, r.transition)) + end + return rec +end + +# ───────────────────────────────────────────────────────────────────────────── +# B5 — the perfect-foresight panel +# ───────────────────────────────────────────────────────────────────────────── + +""" + perfect_foresight_panel(case, protocol; ids=nothing, model_type=ACPPowerModel, + optimizer=nothing, retry=true, verbose=false) + -> NamedTuple + +Solve one true-ACP deterministic equivalent per GLOBAL scenario identifier and +summarize the panel. + +# Arguments +- `protocol::AbstractMatrix{<:Integer}`: the `(stages × scenarios)` atom-index + matrix, from [`scenario_index_matrix`](@ref). + +# Keywords +- `ids`: the global scenario identifiers to solve, defaulting to every column. + A column's identifier is its INDEX IN THE PROTOCOL and never changes. +- `retry::Bool`: on a first-attempt failure, re-solve once with a completely + fresh model and solver. + +# Returns +A `NamedTuple` with one row per requested identifier — cost, status, first-attempt +status, recourse, terminal energy, throughput — plus the panel mean, standard +deviation and standard error, and the full per-scenario results. + +# Notes +**Fail closed.** Every requested identifier is retained: none is replaced, +dropped or renumbered, and if any is unsolved after the retry the panel is marked +incomplete. A mean over the scenarios that happened to succeed is a mean over a +different problem, and no tolerance makes it comparable to a mean over all of +them. The first-attempt status is recorded separately from the retry status, +because "solved on the second try" is information about the case. + +**What the mean is.** The true-ACP perfect-foresight mean is a WAIT-AND-SEE LOWER +BOUND on the nonanticipative stochastic problem: a clairvoyant operator cannot be +beaten by one who must decide before seeing the future. The gap between a +policy's cost and this bound is therefore diagnostic HEADROOM, and it contains +the value of future information — which no nonanticipative policy, TS-DDR or +SDDP, can recover. It is not a target, it is not attainable, and a policy that +closes half of it has not necessarily left anything on the table. + +The bound may be computed during screening, on the screening protocol. Its +relationship to a trained policy is assessed only on PAIRED paths, after that +policy exists. +""" +function perfect_foresight_panel(case::BatteryCase, protocol::AbstractMatrix{<:Integer}; + ids = nothing, + model_type::Type = PowerModels.ACPPowerModel, + optimizer = nothing, + retry::Bool = true, + verbose::Bool = false) + columns = ids === nothing ? collect(1:size(protocol, 2)) : collect(Int.(ids)) + all(c -> 1 <= c <= size(protocol, 2), columns) || + throw(ArgumentError("scenario identifier outside the protocol's 1:$(size(protocol, 2))")) + + rows = NamedTuple[] + results = Dict{Int,Any}() + for c in columns + path = protocol[:, c] + res = deterministic_equivalent(case, path; model_type = model_type, + optimizer = optimizer) + first_status = res.status + if !res.solved && retry + # A completely fresh model and solver, not a re-solve: a re-solve + # from a failed interior point is a different algorithm, not a + # second attempt at the same one. + res = deterministic_equivalent(case, path; model_type = model_type, + optimizer = optimizer) + end + results[c] = res + push!(rows, (scenario = c, solved = res.solved, + first_status = first_status, status = res.status, + cost = res.total_cost, + worst_deficit = res.worst_deficit, worst_surplus = res.worst_surplus, + simultaneous = res.simultaneous, + terminal_energy = sum(values(res.energy_terminal)), + throughput = sum(values(res.throughput)))) + verbose && @printf(" scenario %4d %-16s cost %14.4f\n", c, string(res.status), + res.total_cost) + end + + complete = all(r -> r.solved, rows) + costs = [r.cost for r in rows if r.solved] + n = length(costs) + return (rows = rows, results = results, complete = complete, + num_requested = length(columns), num_solved = n, + mean = n == 0 ? NaN : mean(costs), + std = n < 2 ? NaN : std(costs), + sem = n < 2 ? NaN : std(costs) / sqrt(n), + worst_deficit = maximum(r -> r.worst_deficit, rows; init = 0.0), + worst_surplus = maximum(r -> r.worst_surplus, rows; init = 0.0), + model_type = model_type) +end + +""" + paired_difference(a::AbstractVector, b::AbstractVector) -> NamedTuple + +Paired mean difference `a − b` with its standard error, `t` statistic and 95 % +confidence interval. + +# Notes +Pairing is what makes a comparison of two policies on a common demand protocol +decidable: the spread of cost ACROSS scenarios is typically an order of magnitude +larger than the difference BETWEEN policies on the same scenario, so an unpaired +comparison of the same sample size would resolve nothing. + +The interval uses the normal quantile 1.96 rather than a `t` quantile; at the +sample sizes this study reports on (hundreds of paired paths) the difference is +in the third decimal of the interval and is not worth a distributions dependency +in a file every consumer loads. +""" +function paired_difference(a::AbstractVector, b::AbstractVector) + length(a) == length(b) || throw(ArgumentError("paired vectors must have equal length")) + d = Float64.(a) .- Float64.(b) + n = length(d) + n >= 2 || throw(ArgumentError("a paired difference needs at least two pairs")) + m = mean(d) + se = std(d) / sqrt(n) + return (n = n, mean = m, std = std(d), sem = se, + t = se == 0 ? NaN : m / se, + ci = (m - 1.96 * se, m + 1.96 * se), + wins = count(<(0), d)) +end + + +# ───────────────────────────────────────────────────────────────────────────── +# The deterministic-forecast reference policy +# ───────────────────────────────────────────────────────────────────────────── + +""" + central_atom_path(case, T) -> Vector{Int} + +The atom whose total multiplier is closest to the stage's PROBABILITY-WEIGHTED +mean, for each stage — i.e. the single scenario a forecaster would use. +""" +function central_atom_path(case::BatteryCase, T::Integer) + return [begin + p = atom_probabilities(case.demand, t) + μ = sum(p[k] * mean(demand_multipliers(case.demand, t, k)) + for k in eachindex(p)) + argmin([abs(mean(demand_multipliers(case.demand, t, k)) - μ) + for k in eachindex(p)]) + end for t in 1:Int(T)] +end + +""" + forecast_policy_cost(case, protocol; columns, optimizer=nothing) -> NamedTuple + +The cost of the DETERMINISTIC-FORECAST policy: optimise once against a single +forecast path, then operate those storage targets on every realized path. + +# How it is built +1. Solve one true-ACP deterministic equivalent against + [`central_atom_path`](@ref) — the forecaster's single scenario. +2. Take its outgoing battery energies as a fixed target schedule. +3. On each evaluation path, walk forward imposing those targets as STRICT + equalities, clamping each into the one-stage reachable interval of the state + actually reached. Clamping is not a fudge: a real forecast-based operator + cannot charge past its rating either, and the reachable map is the same one + the strict policy uses. + +# Why it is reported +`VSS = forecast_cost − sddp_cost` is the **value of the stochastic solution**: how +much is lost by ignoring uncertainty and operating a single forecast. It is the +direct test of whether a case's uncertainty structure requires a policy at all. +If VSS is near zero, every method — SDDP, TS-DDR, a spreadsheet — costs the same, +and no comparison between them can resolve anything, however large the other +gaps look. +""" +function forecast_policy_cost(case::BatteryCase, protocol::AbstractMatrix{<:Integer}; + columns, optimizer = nothing) + T = size(protocol, 1) + opt = optimizer === nothing ? acp_optimizer() : optimizer + plan = deterministic_equivalent(case, central_atom_path(case, T)) + plan.solved || error("the forecast deterministic equivalent did not solve") + schedule = [Dict{Int,Float64}(b.index => plan.stages[t].energy_out[b.index] + for b in case.batteries) for t in 1:T] + + Δt = stage_hours(case) + costs = Float64[] + worst_rec = 0.0 + for c in collect(Int.(columns)) + e = Dict{Int,Float64}(b.index => b.energy_initial for b in case.batteries) + total = 0.0 + for t in 1:T + tgt = Dict{Int,Float64}() + for b in case.batteries + lo, hi = reachable_interval(b, e[b.index], Δt) + tgt[b.index] = clamp(schedule[t][b.index], lo, hi) + end + sol = solve_strict_stage(case, PowerModels.ACPPowerModel; stage = t, + atom = protocol[t, c], energy_in = e, + target = tgt, optimizer = opt) + sol.solved || error("forecast policy: stage $t of scenario $c did not solve") + total += sol.cost_stage + worst_rec = max(worst_rec, worst_recourse(sol)) + e = tgt + end + push!(costs, total) + end + return (costs = costs, mean = mean(costs), max = maximum(costs), + worst_recourse = worst_rec, plan = plan) +end diff --git a/examples/BatteryStorageOPF/battery_powermodels.jl b/examples/BatteryStorageOPF/battery_powermodels.jl new file mode 100644 index 0000000..f9f555f --- /dev/null +++ b/examples/BatteryStorageOPF/battery_powermodels.jl @@ -0,0 +1,1154 @@ +# battery_powermodels.jl +# +# The battery layer on top of PowerModels.jl, and nothing else. +# +# THE BOUNDARY, stated once and enforced by the tests: +# +# PowerModels.jl owns buses, generators, branches, voltage variables, the +# reference angle, Ohm's law at both branch ends, +# transformer taps and phase shifts, shunts, angle- +# difference limits, apparent-power limits at both ends, +# the nodal active and reactive balances, generator +# bounds and generator cost. +# this file owns batteries: their energy state, charge/discharge +# controls, state transition, unity-power-factor active +# injection, throughput cost, the strict outgoing-energy +# target equality, the two-sided nodal active-power +# recourse, and the demand parameterization. +# +# There is no handwritten AC trigonometry and no handwritten SOC-WR lifted +# branch equation anywhere below. Selecting `PowerModels.ACPPowerModel` or +# `PowerModels.SOCWRConicPowerModel` selects the network formulation and nothing +# in this file changes. +# +# HOW THE BATTERY REACHES THE NODAL BALANCE. +# PowerModels' `constraint_power_balance` is form-specific and closed: it writes +# the whole balance in one `@constraint`. Its ONLY documented extension point +# for an additional nodal injection is the `storage` component, which enters +# every form's balance as `- sum(ps[s] for s in bus_storage)` on the injection +# side and `- sum(qs[s] ...)` on the reactive side. This file therefore installs +# exactly ONE storage element per bus as an INJECTION CARRIER and defines what +# flows through it: +# +# ps[i] = Δp^d_i - p^{bat}_i - d_i + s_i qs[i] = Δq^d_i +# +# so the stock balance PowerModels writes reads, at bus i, +# +# Σ p_arcs = Σ pg + p^{bat}_i + d_i - s_i - (p^d_i + Δp^d_i) - g^s_i |V_i|² +# Σ q_arcs = Σ qg - (q^d_i + Δq^d_i) + b^s_i |V_i|² +# +# which is the model in the plan: the battery injects at unity power factor, the +# recourse pair enters the ACTIVE balance with opposite signs, the reactive +# balance is HARD, and demand is parameterized by the fixed deviations Δp^d, Δq^d +# that carry the realized stage/atom demand. `ps` and `qs` are JuMP EXPRESSIONS, +# not variables, so this adds no variable and no equality row of its own. + +using JuMP +using PowerModels +using Ipopt +using Clarabel +using LinearAlgebra +using Printf +import MathOptInterface as MOI + +# Include guards: several public files include the same shared sources, and a +# second `include` of a file that defines a struct is an error, not a no-op. +@isdefined(BatterySpec) || include(joinpath(@__DIR__, "battery_case.jl")) +@isdefined(SolutionRecorder) || include(joinpath(@__DIR__, "battery_solution_schema.jl")) + +PowerModels.silence() + +# ───────────────────────────────────────────────────────────────────────────── +# Solvers +# +# One definition each, used by the diagnostics, by the SDDP baseline and by the +# regression suite. Two engines that disagree because they were solved at +# different tolerances is a failure mode this study has already paid for once. +# ───────────────────────────────────────────────────────────────────────────── + +""" + acp_optimizer(; tol=1e-10, max_iter=3000) -> JuMP optimizer factory + +Interior-point NLP solver for the true-ACP model. + +# Notes +Tolerance is tightened well below the physical tolerances the study reports at, +because a variable parked a solver tolerance below its bound shifts a +positively-priced objective by a near-constant amount every stage, which then +looks like a systematic model difference between two engines. +""" +acp_optimizer(; tol::Real = 1e-10, max_iter::Integer = 3000) = + JuMP.optimizer_with_attributes(Ipopt.Optimizer, + "print_level" => 0, + "tol" => tol, + "max_iter" => Int(max_iter), + "sb" => "yes") + +""" + socwr_optimizer(; tol=1e-8, equilibrate=true, max_iter=10_000) + -> JuMP optimizer factory + +Conic solver for the SOC-WR relaxation. + +# Notes +Nothing here retries a failed solve at a different setting: a retry ladder +chooses which duals become cuts, and cut generation must stay stock. The +settings are therefore chosen ONCE, by measurement, to be the ones under which +the solver does not fail in the first place. Two independent measurements fix +them, and they pull in opposite directions: + +**Tolerance and iteration cap, measured 2026-08-06.** These are ONE frozen +correctness configuration, chosen once and applied to every candidate. They +correct an invalid inherited setting; they are not tuned per case. + +The earlier default of `tol = 1e-6, max_iter = 500` did not merely lose +precision — it returned the WRONG ANSWER while reporting `OPTIMAL`. Solves are +bit-reproducible (five repeats, spread exactly 0.00), so this is not noise. On +one cycle-module case with the storage target pinned: + +| tolerance | max_iter | status | objective | +|---|---|---|---| +| `1e-6` | 500 … 50,000 | OPTIMAL | 296,951 | +| `1e-8` | 500 | ALMOST_OPTIMAL | 323,913 | +| `1e-8` | 2,000 | ALMOST_OPTIMAL | 350,788 | +| **`1e-8`** | **10,000** | **OPTIMAL** | **351,411** | +| `1e-8` | 50,000 | OPTIMAL | 351,411 | + +The true optimum is 351,411, against ACP's 358,806 — a 2.1 % relaxation gap. At +`1e-6` the reported value is 15.5 % BELOW it, and no iteration budget helps, +because termination is on the loose tolerance itself. `max_iter = 500` was a +budget inherited from a 57-bus case; a several-hundred-bus conic program needs +far more. + +Why this matters beyond precision: SDDP consumes these solves' DUALS as cuts. +Objectives wrong by percent-level amounts, varying with the pinned state, make +successive cuts mutually inconsistent — which is how individually-healthy +subproblems become a collectively infeasible SDDP. + +`max_iter` is a CAP, not a target; record the iterations and time actually used. + +**Objective convergence is necessary but NOT sufficient.** A production +subproblem must satisfy all three: `OPTIMAL` status, a stable objective, and +stable STATE DUALS validated against finite differences (or one-sided brackets +at a kink). The duals can still move after the objective has settled, and the +duals are what become cuts. `ALMOST_OPTIMAL` may be kept as diagnostic evidence +but can never generate an accepted cut or a headline number. + +**Equilibration is ON, and the objective is PHYSICAL, measured 2026-08-10.** +The two settings were tested together, as a 2×2×2 sweep over objective scaling, +equilibration and tolerance, at two BLAS thread counts, on `case500_goc` bare +and with one cycle module added to it. Only one corner solves the problem that +was posed: + +| objective | equilibration | status | objective | max violation | +|---|---|---|---|---| +| **physical** | **on** | **OPTIMAL**, 27–30 iterations | **453 838.4553 / 617 807.7916** | **≤6.3e-9** | +| physical | off | OPTIMAL, 97–208 iterations | 453 590.70 / 617 387.25 | 3.5e-4 | +| divided by the recourse price | on | NUMERICAL_ERROR / SLOW_PROGRESS | — | — | +| divided by the recourse price | off | ALMOST_OPTIMAL / NUMERICAL_ERROR | — | — | + +Read the second row before the third: with equilibration off, the lower +objective is not a better optimum, it is a point that violates the conic model +by 2.4e-4–3.5e-4 and is not feasible. Only the first row returns a converged +value at a residual worth quoting, and it is the only one that is `OPTIMAL` at +both thread counts on both arms. Tightening to `1e-10` reproduces its objective +to four decimals in one extra iteration. + +Rescaling the objective is therefore rejected as a numerical device: a solver +whose own equilibration already normalizes rows and columns gains nothing from +a second, cruder rescaling of one block, and Clarabel measurably fails on the +rescaled program. Everything this file builds, solves and reports is in one +physical unit system — the objective units of the PGLib case — with no +conversion anywhere. + +The lesson stands, only pointed the other way: a setting that makes an isolated +probe stop failing is not thereby the setting that makes the whole method run. +""" +socwr_optimizer(; tol::Real = 1e-8, equilibrate::Bool = true, + max_iter::Integer = 10_000) = + JuMP.optimizer_with_attributes(Clarabel.Optimizer, + "verbose" => false, + "tol_gap_abs" => tol, + "tol_gap_rel" => tol, + "tol_feas" => tol, + "equilibrate_enable" => equilibrate, + "max_iter" => Int(max_iter)) + +const ACCEPTED_STATUSES = (MOI.OPTIMAL, MOI.LOCALLY_SOLVED) + +""" + worst_recourse(sol) -> Float64 + +The largest USE of physical active-power recourse in a solved stage, in pu. + +# Notes +Clamped at zero on purpose. An interior-point solver parks a nonnegative variable +a tolerance BELOW its zero bound — this study routinely sees `-1e-8` — and a +"worst recourse" of `-1e-8` is not a negative amount of unserved load, it is +zero. Reporting the raw minimum would also make the admissibility rule compare a +negative number against a positive tolerance and pass for the wrong reason. +""" +worst_recourse(sol) = max(0.0, + maximum(values(sol.deficit); init = 0.0), + maximum(values(sol.surplus); init = 0.0)) + +# ───────────────────────────────────────────────────────────────────────────── +# Injection carriers +# ───────────────────────────────────────────────────────────────────────────── + +""" + network_with_carriers(case::BatteryCase) -> Dict{String,Any} + +Return a copy of the frozen network augmented with one PowerModels `storage` +element per bus. + +# Arguments +- `case::BatteryCase`: the frozen case. + +# Returns +- A deep copy of `case.network` whose `"storage"` table has exactly one entry + per bus, keyed by the bus identifier as a string. + +# Notes +The storage elements carry no dynamics of their own: this file never calls +`PowerModels.variable_storage_power`, `constraint_storage_state`, +`constraint_storage_losses`, `constraint_storage_complementarity_*` or +`constraint_storage_thermal_limit`. Their sole role is to make `ref[:bus_storage]` +nonempty so that the stock nodal balance contains a `ps`/`qs` term this file can +bind to an expression (see the file header). + +Their numeric fields are filled with neutral, valid values only so that +PowerModels' own data checks accept the table; they are never read by any +constraint that this problem specification builds. The battery ratings that +matter live in `case.batteries` and are enforced by this file's own bounds. + +The network is COPIED because PowerModels mutates the dictionaries it is given; +sharing one parse across two formulations is how a case export once stopped +being byte-reproducible. + +**Generator costs come through UNCHANGED.** The polynomial coefficients this +returns are the case's own, so `PowerModels.objective_min_fuel_and_flow_cost` +builds the physical generation cost and every stage model this file assembles is +in the case's physical objective units. A stock `PowerModels.solve_opf` on +`case.network` is then a valid external reference for any of them, comparable +without conversion. +""" +function network_with_carriers(case::BatteryCase) + net = deepcopy(case.network) + # Fail closed on component classes this study's cost accounting does not + # decompose. PowerModels would happily build them and their cost would then + # sit inside the objective but outside `cost_generation`, so a cross-engine + # objective comparison would disagree with the sum of its own parts. + isempty(get(net, "dcline", Dict())) || + error("network_with_carriers: HVDC lines are not supported by this study's cost decomposition") + isempty(get(net, "switch", Dict())) || + error("network_with_carriers: switches are not supported by this study") + haskey(net, "storage") && !isempty(net["storage"]) && + error("network_with_carriers: the case already declares storage; the injection carriers would collide with it") + + # The cost decomposition in `extract_stage_solution` re-evaluates each + # generator's polynomial at the reported dispatch, so a piecewise-linear cost + # model would land inside PowerModels' objective but outside that sum. + for (_, gen) in net["gen"] + haskey(gen, "cost") || continue + Int(get(gen, "model", 2)) == 2 || + error("network_with_carriers: only polynomial (model 2) generator costs are supported") + end + + storage = Dict{String,Any}() + for (_, bus) in net["bus"] + i = Int(bus["index"]) + storage[string(i)] = Dict{String,Any}( + "index" => i, + "storage_bus" => i, + "status" => 1, + # Neutral, valid, and unused: no constraint built here reads them. + "energy" => 0.0, "energy_rating" => 0.0, + "charge_rating" => 0.0, "discharge_rating" => 0.0, + "charge_efficiency" => 1.0, "discharge_efficiency" => 1.0, + "thermal_rating" => 0.0, "qmin" => 0.0, "qmax" => 0.0, + "r" => 0.0, "x" => 0.0, "p_loss" => 0.0, "q_loss" => 0.0, + "ps" => 0.0, "qs" => 0.0, + ) + end + net["storage"] = storage + return net +end + +# ───────────────────────────────────────────────────────────────────────────── +# Problem specification +# ───────────────────────────────────────────────────────────────────────────── + +""" + BatteryStateMode + +How the battery energy state is carried by a stage model. + +- `:sddp` the outgoing energy is an `SDDP.State` variable supplied by the + caller; the stage model has no target and no target multiplier. + This is the TARGETLESS formulation stock SDDP trains on. +- `:strict` the incoming energy is data, and the outgoing energy is pinned by + the HARD equality ``e_{b} = \\hat e_b`` whose multiplier is the + actor signal. There is no target slack and no target penalty. +- `:free` the outgoing energy is a free decision inside its own bounds and + there is no target at all. The incoming energy is data when + `state_in` is supplied, and a free variable — to be linked + externally, as a multiperiod deterministic equivalent does — when it + is not. This is the DIAGNOSTIC mode: a myopic one-stage solve, or one + stage of a perfect-foresight solve. +- `:none` the case's batteries are not installed at all. Used to show that + this problem specification reduces to ordinary PowerModels OPF. + +`:free` is not a third scientific formulation. It carries no target and +therefore no target multiplier, so no policy can be trained on it; it exists so +that the physics of a stage, and the value of the energy a stage inherits, can be +probed with the SAME builders the study's two formulations use, instead of with a +second model that would have to be validated all over again. +""" +const BATTERY_STATE_MODES = (:sddp, :strict, :free, :none) + +""" + BatterySpecification + +Everything the battery layer needs in order to build one stage model. + +# Fields +- `case::BatteryCase`: the frozen case. +- `stage::Int`: stage index ``t``, used only to select the stage's entry of the + frozen demand support. +- `atom::Int`: index of the realized demand atom at this stage. In an SDDP node + it is a placeholder overwritten by `SDDP.parameterize`. +- `mode::Symbol`: one of [`BATTERY_STATE_MODES`](@ref). +- `state_in`: `nothing`, or a `Dict{Int,Float64}` of incoming energies + (`:strict`, and optionally `:free`), or a `Dict{Int,Any}` of JuMP + incoming-state references (`:sddp`). +- `state_out`: `nothing`, or a `Dict{Int,Any}` of JuMP outgoing-state + references (`:sddp`). +- `target`: `nothing`, or a `Dict{Int,Float64}` of outgoing-energy targets + (`:strict`). + +# Notes +One specification builds either formulation of the network: the model +constructor passed to `PowerModels.instantiate_model` decides whether the +network equations are `ACPPowerModel`'s or `SOCWRConicPowerModel`'s, and this +struct is unchanged by that choice. +""" +struct BatterySpecification + case::BatteryCase + stage::Int + atom::Int + mode::Symbol + state_in::Any + state_out::Any + target::Any +end + +function BatterySpecification(case::BatteryCase; + stage::Integer = 1, + atom::Integer = 1, + mode::Symbol = :strict, + state_in = nothing, + state_out = nothing, + target = nothing) + mode in BATTERY_STATE_MODES || + throw(ArgumentError("mode must be one of $BATTERY_STATE_MODES, got :$mode")) + if mode === :strict + state_in === nothing && throw(ArgumentError(":strict requires incoming energies")) + target === nothing && throw(ArgumentError(":strict requires outgoing targets")) + elseif mode === :sddp + (state_in === nothing || state_out === nothing) && + throw(ArgumentError(":sddp requires the SDDP state references")) + elseif mode === :free + # A target in a targetless mode would be silently ignored, which is the + # one outcome worse than an error: the caller would believe a target was + # imposed and read a value that was never constrained. + target === nothing || throw(ArgumentError(":free is targetless; pass mode = :strict to impose a target")) + end + return BatterySpecification(case, Int(stage), Int(atom), mode, state_in, state_out, target) +end + +""" + build_battery_opf(pm::PowerModels.AbstractPowerModel, spec::BatterySpecification) + +The shared PowerModels problem specification for the battery-storage study. + +# Arguments +- `pm`: a model instantiated by `PowerModels.instantiate_model`; its concrete + type — `ACPPowerModel` or `SOCWRConicPowerModel` — selects the network + formulation and is not inspected here. +- `spec::BatterySpecification`: the battery layer's data for this stage. + +# Notes +The body is `PowerModels.build_opf` with the storage block replaced. Everything +electrical is a call into PowerModels; everything battery-related is a call into +this file. That split is the point of the whole design and is asserted by the +provenance test: `pm` must be an actual PowerModels model type, and no AC +trigonometric or SOC-WR lifted branch equation is written here. + +Build ORDER matters and is not cosmetic. The nodal balance is closed over the +`ps`/`qs` entries that exist when it is written, so the battery layer's +variables and its injection expressions are installed BEFORE +`constraint_power_balance` runs. Writing them afterwards would silently produce +a network with no battery in it and no error anywhere. +""" +function build_battery_opf(pm::PowerModels.AbstractPowerModel, spec::BatterySpecification) + # ── 1. Stock PowerModels variables ─────────────────────────────────────── + PowerModels.variable_bus_voltage(pm) + PowerModels.variable_gen_power(pm) + PowerModels.variable_branch_power(pm) + PowerModels.variable_dcline_power(pm) + + # ── 2. Battery layer variables and nodal injection carriers ────────────── + _battery_variables!(pm, spec) + + # ── 3. Stock generator/dcline cost, then the battery layer's own costs ─── + PowerModels.objective_min_fuel_and_flow_cost(pm) + _battery_objective!(pm, spec) + + # ── 4. Stock PowerModels constraints ───────────────────────────────────── + PowerModels.constraint_model_voltage(pm) + + for i in PowerModels.ids(pm, :ref_buses) + PowerModels.constraint_theta_ref(pm, i) + end + + for i in PowerModels.ids(pm, :bus) + PowerModels.constraint_power_balance(pm, i) + end + + for i in PowerModels.ids(pm, :branch) + PowerModels.constraint_ohms_yt_from(pm, i) + PowerModels.constraint_ohms_yt_to(pm, i) + PowerModels.constraint_voltage_angle_difference(pm, i) + PowerModels.constraint_thermal_limit_from(pm, i) + PowerModels.constraint_thermal_limit_to(pm, i) + end + + for i in PowerModels.ids(pm, :dcline) + PowerModels.constraint_dcline_power_losses(pm, i) + end + + # ── 5. Battery dynamics and the strict target equality ─────────────────── + _battery_constraints!(pm, spec) + return nothing +end + +""" + _battery_variables!(pm, spec) + +Declare the battery layer's variables and bind the nodal injection carriers. + +# Notes +Declared here, in this order: + +1. `dpd[i]`, `dqd[i]` — FIXED variables carrying the realized demand deviation + at bus `i`. Fixed rather than baked in as constants because the realized + demand is the stage's noise: `SDDP.parameterize` and the strict evaluator + both move them with `JuMP.fix`, which is the only way a formulation whose + balance is written once can see a new demand. +2. `d[i] ≥ 0`, `s[i] ≥ 0` — the two-sided physical active recourse. Neither has + an upper bound of any kind. Capping `d` by the realized demand — natural if + `d` were only curtailed load — would destroy relatively complete recourse for + strict charging targets, so it is deliberately absent. +3. `p_ch[b] ∈ [0, \\overline p^{ch}_b]`, `p_dis[b] ∈ [0, \\overline p^{dis}_b]`, + and the energy state, whose form depends on `spec.mode`. +4. `ps[i]`, `qs[i]` — EXPRESSIONS, registered into `PowerModels.var` so the + stock balance picks them up. +""" +function _battery_variables!(pm::PowerModels.AbstractPowerModel, spec::BatterySpecification) + model = pm.model + case = spec.case + Δt = stage_hours(case) + buses = sort!(collect(PowerModels.ids(pm, :bus))) + + # ── Demand parameterization ────────────────────────────────────────────── + # `pd_nom` and `qd_nom` are already inside the stock balance (PowerModels + # reads them from `ref`), so the deviation carries the realized minus the + # nominal demand. With every multiplier equal to 1 every deviation is 0 and + # the model is exactly ordinary PowerModels OPF on the untouched case. + # + # The realized demand is computed per LOAD from the frozen support and then + # aggregated to the bus, so a per-load or regional multiplier is carried + # exactly; a bus-level factor would already have averaged it away. + pd_nom, qd_nom = nominal_bus_demand(case) + pd_real, qd_real = realized_bus_demand(case, spec.stage, spec.atom) + dpd = JuMP.@variable(model, [i in buses], base_name = "dpd") + dqd = JuMP.@variable(model, [i in buses], base_name = "dqd") + for i in buses + JuMP.fix(dpd[i], pd_real[i] - pd_nom[i]; force = true) + JuMP.fix(dqd[i], qd_real[i] - qd_nom[i]; force = true) + end + + # ── Two-sided uncapped physical active recourse ────────────────────────── + d = JuMP.@variable(model, [i in buses], lower_bound = 0.0, base_name = "d") + s = JuMP.@variable(model, [i in buses], lower_bound = 0.0, base_name = "s") + + # ── Battery controls and state ─────────────────────────────────────────── + batteries = spec.mode === :none ? BatterySpec[] : case.batteries + ids = [b.index for b in batteries] + byid = Dict(b.index => b for b in batteries) + p_ch = JuMP.@variable(model, [k in ids], lower_bound = 0.0, + upper_bound = byid[k].charge_max, base_name = "p_ch") + p_dis = JuMP.@variable(model, [k in ids], lower_bound = 0.0, + upper_bound = byid[k].discharge_max, base_name = "p_dis") + + e_in = Dict{Int,Any}() + e_out = Dict{Int,Any}() + if spec.mode === :sddp + # The caller owns the SDDP.State pair; the battery layer only reads it. + for k in ids + e_in[k] = spec.state_in[k] + e_out[k] = spec.state_out[k] + end + elseif spec.mode === :strict || spec.mode === :free + # Incoming energy is a free variable here and is pinned by an equality in + # `_battery_constraints!` when data was supplied, so that its multiplier + # is available: that multiplier is ∂Q_t/∂e_{t-1}, the second half of the + # actor signal for the PREVIOUS stage's target, and — in `:free` mode — + # the marginal value of the energy a stage inherits. + ein = JuMP.@variable(model, [k in ids], base_name = "e_in") + eout = JuMP.@variable(model, [k in ids], + lower_bound = byid[k].energy_min, + upper_bound = byid[k].energy_max, base_name = "e_out") + for k in ids + e_in[k] = ein[k] + e_out[k] = eout[k] + end + end + + # ── Nodal injection carriers, as expressions ───────────────────────────── + # p^bat_i aggregates every battery at bus i; unity power factor means the + # reactive carrier holds only the demand deviation. + pbat = Dict{Int,Any}(i => JuMP.AffExpr(0.0) for i in buses) + for b in batteries + JuMP.add_to_expression!(pbat[b.bus], 1.0, p_dis[b.index]) + JuMP.add_to_expression!(pbat[b.bus], -1.0, p_ch[b.index]) + end + ps = Dict{Int,Any}() + qs = Dict{Int,Any}() + for i in buses + ps[i] = dpd[i] - pbat[i] - d[i] + s[i] + qs[i] = JuMP.AffExpr(0.0) + dqd[i] + end + PowerModels.var(pm)[:ps] = ps + PowerModels.var(pm)[:qs] = qs + + # Keep everything reachable for constraints, objective and extraction. The + # battery layer's own bookkeeping lives in `pm.ext`, never in `ref`, so it + # cannot collide with a PowerModels key. + pm.ext[:battery] = Dict{Symbol,Any}( + :spec => spec, :buses => buses, :ids => ids, :byid => byid, + :dpd => dpd, :dqd => dqd, :d => d, :s => s, + :p_ch => p_ch, :p_dis => p_dis, :e_in => e_in, :e_out => e_out, + :pbat => pbat, :Δt => Δt, + :pd_nom => pd_nom, :qd_nom => qd_nom, + # The REALIZED demand of this stage/atom, kept so extraction reports what + # the model was actually solved at rather than re-deriving it. + :pd_real => pd_real, :qd_real => qd_real, + ) + return nothing +end + +""" + _battery_objective!(pm, spec) + +Add the battery layer's cost terms to the stock PowerModels objective. + +# Notes +The added term is + +```math +\\sum_b c^{deg}_b \\Delta t\\,(p^{ch}_b + p^{dis}_b) ++ C^{def}\\sum_i d_i + C^{sur}\\sum_i s_i, +``` + +every coefficient taken from the frozen case, so the ACP model, the SOC-WR model +and both SDDP passes charge for the same thing at the same price. The recourse +prices are far above any generator's marginal cost: they guarantee the strict +target is attainable, they do not make attaining it economical. + +**Units.** The generator cost already in the objective is the case's own +physical polynomial ([`network_with_carriers`](@ref) does not touch it), and the +prices added here are the case's own, so the assembled objective IS the physical +stage cost. Nothing in it is rescaled and nothing mixes unit systems, which is +why every quantity `extract_stage_solution` reads off the solved model — cost, +price, multiplier alike — needs no conversion. +""" +function _battery_objective!(pm::PowerModels.AbstractPowerModel, spec::BatterySpecification) + bat = pm.ext[:battery] + case = spec.case + Δt = bat[:Δt] + extra = JuMP.AffExpr(0.0) + for k in bat[:ids] + b = bat[:byid][k] + JuMP.add_to_expression!(extra, b.throughput_cost * Δt, bat[:p_ch][k]) + JuMP.add_to_expression!(extra, b.throughput_cost * Δt, bat[:p_dis][k]) + end + for i in bat[:buses] + JuMP.add_to_expression!(extra, case.recourse.deficit, bat[:d][i]) + JuMP.add_to_expression!(extra, case.recourse.surplus, bat[:s][i]) + end + JuMP.set_objective_function(pm.model, JuMP.objective_function(pm.model) + extra) + return nothing +end + +""" + _battery_constraints!(pm, spec) + +Add the battery state transition and, in `:strict` mode, the target equality. + +# Notes +The transition is + +```math +e_{b} - \\alpha_b e_{b}^{in} + - \\eta^{ch}_b \\Delta t\\, p^{ch}_b + + \\frac{\\Delta t}{\\eta^{dis}_b} p^{dis}_b = 0, +``` + +with ``e_b`` the END-of-stage energy. Neither ``d`` nor ``s`` appears in it: +the recourse is a property of the NETWORK balance, not of the battery, and a +recourse term inside the state equation would be target slack wearing a +physical name. + +In `:strict` mode two further equalities are added, and both are recorded so +their duals can be read: + +- `energy_in[b]`: pins the incoming energy to data. Its dual is + ``\\partial Q_t / \\partial e_{b,t-1}``. +- `target[b]`: pins the outgoing energy to the policy's target. Its dual is + ``\\lambda_{b,t} = \\partial Q_t / \\partial \\hat e_{b,t}``. + +The actor signal for target ``\\hat e_{b,t}`` is the SUM of the `target` dual at +stage ``t`` and the `energy_in` dual at stage ``t+1``, because in strict mode +the emitted target IS the next stage's incoming state. Nothing else couples the +stages: with both ends of every battery pinned, the strict trajectory separates +into `T` independent stage problems. That separation is what lets the JuMP +engine replay an Exa trajectory stage by stage. +""" +function _battery_constraints!(pm::PowerModels.AbstractPowerModel, spec::BatterySpecification) + bat = pm.ext[:battery] + model = pm.model + Δt = bat[:Δt] + + transition = Dict{Int,Any}() + for k in bat[:ids] + b = bat[:byid][k] + transition[k] = JuMP.@constraint(model, + bat[:e_out][k] - b.self_discharge * bat[:e_in][k] + - b.charge_efficiency * Δt * bat[:p_ch][k] + + (Δt / b.discharge_efficiency) * bat[:p_dis][k] == 0.0) + end + bat[:transition] = transition + + if spec.mode === :strict || spec.mode === :free + # The incoming-energy equality is written whenever incoming energy is + # DATA. In `:free` mode with `state_in === nothing` the incoming energy + # stays a free variable that the caller links to the previous stage. + if spec.state_in !== nothing + energy_in_con = Dict{Int,Any}() + for k in bat[:ids] + energy_in_con[k] = JuMP.@constraint(model, + bat[:e_in][k] == Float64(spec.state_in[k])) + end + bat[:energy_in_con] = energy_in_con + end + if spec.mode === :strict + target_con = Dict{Int,Any}() + for k in bat[:ids] + target_con[k] = JuMP.@constraint(model, + bat[:e_out][k] == Float64(spec.target[k])) + end + bat[:target_con] = target_con + end + end + return nothing +end + +# ───────────────────────────────────────────────────────────────────────────── +# Stage model construction and solution +# ───────────────────────────────────────────────────────────────────────────── + +""" + apply_stage_availability!(net, stage) -> Int + +Scale the limits of every scheduled generator of `net` by its own availability at +`stage`, IN PLACE, and return how many generators were scaled. + +# Arguments +- `net::AbstractDict`: a parsed network, about to be handed to PowerModels. +- `stage::Integer`: the stage being built, `1`-based. + +# Notes +`pmin`, `pmax`, `qmin` and `qmax` are all scaled by the same multiplier, so an +availability of `0` takes the unit out of service completely — active AND +reactive — rather than leaving a generator that cannot generate but can still +hold up a voltage for free. The multiplier form generalises past that one case: a +resource whose capacity varies through the day is the same statement with +fractions in it. + +The generator is scaled rather than deleted, and `gen_status` is deliberately not +touched. PowerModels drops out-of-service generators from `ref`, so flipping the +status would change the variable set — and therefore the model's shape — from one +stage to the next. Scaling keeps every stage's model structurally identical, with +`pg` pinned at zero where the unit is unavailable, and a polynomial cost +evaluated at zero contributes exactly zero to the objective. + +Fail-closed on a schedule that does not cover the requested stage: a case that +declares a two-stage schedule and is then solved at stage 3 has been mixed up +with a different case, and silently reusing the last entry would hide that. +""" +function apply_stage_availability!(net::AbstractDict, stage::Integer) + stage >= 1 || throw(ArgumentError("stage must be 1-based, got $stage")) + scaled = 0 + for (id, gen) in net["gen"] + haskey(gen, STAGE_AVAILABILITY_KEY) || continue + sched = gen[STAGE_AVAILABILITY_KEY] + (sched isa AbstractVector && !isempty(sched)) || + error("generator $id: \"$STAGE_AVAILABILITY_KEY\" must be a non-empty vector of multipliers") + stage <= length(sched) || + error("generator $id: \"$STAGE_AVAILABILITY_KEY\" covers $(length(sched)) stages but stage $stage was requested") + a = Float64(sched[stage]) + (isfinite(a) && a >= 0) || + error("generator $id: availability $a at stage $stage is not a finite nonnegative multiplier") + for k in ("pmin", "pmax", "qmin", "qmax") + haskey(gen, k) && (gen[k] = Float64(gen[k]) * a) + end + scaled += 1 + end + return scaled +end + +""" + battery_stage_model(case, model_type; optimizer, kwargs...) + -> PowerModels.AbstractPowerModel + +Instantiate one stage model of the battery study. + +# Arguments +- `case::BatteryCase`: frozen case. +- `model_type::Type`: `PowerModels.ACPPowerModel` (the TRUE model) or + `PowerModels.SOCWRConicPowerModel` (the relaxation SDDP's backward pass uses). + +# Keywords +- `optimizer`: JuMP optimizer factory; attached to the model that is created. +- `jump_model`: an existing JuMP model to build into (SDDP passes its + subproblem here). Defaults to a fresh model. +- everything else is forwarded to [`BatterySpecification`](@ref). + +# Returns +- The instantiated `pm`. `pm.model` is the JuMP model; `pm.ext[:battery]` holds + the battery layer's variable references. + +# Notes +`model_type` is passed straight to `PowerModels.instantiate_model`, so the +network formulation actually instantiated is PowerModels' own. Nothing in this +function branches on it. + +Every stage model in the study is built here — the strict evaluator, the +diagnostics, and each SDDP subproblem — so the per-stage generator availability +applied below is applied once, for all of them. A consumer that assembled a stage +from `network_with_carriers` on its own would silently ignore it, which is why +nothing else in this study does that. + +Dual reporting is requested through PowerModels' own `setting`, which makes it +store the nodal balance CONSTRAINT REFERENCES in `sol(pm, :bus, i)` under +`:lam_kcl_r` and `:lam_kcl_i`. That is the only supported way to reach the +balance rows: the balance is written by a single closed PowerModels function +that returns nothing, so a diagnostic that wants nodal prices either asks +PowerModels to keep the reference or rewrites the balance — and rewriting it is +exactly what this file does not do. +""" +function battery_stage_model(case::BatteryCase, model_type::Type; + optimizer = nothing, + jump_model = nothing, + kwargs...) + spec = BatterySpecification(case; kwargs...) + net = network_with_carriers(case) + apply_stage_availability!(net, spec.stage) + model = jump_model === nothing ? + (optimizer === nothing ? JuMP.Model() : JuMP.Model(optimizer)) : jump_model + if jump_model !== nothing && optimizer !== nothing + JuMP.set_optimizer(model, optimizer) + end + return PowerModels.instantiate_model(net, model_type, + pm -> build_battery_opf(pm, spec); + jump_model = model, + setting = Dict("output" => Dict("duals" => true))) +end + +""" + solve_strict_stage(case, model_type; stage, atom, energy_in, target, + optimizer, silent=true) -> NamedTuple + +Build and solve one STRICT stage problem, returning its full physical solution. + +# Arguments / Keywords +- `stage::Integer`, `atom::Integer`: which demand realization to impose. +- `energy_in::AbstractDict{Int,<:Real}`: incoming energy per battery identifier. +- `target::AbstractDict{Int,<:Real}`: outgoing-energy target per battery. +- `optimizer`: JuMP optimizer factory (Ipopt for ACP). +- `silent::Bool`: suppress solver output. + +# Returns +A `NamedTuple` with the solver status, the objective decomposed into its +physical components, every physical variable keyed by NETWORK identifier, the +strict target multipliers, and the incoming-energy multipliers. + +# Notes +The returned `target_dual` is the multiplier of ``e_b = \\hat e_b`` as JuMP +reports it for a minimization problem, i.e. the sensitivity of the stage +objective to the target. `energy_in_dual` is the corresponding sensitivity to +the incoming state. Together they give the full actor signal — see +[`_battery_constraints!`](@ref). + +The solve is accepted only when the solver returns a status in +`(OPTIMAL, LOCALLY_SOLVED)`; anything else is reported as-is and the caller must +reject it. A solver status alone is still not sufficient, which is why the +physical residuals are computed separately from the returned solution. +""" +function solve_strict_stage(case::BatteryCase, model_type::Type; + stage::Integer, + atom::Integer, + energy_in::AbstractDict, + target::AbstractDict, + optimizer, + silent::Bool = true, + active_batteries::Bool = true) + mode = active_batteries ? :strict : :none + pm = battery_stage_model(case, model_type; + optimizer = optimizer, + stage = stage, atom = atom, mode = mode, + state_in = active_batteries ? Dict(Int(k) => Float64(v) for (k, v) in energy_in) : nothing, + target = active_batteries ? Dict(Int(k) => Float64(v) for (k, v) in target) : nothing) + silent && JuMP.set_silent(pm.model) + JuMP.optimize!(pm.model) + return extract_stage_solution(pm) +end + +""" + extract_stage_solution(pm) -> NamedTuple + +Read every physical quantity of a solved stage model, keyed by network id. + +# Notes +Generator reactive power is reported BOTH per generator and aggregated to the +bus. Several generators may share a bus and the nodal balance constrains only +their sum, so per-generator values live in a null space that two engines are +free to split differently; the nodal aggregate is the physically determined +quantity, and comparing only the per-generator values would report a difference +that the model does not determine. + +**Nothing here is converted, because nothing was rescaled.** The model that was +solved carries the case's physical stage cost, so its objective value, its +generation-cost polynomial, its nodal prices and its state multipliers are all +already in the case's objective units and are read off as they stand. A residual +compared against the solver's own KKT residuals, or a cost compared against a +stock `PowerModels.solve_opf`, therefore compares like with like — there is no +second unit system anywhere in this file for one of them to slip into. +""" +function extract_stage_solution(pm::PowerModels.AbstractPowerModel) + model = pm.model + bat = pm.ext[:battery] + spec = bat[:spec] + case = spec.case + Δt = bat[:Δt] + status = JuMP.termination_status(model) + ok = status in (MOI.OPTIMAL, MOI.LOCALLY_SOLVED) + + val(x) = JuMP.value(x) + buses = bat[:buses] + gen_ids = sort!(collect(PowerModels.ids(pm, :gen))) + branch_ids = sort!(collect(PowerModels.ids(pm, :branch))) + + vm = Dict{Int,Float64}() + va = Dict{Int,Float64}() + if haskey(PowerModels.var(pm), :vm) + # Polar forms carry the magnitude directly. + for i in buses + vm[i] = val(PowerModels.var(pm, :vm, i)) + va[i] = val(PowerModels.var(pm, :va, i)) + end + else + # W-space forms (SOC-WR) carry |V|²; the angle is not a variable there. + for i in buses + vm[i] = sqrt(max(val(PowerModels.var(pm, :w, i)), 0.0)) + va[i] = NaN + end + end + + pg = Dict{Int,Float64}(g => val(PowerModels.var(pm, :pg, g)) for g in gen_ids) + qg = Dict{Int,Float64}(g => val(PowerModels.var(pm, :qg, g)) for g in gen_ids) + pg_bus = Dict{Int,Float64}(i => 0.0 for i in buses) + qg_bus = Dict{Int,Float64}(i => 0.0 for i in buses) + for g in gen_ids + b = Int(PowerModels.ref(pm, :gen, g)["gen_bus"]) + pg_bus[b] += pg[g] + qg_bus[b] += qg[g] + end + + p_fr = Dict{Int,Float64}(); q_fr = Dict{Int,Float64}() + p_to = Dict{Int,Float64}(); q_to = Dict{Int,Float64}() + for l in branch_ids + br = PowerModels.ref(pm, :branch, l) + f = (l, Int(br["f_bus"]), Int(br["t_bus"])) + t = (l, Int(br["t_bus"]), Int(br["f_bus"])) + p_fr[l] = val(PowerModels.var(pm, :p, f)); q_fr[l] = val(PowerModels.var(pm, :q, f)) + p_to[l] = val(PowerModels.var(pm, :p, t)); q_to[l] = val(PowerModels.var(pm, :q, t)) + end + + d = Dict{Int,Float64}(i => val(bat[:d][i]) for i in buses) + s = Dict{Int,Float64}(i => val(bat[:s][i]) for i in buses) + pd = Dict{Int,Float64}(i => bat[:pd_real][i] for i in buses) + qd = Dict{Int,Float64}(i => bat[:qd_real][i] for i in buses) + + ids = bat[:ids] + p_ch = Dict{Int,Float64}(k => val(bat[:p_ch][k]) for k in ids) + p_dis = Dict{Int,Float64}(k => val(bat[:p_dis][k]) for k in ids) + p_bat = Dict{Int,Float64}(k => p_dis[k] - p_ch[k] for k in ids) + e_in = Dict{Int,Float64}(k => val(bat[:e_in][k]) for k in ids) + e_out = Dict{Int,Float64}(k => val(bat[:e_out][k]) for k in ids) + + # Multipliers of the physical objective: objective units per pu-hour of + # stored energy, read off with no conversion. + target_dual = Dict{Int,Float64}() + energy_in_dual = Dict{Int,Float64}() + if JuMP.has_duals(model) + if haskey(bat, :target_con) + for k in ids + target_dual[k] = JuMP.dual(bat[:target_con][k]) + end + end + if haskey(bat, :energy_in_con) + for k in ids + energy_in_dual[k] = JuMP.dual(bat[:energy_in_con][k]) + end + end + end + + # ── Nodal prices ───────────────────────────────────────────────────────── + # PowerModels writes the active balance at bus i as + # + # Σ p_arcs − Σ pg + Σ ps + p^d_i + g^s_i |V_i|² = 0, + # + # i.e. `h(x) = −p^d_i`. JuMP's multiplier λ of `h(x) == b` in a minimization + # is ∂obj/∂b, so the price of demand — the quantity anyone means by a nodal + # price — is ∂obj/∂p^d_i = −λ. The sign is derived here once rather than + # guessed, and it is checked in the regression suite against a finite + # difference of the realized demand. + price_active = Dict{Int,Float64}() + price_reactive = Dict{Int,Float64}() + if JuMP.has_duals(model) + for i in buses + bus_sol = PowerModels.sol(pm, :bus, i) + haskey(bus_sol, :lam_kcl_r) && (price_active[i] = -JuMP.dual(bus_sol[:lam_kcl_r])) + haskey(bus_sol, :lam_kcl_i) && (price_reactive[i] = -JuMP.dual(bus_sol[:lam_kcl_i])) + end + end + + # ── Cost decomposition ─────────────────────────────────────────────────── + # `ref` holds the case's own polynomial and the three remaining components + # are built from the case's own prices, so all four are in the same units as + # the objective they must sum to. + cost_generation = 0.0 + for g in gen_ids + gen = PowerModels.ref(pm, :gen, g) + cost_generation += _polynomial_cost(gen, pg[g]) + end + cost_throughput = sum(bat[:byid][k].throughput_cost * Δt * (p_ch[k] + p_dis[k]) + for k in ids; init = 0.0) + cost_deficit = case.recourse.deficit * sum(values(d); init = 0.0) + cost_surplus = case.recourse.surplus * sum(values(s); init = 0.0) + + return ( + status = status, solved = ok, + objective = ok ? JuMP.objective_value(model) : NaN, + cost_generation = cost_generation, + cost_throughput = cost_throughput, + cost_deficit = cost_deficit, + cost_surplus = cost_surplus, + cost_stage = cost_generation + cost_throughput + cost_deficit + cost_surplus, + vm = vm, va = va, pg = pg, qg = qg, pg_bus = pg_bus, qg_bus = qg_bus, + p_fr = p_fr, q_fr = q_fr, p_to = p_to, q_to = q_to, + deficit = d, surplus = s, pd = pd, qd = qd, + p_ch = p_ch, p_dis = p_dis, p_bat = p_bat, + energy_in = e_in, energy_out = e_out, + target_dual = target_dual, energy_in_dual = energy_in_dual, + price_active = price_active, price_reactive = price_reactive, + simultaneous = Dict{Int,Float64}(k => min(p_ch[k], p_dis[k]) for k in ids), + pm = pm, + ) +end + +""" + binding_constraints(pm, sol; tol=1e-6) -> Vector{NamedTuple} + +Every physical limit of a solved stage that is binding or nearly binding. + +# Arguments +- `pm`: the solved model (used for its network reference). +- `sol`: the named tuple returned by [`extract_stage_solution`](@ref). + +# Keywords +- `tol::Real`: absolute slack, in the natural unit of each limit, below which a + limit counts as binding. + +# Returns +A vector of `(kind, index, side, value, limit, slack)` rows, sorted by slack, for + +- generator active and reactive bounds (pu); +- bus voltage magnitude bounds (pu); +- branch apparent-power limits at BOTH ends (pu, compared on ``|S|`` rather than + on ``|S|^2`` so the tolerance means the same thing on every branch); +- branch angle-difference limits (rad), where the formulation has angles. + +# Notes +This answers "what stopped the network from delivering the energy" — the question +that separates a real relaxation-driven storage-value difference from a numerical +one. It reads the reported solution rather than the solver's active set, so it +says the same thing about a solution produced by either engine. +""" +function binding_constraints(pm::PowerModels.AbstractPowerModel, sol; tol::Real = 1e-6) + rows = NamedTuple[] + push_row!(kind, index, side, value, limit) = begin + slack = abs(limit - value) + slack <= tol && push!(rows, (kind = kind, index = index, side = side, + value = float(value), limit = float(limit), + slack = float(slack))) + end + + for (g, val) in sol.pg + gen = PowerModels.ref(pm, :gen, g) + push_row!("pg", g, "min", val, Float64(gen["pmin"])) + push_row!("pg", g, "max", val, Float64(gen["pmax"])) + end + for (g, val) in sol.qg + gen = PowerModels.ref(pm, :gen, g) + push_row!("qg", g, "min", val, Float64(gen["qmin"])) + push_row!("qg", g, "max", val, Float64(gen["qmax"])) + end + for (i, val) in sol.vm + bus = PowerModels.ref(pm, :bus, i) + push_row!("vm", i, "min", val, Float64(bus["vmin"])) + push_row!("vm", i, "max", val, Float64(bus["vmax"])) + end + for l in keys(sol.p_fr) + br = PowerModels.ref(pm, :branch, l) + rate = Float64(get(br, "rate_a", Inf)) + isfinite(rate) || continue + push_row!("thermal", l, "from", hypot(sol.p_fr[l], sol.q_fr[l]), rate) + push_row!("thermal", l, "to", hypot(sol.p_to[l], sol.q_to[l]), rate) + if !isnan(sol.va[Int(br["f_bus"])]) + θ = sol.va[Int(br["f_bus"])] - sol.va[Int(br["t_bus"])] + push_row!("angle", l, "min", θ, Float64(get(br, "angmin", -pi))) + push_row!("angle", l, "max", θ, Float64(get(br, "angmax", pi))) + end + end + sort!(rows; by = r -> r.slack) + return rows +end + +""" + _polynomial_cost(gen, pg) -> Float64 + +Evaluate a PowerModels polynomial cost model at `pg`. + +# Notes +PowerModels stores the polynomial highest-order-first with `ncost` coefficients, +so the value is ``\\sum_{j} c_j\\, pg^{ncost-j}``. Only `model == 2` (polynomial) +is supported; a piecewise-linear cost model would need its own evaluation and +none of the benchmarks used here carries one. + +The result is in the units of the coefficients it was handed. Every model this +file builds carries the case's own coefficients, so calling it on `case.network` +and calling it on a model's `ref` return the same number for the same dispatch. +""" +function _polynomial_cost(gen::AbstractDict, pg::Real) + Int(get(gen, "model", 2)) == 2 || + error("only polynomial (model 2) generator costs are supported") + cost = Float64.(gen["cost"]) + n = Int(gen["ncost"]) + total = 0.0 + for (j, c) in enumerate(cost[(end - n + 1):end]) + total += c * pg^(n - j) + end + return total +end + +""" + record_stage_solution!(rec, sol, case; scenario, stage) + +Write one solved stage into a [`SolutionRecorder`](@ref) in the shared schema. +""" +function record_stage_solution!(rec::SolutionRecorder, sol, case::BatteryCase; + scenario::Integer, stage::Integer) + record_map!(rec, scenario, stage, "vm", sol.vm) + record_map!(rec, scenario, stage, "va", sol.va) + record_map!(rec, scenario, stage, "pg", sol.pg) + record_map!(rec, scenario, stage, "qg", sol.qg) + record_map!(rec, scenario, stage, "pg_bus", sol.pg_bus) + record_map!(rec, scenario, stage, "qg_bus", sol.qg_bus) + record_map!(rec, scenario, stage, "p_fr", sol.p_fr) + record_map!(rec, scenario, stage, "q_fr", sol.q_fr) + record_map!(rec, scenario, stage, "p_to", sol.p_to) + record_map!(rec, scenario, stage, "q_to", sol.q_to) + record_map!(rec, scenario, stage, "deficit", sol.deficit) + record_map!(rec, scenario, stage, "surplus", sol.surplus) + record_map!(rec, scenario, stage, "pd", sol.pd) + record_map!(rec, scenario, stage, "qd", sol.qd) + record_map!(rec, scenario, stage, "p_ch", sol.p_ch) + record_map!(rec, scenario, stage, "p_dis", sol.p_dis) + record_map!(rec, scenario, stage, "p_bat", sol.p_bat) + record_map!(rec, scenario, stage, "energy_in", sol.energy_in) + record_map!(rec, scenario, stage, "energy_out", sol.energy_out) + isempty(sol.target_dual) || record_map!(rec, scenario, stage, "target_dual", sol.target_dual) + isempty(sol.price_active) || record_map!(rec, scenario, stage, "price_active", sol.price_active) + isempty(sol.price_reactive) || record_map!(rec, scenario, stage, "price_reactive", sol.price_reactive) + record!(rec, scenario, stage, "cost_generation", 0, sol.cost_generation) + record!(rec, scenario, stage, "cost_throughput", 0, sol.cost_throughput) + record!(rec, scenario, stage, "cost_deficit", 0, sol.cost_deficit) + record!(rec, scenario, stage, "cost_surplus", 0, sol.cost_surplus) + record!(rec, scenario, stage, "cost_stage", 0, sol.cost_stage) + record!(rec, scenario, stage, "objective", 0, sol.objective) + record!(rec, scenario, stage, "solved", 0, sol.solved ? 1.0 : 0.0) + return rec +end + +# ───────────────────────────────────────────────────────────────────────────── +# Provenance +# ───────────────────────────────────────────────────────────────────────────── + +""" + assert_powermodels_provenance(pm, expected::Type) -> Nothing + +Assert, from the LIVE object, that the network formulation actually built is the +intended PowerModels one. + +# Notes +This is the runtime half of the provenance gate. Numerical agreement with a +handwritten model is explicitly NOT an acceptable substitute: the claim the +study makes is that SDDP's backward pass is an actual +`PowerModels.SOCWRConicPowerModel` and its forward pass an actual +`PowerModels.ACPPowerModel`, and only the type of the instantiated object can +establish that. + +Beyond the type, the assertion checks that the model carries the variables the +intended formulation is defined by — `vm`/`va` for the polar AC form, the lifted +`w`/`wr`/`wi` for the SOC-WR form — so that a type that had been made to alias +something else would still be caught. +""" +function assert_powermodels_provenance(pm::PowerModels.AbstractPowerModel, expected::Type) + typeof(pm) === expected || + error("expected an actual $expected, got $(typeof(pm))") + pm isa PowerModels.AbstractPowerModel || + error("$(typeof(pm)) is not a PowerModels.AbstractPowerModel") + vars = keys(PowerModels.var(pm)) + if expected === PowerModels.ACPPowerModel + (:vm in vars && :va in vars) || + error("ACPPowerModel is missing its polar voltage variables") + elseif expected === PowerModels.SOCWRConicPowerModel + (:w in vars && :wr in vars && :wi in vars) || + error("SOCWRConicPowerModel is missing its lifted voltage variables") + end + return nothing +end diff --git a/examples/BatteryStorageOPF/battery_sddp.jl b/examples/BatteryStorageOPF/battery_sddp.jl new file mode 100644 index 0000000..331548e --- /dev/null +++ b/examples/BatteryStorageOPF/battery_sddp.jl @@ -0,0 +1,542 @@ +# battery_sddp.jl +# +# The SDDP baseline: stock SDDP.jl over the shared PowerModels battery problem +# specification, with a SOC-WR backward pass and a true-ACP forward pass. +# +# WHAT IS STOCK AND WHY IT MATTERS. +# SDDP.jl owns the policy graph, the state variables, the sampling scheme, cut +# generation, training and simulation. This file constructs two policy graphs +# from the SAME `build_battery_opf` specification — one instantiated as an +# actual `PowerModels.SOCWRConicPowerModel`, one as an actual +# `PowerModels.ACPPowerModel` — and hands them to SDDP's own +# `AlternativeForwardPass`/`AlternativePostIterationCallback` pair, which is +# SDDP.jl's documented mechanism for training against a convex relaxation while +# operating a nonconvex model. No `duality_handler` is overridden, no cut is +# filtered, retried or reweighted: which duals become cuts is SDDP's decision. +# +# The bound produced here is a bound on the SOC-WR relaxation over the horizon +# it was trained on. It is NOT comparable to a forward objective over a shorter +# horizon, and nothing in this file invites that comparison. +# +# Usage +# julia --project=. battery_sddp.jl # short construction smoke +# DR_BAT_SDDP_STAGES=3 DR_BAT_SDDP_ITERATIONS=10 julia --project=. battery_sddp.jl + +using SDDP +using JuMP +using PowerModels +using Ipopt +using Clarabel +using Printf +using Random +using Statistics + +@isdefined(BatterySpecification) || include(joinpath(@__DIR__, "battery_powermodels.jl")) +@isdefined(perfect_foresight_panel) || include(joinpath(@__DIR__, "battery_diagnostics.jl")) + +"The relaxation SDDP's backward pass values stored energy with." +const BACKWARD_FORMULATION = PowerModels.SOCWRConicPowerModel + +"The true model SDDP's forward pass operates." +const FORWARD_FORMULATION = PowerModels.ACPPowerModel + +""" + sddp_path_cost(case, path, T) -> Float64 + +The cost of one simulated path: its `T` stage objectives summed. + +# Notes +Both policy graphs are built by the shared specification, so every stage +objective SDDP sees — and therefore every cut, every `stage_objective` a +simulation records and the bound `SDDP.calculate_bound` returns — is the physical +stage cost of the case, in the objective units of the underlying PGLib network. +Stage costs, cuts and bounds live in that one unit system on both graphs, so a +path cost is a plain sum and a number leaving this file needs no conversion. + +`case` is taken for the signature every consumer already calls and to keep the +path bound to the case it was simulated on; the sum itself does not need it. +""" +sddp_path_cost(case::BatteryCase, path, T::Integer) = + sum(path[t][:stage_objective] for t in 1:Int(T)) + +""" + battery_policy_graph(case, model_type; num_stages, optimizer) -> SDDP.PolicyGraph + +Build a `num_stages`-stage linear policy graph whose stage problem is the shared +battery problem specification instantiated as `model_type`. + +# Arguments +- `case::BatteryCase`: frozen case. +- `model_type::Type`: `SOCWRConicPowerModel` or `ACPPowerModel`. + +# Keywords +- `num_stages::Integer`: horizon. +- `optimizer`: solver factory matching `model_type`. + +# Returns +- The `SDDP.PolicyGraph`. Each node's JuMP model additionally carries + `sp.ext[:battery]` (the battery layer's variable references) and + `sp.ext[:pm]` (the live PowerModels object, so provenance can be asserted + from the graph itself). + +# Notes +Battery energy is the genuine SDDP state: `@variable(sp, ..., SDDP.State)` +creates the incoming/outgoing pair, SDDP equates one stage's outgoing value to +the next stage's incoming value, and the battery transition — written by the +shared specification, not here — is what ties that state to the dispatch. + +Demand is the node's NOISE. `SDDP.parameterize` moves the fixed demand-deviation +variables the specification installed; the atoms and their probabilities come +from the frozen case, so the forward graph, the backward graph and the Exa +engine all face the same stochastic program. + +Information timing is the plan's: the incoming energy and the realized demand +are both known when the stage decision is taken, and the outgoing energy is the +decision that becomes the next stage's state. +""" +function battery_policy_graph(case::BatteryCase, model_type::Type; + num_stages::Integer, + optimizer) + ids = [b.index for b in case.batteries] + byid = Dict(b.index => b for b in case.batteries) + num_stages <= horizon(case.demand) || + throw(ArgumentError("policy graph asks for $num_stages stages but the frozen support covers $(horizon(case.demand))")) + + graph = SDDP.LinearPolicyGraph( + stages = num_stages, + sense = :Min, + # Every stage cost is a sum of nonnegative terms (generation cost with + # nonnegative coefficients, throughput cost, priced recourse), so 0 is a + # valid and honest lower bound on the value function. + lower_bound = 0.0, + optimizer = optimizer, + ) do sp, t + JuMP.@variable(sp, e[k in ids], SDDP.State, + initial_value = byid[k].energy_initial, + lower_bound = byid[k].energy_min, + upper_bound = byid[k].energy_max) + state_in = Dict{Int,Any}(k => e[k].in for k in ids) + state_out = Dict{Int,Any}(k => e[k].out for k in ids) + + pm = battery_stage_model(case, model_type; + jump_model = sp, + stage = t, atom = 1, mode = :sddp, + state_in = state_in, state_out = state_out) + sp.ext[:pm] = pm + sp.ext[:battery] = pm.ext[:battery] + + # The stage cost is exactly the objective the shared specification + # assembled: stock PowerModels generation cost plus the battery layer's + # throughput and recourse prices. + SDDP.@stageobjective(sp, JuMP.objective_function(sp)) + + bat = pm.ext[:battery] + pd_nom, qd_nom = bat[:pd_nom], bat[:qd_nom] + buses = bat[:buses] + # The stage's atoms come from the FROZEN support, per stage: the support + # is stage-dependent in general, so a graph-wide atom list would be + # wrong on any case whose late stages carry a different support. The + # realized per-bus demand of each atom is materialized ONCE here, so a + # parameterize call is a few `fix`es rather than a re-aggregation of the + # case's loads on every node solve of every iteration. + atoms = collect(1:num_atoms(case.demand, t)) + probs = copy(atom_probabilities(case.demand, t)) + realized = [realized_bus_demand(case, t, k) for k in atoms] + SDDP.parameterize(sp, atoms, probs) do ω + pd, qd = realized[ω] + for i in buses + JuMP.fix(bat[:dpd][i], pd[i] - pd_nom[i]; force = true) + JuMP.fix(bat[:dqd][i], qd[i] - qd_nom[i]; force = true) + end + return + end + end + return graph +end + +""" + assert_graph_provenance(graph, expected::Type) + +Assert that every node of `graph` was instantiated as an actual `expected` +PowerModels model. + +# Notes +Checking the type on one node would not do: a policy graph builds one model per +stage and a formulation switch that only fired on some stages would be a +different stochastic program with the same name. +""" +function assert_graph_provenance(graph::SDDP.PolicyGraph, expected::Type) + for (key, node) in graph.nodes + haskey(node.subproblem.ext, :pm) || + error("node $key carries no PowerModels object") + assert_powermodels_provenance(node.subproblem.ext[:pm], expected) + end + return nothing +end + +""" + train_battery_sddp(case; num_stages, iteration_limit, time_limit, seed, + print_level, backward_optimizer, forward_optimizer, + protocol, evaluate_columns, evaluate_every, cut_path) + -> NamedTuple + +Train the SDDP policy: SOC-WR backward, true-ACP forward. + +# Keywords +- `num_stages::Integer`: horizon. +- `iteration_limit`, `time_limit`: the training budget. Either may be `nothing`. +- `seed::Integer`: seed of the forward sampling scheme. +- `backward_optimizer`, `forward_optimizer`: solver factories. These are + SOLVER settings; nothing here may change the mathematical model. +- `protocol`, `evaluate_columns`, `evaluate_every`: when all three are given, + the TRUE-ACP forward cost is evaluated on those fixed protocol columns every + `evaluate_every` iterations and recorded in `history`. +- `cut_path`: when given, the cuts are written there after training. + +# Returns +A `NamedTuple` with the two graphs, the termination status, the SOC-WR bound, the +elapsed wall time, and `history` — one row per evaluation with the iteration, the +bound at that point, the true-ACP mean cost on the fixed columns, the worst +recourse and the elapsed time. + +# Notes +`SDDP.AlternativeForwardPass(forward)` performs each forward pass on the ACP +graph and copies the resulting states back into the convex graph, and +`AlternativePostIterationCallback(forward)` copies the newly created cuts into +the ACP graph. Both are SDDP.jl's own; the pair is what makes "value with a +relaxation, operate the true model" a stock configuration rather than an +intervention. The periodic evaluation is composed AROUND that callback, never +in place of it. + +**Three signals, never compared in level.** The SOC-WR bound is a bound on the +RELAXATION over `num_stages` stages. The true-ACP forward cost on the fixed +columns is a physical cost of the current policy on a small, fixed sample. A +final protocol cost is a third thing again. Quoting the bound beside a forward +cost accumulated over a different number of stages compares two different +quantities, and nothing here invites that. + +The evaluation is a MEASUREMENT, not a stopping rule: training runs its declared +budget. Choosing when to stop by watching the evaluation would select a policy on +the same numbers used to report it. +""" +function train_battery_sddp(case::BatteryCase; + num_stages::Integer = 3, + iteration_limit = 10, + time_limit = nothing, + seed::Integer = 20260804, + print_level::Integer = 0, + backward_optimizer = socwr_optimizer(), + forward_optimizer = acp_optimizer(), + protocol = nothing, + evaluate_columns = nothing, + evaluate_every = nothing, + cut_path = nothing) + Random.seed!(seed) + backward = battery_policy_graph(case, BACKWARD_FORMULATION; + num_stages = num_stages, optimizer = backward_optimizer) + forward = battery_policy_graph(case, FORWARD_FORMULATION; + num_stages = num_stages, optimizer = forward_optimizer) + assert_graph_provenance(backward, BACKWARD_FORMULATION) + assert_graph_provenance(forward, FORWARD_FORMULATION) + + ids = [b.index for b in case.batteries] + history = NamedTuple[] + stock = SDDP.AlternativePostIterationCallback(forward) + iteration = Ref(0) + t0 = time() + + # The stock callback FIRST — the periodic evaluation is composed around it, + # so the cuts the ACP graph carries are exactly the ones stock SDDP made. + callback = function (result) + stock(result) + iteration[] += 1 + (protocol === nothing || evaluate_every === nothing) && return + iteration[] % Int(evaluate_every) == 0 || return + sims = simulate_battery_sddp_on((forward = forward, num_stages = Int(num_stages)), + protocol; ids = ids, columns = evaluate_columns) + costs = [sddp_path_cost(case, s, num_stages) for s in sims] + rec = maximum(max(sims[i][t][:deficit], sims[i][t][:surplus]) + for i in eachindex(sims), t in 1:Int(num_stages)) + push!(history, (iteration = iteration[], + bound = SDDP.calculate_bound(backward), + acp_mean = mean(costs), acp_min = minimum(costs), + acp_max = maximum(costs), worst_recourse = rec, + elapsed = time() - t0)) + return + end + + kwargs = Dict{Symbol,Any}(:print_level => print_level, + :forward_pass => SDDP.AlternativeForwardPass(forward), + :post_iteration_callback => callback) + iteration_limit === nothing || (kwargs[:iteration_limit] = Int(iteration_limit)) + time_limit === nothing || (kwargs[:time_limit] = Float64(time_limit)) + SDDP.train(backward; kwargs...) + elapsed = time() - t0 + + cut_path === nothing || SDDP.write_cuts_to_file(backward, cut_path) + + return (backward = backward, forward = forward, + status = SDDP.termination_status(backward), + # In the objective units of the PGLib case, like every stage cost the + # backward graph was built from. Every consumer of `trained.bound` — + # `cost_report`, the smoke and any downstream analysis — reads it as + # it stands, directly comparable with `sddp_path_cost`. + bound = SDDP.calculate_bound(backward), + case = case, + elapsed = elapsed, num_stages = Int(num_stages), + iterations = iteration[], history = history, + cut_path = cut_path) +end + +""" + simulate_battery_sddp(trained, num_replications; ids, seed) -> Vector + +Simulate the trained policy on the TRUE-ACP graph. + +# Arguments +- `ids`: battery identifiers, in the order the recorded energy vectors use. + +# Notes +Simulation records, per stage: the stage objective, the outgoing battery energy, +the charge/discharge split and the two recourse totals. The recourse totals are +recorded on every path because a policy that leans on them is rejected, and a +rejection rule that is only evaluated at the end of a campaign is not a rule. + +Everything is recorded through `custom_recorders`, which read the live +subproblem after it is solved, so what is stored is the value the solver +actually returned rather than a re-derivation of it. +""" +function simulate_battery_sddp(trained, num_replications::Integer; + ids::AbstractVector{Int}, + seed::Integer = 20260804) + Random.seed!(seed) + return SDDP.simulate(trained.forward, num_replications; + custom_recorders = Dict{Symbol,Function}( + :energy_out => (sp::JuMP.Model) -> [JuMP.value(sp[:e][k].out) for k in ids], + :energy_in => (sp::JuMP.Model) -> [JuMP.value(sp[:e][k].in) for k in ids], + :deficit => (sp::JuMP.Model) -> sum(JuMP.value.(sp.ext[:battery][:d])), + :surplus => (sp::JuMP.Model) -> sum(JuMP.value.(sp.ext[:battery][:s])), + :p_ch => (sp::JuMP.Model) -> sum(JuMP.value(sp.ext[:battery][:p_ch][k]) for k in ids; init = 0.0), + :p_dis => (sp::JuMP.Model) -> sum(JuMP.value(sp.ext[:battery][:p_dis][k]) for k in ids; init = 0.0), + )) +end + +""" + simulate_battery_sddp_on(trained, protocol; ids, columns=nothing) -> Vector + +Simulate the trained policy on the true-ACP graph over EXACTLY the demand paths +of a protocol, in the protocol's own order. + +# Arguments +- `protocol::AbstractMatrix{<:Integer}`: the `(stages × scenarios)` atom-index + matrix. + +# Keywords +- `columns`: the global scenario identifiers to simulate; every column by + default. + +# Notes +This is what makes an SDDP cost PAIRED with a perfect-foresight cost or with a +TS-DDR cost: all three are then accumulated over the same demand realizations, +and the difference between two policies is measured scenario by scenario rather +than between two independent samples of a distribution whose spread dwarfs it. + +`SDDP.Historical` is SDDP.jl's own mechanism for replaying a fixed set of +realizations; nothing about the policy or the graph changes, only which noises +the forward pass sees. +""" +function simulate_battery_sddp_on(trained, protocol::AbstractMatrix{<:Integer}; + ids::AbstractVector{Int}, + columns = nothing) + T = trained.num_stages + T <= size(protocol, 1) || + throw(ArgumentError("protocol has $(size(protocol, 1)) stages but the policy has $T")) + cols = columns === nothing ? collect(1:size(protocol, 2)) : collect(Int.(columns)) + scenarios = [[(t, Int(protocol[t, c])) for t in 1:T] for c in cols] + return SDDP.simulate(trained.forward, length(scenarios); + sampling_scheme = SDDP.Historical(scenarios), + custom_recorders = Dict{Symbol,Function}( + :energy_out => (sp::JuMP.Model) -> [JuMP.value(sp[:e][k].out) for k in ids], + :energy_in => (sp::JuMP.Model) -> [JuMP.value(sp[:e][k].in) for k in ids], + :deficit => (sp::JuMP.Model) -> max(0.0, sum(JuMP.value.(sp.ext[:battery][:d]))), + :surplus => (sp::JuMP.Model) -> max(0.0, sum(JuMP.value.(sp.ext[:battery][:s]))), + :p_ch => (sp::JuMP.Model) -> sum(JuMP.value(sp.ext[:battery][:p_ch][k]) for k in ids; init = 0.0), + :p_dis => (sp::JuMP.Model) -> sum(JuMP.value(sp.ext[:battery][:p_dis][k]) for k in ids; init = 0.0), + )) +end + +""" + sddp_smoke(; case_dir, num_stages, iteration_limit, replications) -> NamedTuple + +The Phase-1 SDDP construction smoke. + +# Notes +This is a CONSTRUCTION test, not a performance experiment. It runs the smallest +horizon and iteration count that still exercises every mechanism the study +depends on — actual SOC-WR backward nodes, actual ACP forward nodes, battery +energy as a genuine state that propagates, demand realized from the frozen +atoms, cuts created by stock SDDP, and clean ACP forward solves — and it reports +nothing about policy quality. +""" +function sddp_smoke(; case_dir::AbstractString = joinpath(@__DIR__, "case", "pglib_opf_case14_ieee"), + num_stages::Integer = parse(Int, get(ENV, "DR_BAT_SDDP_STAGES", "3")), + iteration_limit::Integer = parse(Int, get(ENV, "DR_BAT_SDDP_ITERATIONS", "10")), + replications::Integer = parse(Int, get(ENV, "DR_BAT_SDDP_SIMS", "6"))) + case = read_battery_case(case_dir) + ids = [b.index for b in case.batteries] + trained = train_battery_sddp(case; num_stages = num_stages, iteration_limit = iteration_limit) + sims = simulate_battery_sddp(trained, replications; ids = ids) + @printf("SDDP smoke: %d stages, %d iterations, status %s\n", + num_stages, iteration_limit, trained.status) + @printf(" backward formulation %s forward formulation %s\n", + BACKWARD_FORMULATION, FORWARD_FORMULATION) + # `trained.bound` and `sddp_path_cost` are both in the objective units of the + # PGLib case, so the bound below and the forward costs printed after it are + # directly comparable. + @printf(" SOC-WR bound over %d stages: %.6f (elapsed %.1f s)\n", + trained.num_stages, trained.bound, trained.elapsed) + ncuts = sum(length(node.bellman_function.global_theta.cuts) + for (_, node) in trained.backward.nodes) + @printf(" stock cuts created: %d\n", ncuts) + costs = [sddp_path_cost(case, s, num_stages) for s in sims] + @printf(" ACP forward cost over %d paths: mean %.6f min %.6f max %.6f\n", + length(costs), mean(costs), minimum(costs), maximum(costs)) + worst_d = maximum(sims[i][t][:deficit] for i in eachindex(sims), t in 1:num_stages) + worst_s = maximum(sims[i][t][:surplus] for i in eachindex(sims), t in 1:num_stages) + @printf(" worst recourse on any simulated stage: deficit %.3e surplus %.3e\n", worst_d, worst_s) + for (j, k) in enumerate(ids) + # `energy_out` is recorded in `ids` order, so column j is battery k. + traj = [sims[1][t][:energy_out][j] for t in 1:num_stages] + @printf(" battery %d energy path (path 1): %.5f -> %s\n", k, + sims[1][1][:energy_in][j], + join((@sprintf("%.5f", x) for x in traj), " -> ")) + end + return (trained = trained, sims = sims, cuts = ncuts, + worst_deficit = worst_d, worst_surplus = worst_s) +end + +if abspath(PROGRAM_FILE) == @__FILE__ + sddp_smoke() +end + + +# ───────────────────────────────────────────────────────────────────────────── +# The standard cost report +# ───────────────────────────────────────────────────────────────────────────── + +""" + cost_report(case, trained, protocol; columns, alpha=0.95, io=stdout) -> NamedTuple + +The four quantities this study reports about a case, always together and always +with the same meaning. + +# Returns / prints + +| | | +|---|---| +| `sddp_mean`, `sddp_cvar`, `sddp_max` | the SDDP policy's TRUE-ACP cost over `columns`: mean, the `alpha`-CVaR (mean of the worst `1-alpha` tail) and the worst path | +| `bound` | the SOC-WR relaxation's bound over the SAME horizon | +| `pf_mean`, `pf_cvar`, `pf_max` | the true-ACP perfect-foresight cost over the SAME paths | +| `gap_bound` | `(sddp_mean − bound) / sddp_mean` | +| `gap_pf` | `(sddp_mean − pf_mean) / pf_mean` | + +# Notes +The two gaps answer different questions and are never added or conflated: + +- `gap_bound` is the SDDP policy's true cost against a LOWER BOUND on the + RELAXED problem. It is dominated by how loose the SOC-WR relaxation is on this + network, and it is not a statement about the policy. +- `gap_pf` is the policy against CLAIRVOYANCE on the same demand paths. It is + the policy headroom, and it contains the value of perfect information, which no + nonanticipative method can recover. + +Every quantity in the table is in the objective units of the PGLib case, the one +unit system this study has. The policy costs come through +[`sddp_path_cost`](@ref), the bound off the backward graph built from those same +stage costs, and the perfect-foresight and forecast costs are sums of +`cost_stage`. No quantity here is rescaled at any point, so the rows are +comparable as they stand. + +Both are reported on the SAME paths and the SAME horizon as the bound, because a +bound never bounds a quantity accumulated over a different horizon and a paired +comparison is only paired if both sides saw the same scenarios. The tail metric +is reported beside every mean because a storage policy that is good on average +and bad in the tail is a different object from one that is good in both. + +# The supporting metrics, and why they exist +A large `gap_bound` is easy to mistake for room a better policy could take. These +two say how much of each gap is actually available: + +- **`e` — the deterministic-forecast policy** and `VSS = (forecast − a)/a`. If + ignoring the uncertainty entirely costs nothing, the case has no stochastic + content and no two methods can be told apart on it, whatever the other gaps. +- **`f` — the recoverable ceiling**, `(a − max(bound, pf_mean))/a`. The best + nonanticipative cost `RP` is unknown, but it is at least the relaxation bound + and at least the wait-and-see mean, so this is a hard cap on what TS-DDR could + ever take from `a`. It is an upper bound on the prize, not the prize. + +**The policy is never run in the SOC model.** This SDDP is deliberately +INCONSISTENT — cuts built in the relaxation, states visited in the true model — +so operating the same cuts inside the relaxation gives the cost of a different +trajectory of a different problem, not a decomposition of anything about the +policy we have. +""" +function cost_report(case::BatteryCase, trained, protocol::AbstractMatrix{<:Integer}; + columns, alpha::Real = 0.95, forecast::Bool = true, + io::IO = stdout) + T = trained.num_stages + ids = [b.index for b in case.batteries] + cols = collect(Int.(columns)) + + sims = simulate_battery_sddp_on(trained, protocol; ids = ids, columns = cols) + sddp = [sddp_path_cost(case, s, T) for s in sims] + rec = maximum(max(sims[i][t][:deficit], sims[i][t][:surplus]) + for i in eachindex(sims), t in 1:T) + + panel = perfect_foresight_panel(case, protocol; ids = cols) + panel.complete || + error("perfect-foresight panel incomplete; a gap against a partial panel is a gap against a different problem") + pf = [r.cost for r in panel.rows] + + fc = forecast ? forecast_policy_cost(case, protocol; columns = cols) : nothing + + tail(v) = (n = max(1, ceil(Int, (1 - alpha) * length(v))); mean(sort(v; rev = true)[1:n])) + a, bnd, cc = mean(sddp), trained.bound, mean(pf) + # RP, the best nonanticipative cost, is unknown but is bounded below by BOTH + # the relaxation bound and the wait-and-see mean. Whichever is tighter caps + # what ANY better policy — TS-DDR included — could ever recover from `a`. + rp_lower = max(bnd, cc) + + r = (n = length(cols), horizon = T, alpha = alpha, + sddp_mean = a, sddp_cvar = tail(sddp), sddp_max = maximum(sddp), + sddp_sem = std(sddp) / sqrt(length(sddp)), sddp_recourse = rec, + bound = bnd, + pf_mean = cc, pf_cvar = tail(pf), pf_max = maximum(pf), + pf_sem = std(pf) / sqrt(length(pf)), + forecast_mean = fc === nothing ? NaN : fc.mean, + forecast_max = fc === nothing ? NaN : fc.max, + gap_bound = (a - bnd) / a, + gap_pf = (a - cc) / cc, + vss = fc === nothing ? NaN : (fc.mean - a) / a, + recoverable_ceiling = (a - rp_lower) / a) + + @printf(io, "\n%d stages, %d paths, CVaR at %.0f%%\n", T, r.n, 100alpha) + @printf(io, " a) SDDP ac-soc cost mean %14.2f CVaR %14.2f max %14.2f (sem %.2f)\n", + r.sddp_mean, r.sddp_cvar, r.sddp_max, r.sddp_sem) + @printf(io, " b) SDDP ac-soc bound %14.2f\n", r.bound) + @printf(io, " c) perfect foresight mean %14.2f CVaR %14.2f max %14.2f (sem %.2f)\n", + r.pf_mean, r.pf_cvar, r.pf_max, r.pf_sem) + @printf(io, " d) gap a-b %8.4f%% gap a-c %8.4f%% worst recourse %.2e\n", + 100r.gap_bound, 100r.gap_pf, r.sddp_recourse) + @printf(io, "\n supporting metrics\n") + if fc !== nothing + @printf(io, " e) deterministic-forecast policy %14.2f max %14.2f\n", + r.forecast_mean, r.forecast_max) + @printf(io, " VSS = (forecast - a)/a = %7.4f%% — how much the uncertainty is worth\n", + 100r.vss) + end + @printf(io, " f) recoverable ceiling %7.4f%% — (a - max(b,c))/a, the most ANY better\n", + 100r.recoverable_ceiling) + @printf(io, " nonanticipative policy, TS-DDR included, could win from a\n") + return r +end diff --git a/examples/BatteryStorageOPF/battery_solution_schema.jl b/examples/BatteryStorageOPF/battery_solution_schema.jl new file mode 100644 index 0000000..b18ba0b --- /dev/null +++ b/examples/BatteryStorageOPF/battery_solution_schema.jl @@ -0,0 +1,309 @@ +# 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 diff --git a/examples/BatteryStorageOPF/build_battery_case.jl b/examples/BatteryStorageOPF/build_battery_case.jl new file mode 100644 index 0000000..e13dcb3 --- /dev/null +++ b/examples/BatteryStorageOPF/build_battery_case.jl @@ -0,0 +1,1361 @@ +# build_battery_case.jl +# +# The public case-construction API, and the script that builds the frozen cases +# of this study with it. +# +# This is the only file in the project that reaches out to PGLib.jl in order to +# CREATE case data; everything downstream reads the four frozen files through +# `battery_case.jl`. The user-facing workflow is five calls: +# +# src = acquire_pglib_case("pglib_opf_case30_ieee") # A1 +# buses, prec = select_battery_buses(src.network, SampledPlacement(3; seed = 7)) +# fleet, crec = battery_fleet(src.network, buses; power = ..., energy_hours = ...) +# supp = freeze_demand_support(sampler, src.network, 24; seed = 11, ...) # A3 +# build_case(src; dir = ..., batteries = fleet, support = supp, ...) +# +# and `verify(dir)` re-checks everything the manifest claims. +# +# Usage +# julia --project=. build_battery_case.jl # build (and mirror) +# julia --project=. build_battery_case.jl --verify # re-verify only +# DR_BAT_CASE=pglib_opf_case30_ieee julia ... build_battery_case.jl +# +# Environment overrides (all optional; defaults are the frozen correctness case): +# DR_BAT_CASE PGLib case name +# DR_BAT_DIR output directory (default: case/) +# DR_BAT_NUM number of batteries +# DR_BAT_BUSES comma-separated explicit bus override +# DR_BAT_SEED placement seed +# DR_BAT_HORIZON frozen horizon +# DR_BAT_MIRROR path of the DecisionRulesExa.jl battery example to +# mirror the case and the shared sources into +# +# Reproducibility note. PowerModels MUTATES the network dictionary it is handed +# (per-unit conversion, status propagation, angle-bound defaults). The exporter +# therefore parses the PGLib case FRESH here and writes those bytes before any +# model is instantiated, so the artifact can never depend on which formulation +# happened to be built first in the same session. Running this script twice +# produces byte-identical files. + +using PGLib +using PowerModels +using Pkg +using SHA +using Distributions + +@isdefined(BatterySpec) || include(joinpath(@__DIR__, "battery_case.jl")) +@isdefined(DemandSampler) || include(joinpath(@__DIR__, "battery_demand.jl")) + +PowerModels.silence() + +# ───────────────────────────────────────────────────────────────────────────── +# A1 — PGLib case acquisition +# ───────────────────────────────────────────────────────────────────────────── + +""" + acquire_pglib_case(name; variant=nothing, validate=true) -> NamedTuple + +Obtain a canonical PGLib benchmark and check it is usable as a study case. + +# Arguments +- `name::AbstractString`: PGLib case name, e.g. `"pglib_opf_case30_ieee"` or + `"pglib_opf_case30_ieee__api"`. + +# Keywords +- `variant`: `nothing` (inferred from the name), `"api"`, `"sad"` or `""` for the + typical operating condition. PGLib ships each benchmark in three libraries and + they are DIFFERENT SYSTEMS, not different settings of one: `__api` is the + congested "active power increase" condition and `__sad` the small-angle + difference one. Selecting one is a choice of benchmark, not a modification of a + case, which is why it goes through the acquisition entry point and is recorded + in the manifest. +- `validate::Bool`: run [`validate_network`](@ref) before returning. + +# Returns +A `NamedTuple` with + +- `name::String` — the case name as given; +- `network::Dict{String,Any}` — the parsed, per-unit PowerModels network + dictionary, VERBATIM, with the benchmark's original component identifiers; +- `versions::Dict{String,Any}` — the PGLib, PowerModels and Julia versions the + bytes came from; +- `report::NamedTuple` — the validation summary (component counts, the load and + generation totals, the largest connected component). + +# Notes +Component identifiers are the benchmark's own and are never renumbered. PGLib +cases contain nonconsecutive identifiers, isolated buses and out-of-service +components; every consumer in this study keys on identifiers rather than on +positions, and this entry point is where that is checked rather than assumed. + +Recording the PGLib version matters because a benchmark revised upstream must not +silently become "the same case": the version travels into the manifest and a +rebuild against a different release changes the artifact hashes. +""" +function acquire_pglib_case(name::AbstractString; variant = nothing, + validate::Bool = true) + v = variant === nothing ? _infer_variant(name) : String(variant) + network = isempty(v) ? pglib(String(name)) : pglib(String(name), v) + # `PGLib.pglib` WARNS and returns an empty dictionary for a name it cannot + # find. A study that accepted that would silently build a case out of + # nothing, so an empty result is an error here. + isempty(get(network, "bus", Dict())) && + error("PGLib returned no network for \"$name\"" * + (isempty(v) ? "" : " (variant \"$v\")") * + "; check the name with PGLib.find_pglib_case") + versions = Dict{String,Any}( + "PGLib" => string(_package_version("PGLib")), + "PowerModels" => string(_package_version("PowerModels")), + "julia" => string(VERSION), + "variant" => isempty(v) ? "typical" : v, + ) + report = validate ? validate_network(network) : nothing + return (name = String(name), variant = v, network = network, + versions = versions, report = report) +end + +""" + _infer_variant(name) -> String + +The PGLib library a case name belongs to, from its `__api` / `__sad` suffix. + +# Notes +Inferring rather than requiring the caller to pass it twice removes the one way +this can go silently wrong: asking for `"…__api"` out of the typical-operating- +condition library, getting a name miss, and building the study on whatever the +fuzzy name filter happened to return. +""" +function _infer_variant(name::AbstractString) + endswith(name, "__api") && return "api" + endswith(name, "__sad") && return "sad" + return "" +end + +""" + validate_network(network) -> NamedTuple + +Fail closed on the network properties this study depends on, and summarize what +was found. + +# Checks +1. the mandatory component tables exist and are non-empty; +2. every component identifier equals its own `"index"` field, so the dictionary + key and the identifier can never disagree; +3. every in-service generator, branch and load refers to an existing bus; +4. every in-service bus is reachable from the reference bus over in-service + branches — a second electrical island has its own reference angle and its own + power balance, and a study that quietly spans two of them is not the study it + says it is; +5. at least one reference bus and at least one positively-priced generator exist; +6. total nominal active load is positive. + +# Returns +Counts, totals, and the number of buses in the reference bus's island. + +# Notes +Out-of-service components are reported but not rejected: PGLib ships them and +PowerModels handles them. What is rejected is an in-service component the model +cannot place. +""" +function validate_network(network::AbstractDict) + for tbl in ("bus", "gen", "branch", "load") + haskey(network, tbl) || error("network has no \"$tbl\" table") + isempty(network[tbl]) && error("network table \"$tbl\" is empty") + end + for tbl in ("bus", "gen", "branch", "load", "shunt") + haskey(network, tbl) || continue + for (key, comp) in network[tbl] + parse(Int, string(key)) == Int(comp["index"]) || + error("$tbl entry \"$key\" carries index $(comp["index"])") + end + end + + bus_ids = Set(Int(b["index"]) for (_, b) in network["bus"]) + active_bus = Set(Int(b["index"]) for (_, b) in network["bus"] + if Int(get(b, "bus_type", 1)) != 4) + for (_, g) in network["gen"] + Int(get(g, "gen_status", 1)) == 0 && continue + Int(g["gen_bus"]) in bus_ids || error("generator $(g["index"]) sits at unknown bus $(g["gen_bus"])") + end + for (_, l) in network["load"] + Int(get(l, "status", 1)) == 0 && continue + Int(l["load_bus"]) in bus_ids || error("load $(l["index"]) sits at unknown bus $(l["load_bus"])") + end + adjacency = Dict{Int,Vector{Int}}(i => Int[] for i in bus_ids) + n_branch_off = 0 + for (_, br) in network["branch"] + if Int(get(br, "br_status", 1)) == 0 + n_branch_off += 1 + continue + end + f, t = Int(br["f_bus"]), Int(br["t_bus"]) + (f in bus_ids && t in bus_ids) || + error("branch $(br["index"]) connects unknown buses $f-$t") + push!(adjacency[f], t) + push!(adjacency[t], f) + end + + refs = [Int(b["index"]) for (_, b) in network["bus"] if Int(get(b, "bus_type", 1)) == 3] + isempty(refs) && error("network has no reference (slack) bus") + # Breadth-first search from the first reference bus over in-service branches. + seen = Set{Int}([first(sort!(refs))]) + queue = collect(seen) + while !isempty(queue) + i = pop!(queue) + for j in adjacency[i] + if !(j in seen) + push!(seen, j) + push!(queue, j) + end + end + end + stranded = setdiff(active_bus, seen) + isempty(stranded) || + error("in-service buses $(sort!(collect(stranded))) are not connected to the reference bus") + + priced = 0 + scheduled = 0 + for (_, g) in network["gen"] + # An availability schedule is checked on EVERY generator, in service or + # not: a malformed schedule on a unit that is switched on later is still + # a malformed case, and this is the last point at which the case exists + # as data rather than as a solved stage. + if haskey(g, STAGE_AVAILABILITY_KEY) + sched = g[STAGE_AVAILABILITY_KEY] + (sched isa AbstractVector && !isempty(sched)) || + error("generator $(g["index"]): \"$STAGE_AVAILABILITY_KEY\" must be a non-empty vector of multipliers") + all(x -> isfinite(Float64(x)) && Float64(x) >= 0, sched) || + error("generator $(g["index"]): \"$STAGE_AVAILABILITY_KEY\" must hold finite nonnegative multipliers, got $sched") + scheduled += 1 + end + Int(get(g, "gen_status", 1)) == 0 && continue + c = Float64.(g["cost"]) + any(!=(0), c) && (priced += 1) + end + priced > 0 || error("network has no positively-priced generator") + + total_pd = sum(Float64(l["pd"]) for (_, l) in network["load"] + if Int(get(l, "status", 1)) != 0; init = 0.0) + total_pd > 0 || error("network has no positive nominal active load") + total_pmax = sum(Float64(g["pmax"]) for (_, g) in network["gen"] + if Int(get(g, "gen_status", 1)) != 0; init = 0.0) + + return (bus = length(network["bus"]), gen = length(network["gen"]), + branch = length(network["branch"]), load = length(network["load"]), + shunt = length(get(network, "shunt", Dict())), + branches_out_of_service = n_branch_off, + buses_out_of_service = length(bus_ids) - length(active_bus), + connected_component = length(seen), + total_load_pu = total_pd, total_pmax_pu = total_pmax, + priced_generators = priced, + scheduled_generators = scheduled, + headroom = total_pmax / total_pd) +end + +"Version string of an installed package, by name." +function _package_version(name::AbstractString) + for (_, dep) in Pkg.dependencies() + dep.name == name && return something(dep.version, "unknown") + end + return "unknown" +end + +# ───────────────────────────────────────────────────────────────────────────── +# Recourse prices +# ───────────────────────────────────────────────────────────────────────────── + +""" + recourse_prices(network; factor=50) -> RecourseCosts + +Derive the two-sided recourse prices from the host case. + +# Arguments +- `network::AbstractDict`: parsed PowerModels network (per-unit). + +# Keywords +- `factor::Real`: multiple of the largest generator marginal cost. + +# Returns +- [`RecourseCosts`](@ref) with `deficit == surplus`. + +# Notes +The price is `factor` times the largest generator MARGINAL cost evaluated at that +generator's `pmax`, rounded up to an integer. Deriving it from the case rather +than hard-coding a number is what lets the same API move to another PGLib +benchmark without a hidden re-tuning, and the factor puts recourse far outside +any economic trade-off against dispatch: a policy that uses it is rejected, not +priced. + +**Why the factor is LARGE, measured.** It is tempting to shrink this price on +conditioning grounds: it is the biggest coefficient in the objective by orders of +magnitude, and on `pglib_opf_case300_ieee` a factor of 50 gives 584,698 per pu +against a worst measured NODAL price of 4,612. A failing SOC-WR subproblem duly +produced a `DUAL_INFEASIBLE` certificate whose "unbounded ray" had recourse +components of order `1e-7` — numerical noise that, multiplied by 584,698, moves +the objective by about 2. That reads as a scaling problem, and it is a trap. + +A controlled measurement on `pglib_opf_case118_ieee` says the opposite. Holding +everything else fixed and running ten SDDP iterations: + +| conic tolerance | factor | result | +|---|---|---| +| `1e-8` | 50 | 10 iterations, bound 2,152,035 | +| `1e-6` | 50 | 10 iterations, bound 2,149,769 | +| `1e-8` | **5** | **fails at node 19** | + +The factor, not the tolerance, decides whether SDDP runs, and it is the LOW price +that fails. The reason is admissibility, not scaling: as the price falls the +solution starts to USE recourse, and the base ACP sweep of the research case +shows exactly that — worst recourse 0.00 at factors 50 and 20, then 2.3e-3, +4.5e-3 and 7.5e-3 at 5, 2 and 1. Once recourse is a cheap generator rather than a +last resort, the stage problem's dual structure changes and the conic solves +degrade. + +So the price must beat every real alternative by a wide margin, and the apparent +tension with conditioning is resolved in favour of the large price. + +Deficit and surplus are priced EQUALLY. An asymmetric price would make the +recourse a one-sided economic signal and could bias which side of a reachable +interval a target is pushed towards; the recourse must be neutral, because its +purpose is feasibility, not incentive. +""" +function recourse_prices(network::AbstractDict; factor::Real = 50) + marginal = 0.0 + for (_, gen) in network["gen"] + Int(get(gen, "gen_status", 1)) == 0 && continue + cost = Float64.(gen["cost"]) + ncost = Int(gen["ncost"]) + pmax = Float64(gen["pmax"]) + # PowerModels stores the polynomial highest-order-first. The marginal + # cost of a quadratic model at pmax is 2 c2 pmax + c1; a linear model's + # is just c1; a constant model's is 0. + m = if ncost >= 3 + 2 * cost[end - 2] * pmax + cost[end - 1] + elseif ncost == 2 + cost[end - 1] + else + 0.0 + end + marginal = max(marginal, m) + end + marginal > 0 || error("recourse_prices: case has no positively-priced generator") + price = ceil(factor * marginal) + return RecourseCosts(price, price) +end + +# ───────────────────────────────────────────────────────────────────────────── +# The general case constructor +# ───────────────────────────────────────────────────────────────────────────── + +""" + build_case(source; dir, batteries, support, placement=Dict(), recourse=nothing, + protocol_stages, protocol_scenarios, mirror=nothing) -> BatteryCase + +Write the four frozen artifacts of a case and read them back through the +verifier. + +# Arguments +- `source`: the named tuple returned by [`acquire_pglib_case`](@ref). + +# Keywords +- `dir::AbstractString`: output directory. +- `batteries::Vector{BatterySpec}`: the fleet, from [`battery_fleet`](@ref). +- `support::DemandSupport`: the FROZEN finite support, from + [`freeze_demand_support`](@ref). +- `placement::AbstractDict`: the placement and capacity records, merged into the + battery artifact. +- `recourse`: `nothing` to derive prices from the case, or explicit + [`RecourseCosts`](@ref). +- `protocol_stages`, `protocol_scenarios`: the FINAL paired protocol the manifest + freezes a digest for. +- `screening_seed`, `screening_scenarios`: the INDEPENDENT screening protocol. + Leaving the seed `nothing` records no screening protocol, which is right for a + correctness case that has no selection decision to make. +- `mirror`: an Exa example directory to mirror the case and shared sources into. + +# Notes +Everything the two engines must agree on is decided HERE, once, and hashed. The +function returns the case as READ BACK from disk, not the objects it was handed, +so a case that cannot be re-read is a build failure rather than a later mystery. +""" +function build_case(source; + dir::AbstractString, + batteries::AbstractVector{BatterySpec}, + support::DemandSupport, + placement::AbstractDict = Dict{String,Any}(), + recourse::Union{Nothing,RecourseCosts} = nothing, + protocol_stages::Integer, + protocol_scenarios::Integer, + screening_seed::Union{Nothing,Integer} = nothing, + screening_scenarios::Integer = 0, + mirror::Union{Nothing,AbstractString} = nothing, + quiet::Bool = false) + prices = recourse === nothing ? recourse_prices(source.network) : recourse + record = Dict{String,Any}(placement) + record["versions"] = source.versions + + manifest = write_battery_case(dir; + name = source.name, + network = source.network, + batteries = batteries, + recourse = prices, + demand = support, + source_version = string(source.versions["PGLib"]), + placement = record, + protocol_stages = protocol_stages, + protocol_scenarios = protocol_scenarios, + screening_seed = screening_seed, + screening_scenarios = screening_scenarios) + + built = read_battery_case(dir) # read back through the verifier + if !quiet + print(describe(built)) + println("manifest artifacts:") + for (k, v) in sort!(collect(manifest["artifacts"]); by = first) + println(" ", rpad(k, 18), v) + end + println(" ", rpad("support", 18), manifest["support"]["sha256"]) + println(" ", rpad("protocol", 18), manifest["protocol"]["sha256"]) + manifest["screening"] === nothing || + println(" ", rpad("screening", 18), manifest["screening"]["sha256"]) + end + mirror === nothing || mirror_to_exa(dir, mirror; quiet = quiet) + return built +end + +""" + mirror_to_exa(case_dir, exa_example_dir; quiet=false) + +Copy the frozen case and the byte-shared source files into the ExaModels +example, then assert byte identity of everything copied. + +# Notes +The two engines are independent packages: neither may `include` a file from the +other. They are nonetheless required to agree exactly on the case contract and +on the solution schema, so those files are shipped as COPIES whose identity is +asserted here. The assertion is the point — a copy that has drifted is precisely +the failure this guards against. +""" +function mirror_to_exa(case_dir::AbstractString, exa_example_dir::AbstractString; + quiet::Bool = false) + isdir(exa_example_dir) || error("mirror target $exa_example_dir does not exist") + target_case = joinpath(exa_example_dir, "case", basename(case_dir)) + mkpath(target_case) + for f in ("network.json", "batteries.json", "demand.json", "case_manifest.json") + cp(joinpath(case_dir, f), joinpath(target_case, f); force = true) + sha256_file(joinpath(case_dir, f)) == sha256_file(joinpath(target_case, f)) || + error("mirrored case file $f is not byte-identical") + end + for f in ("battery_case.jl", "battery_solution_schema.jl") + src = joinpath(@__DIR__, f) + dst = joinpath(exa_example_dir, f) + cp(src, dst; force = true) + sha256_file(src) == sha256_file(dst) || + error("mirrored source file $f is not byte-identical") + end + quiet || println("mirrored case + shared sources into ", exa_example_dir) + return nothing +end + +""" + verify(dir) -> BatteryCase + +Re-verify a frozen case in place: hashes, schemas, the stage-duration contract, +the battery bound consistency checks, the support digest and the regenerated +protocol digest. +""" +function verify(dir::AbstractString = get(ENV, "DR_BAT_DIR", + joinpath(@__DIR__, "case", DEFAULT_CASE))) + case = read_battery_case(dir) + print(describe(case)) + println("case verified: ", dir) + return case +end + +# ───────────────────────────────────────────────────────────────────────────── +# The correctness case +# +# These are the constants of the Phase-1 correctness case. They deliberately +# describe a SMALL, comfortably feasible system: the case exists to establish +# that the two engines agree and that the strict formulation is well posed, not +# to expose a scientific mechanism. The research case is constructed from the +# same API by `case_design.jl`, and is not this section's business. +# ───────────────────────────────────────────────────────────────────────────── + +"PGLib benchmark used by the correctness case." +const DEFAULT_CASE = get(ENV, "DR_BAT_CASE", "pglib_opf_case14_ieee") + +"Number of batteries placed when no explicit bus list is given." +const DEFAULT_NUM_BATTERIES = parse(Int, get(ENV, "DR_BAT_NUM", "3")) + +"Seed of the deterministic placement draw." +const DEFAULT_PLACEMENT_SEED = parse(Int, get(ENV, "DR_BAT_SEED", "20260804")) + +"Seed of the paired evaluation protocol." +const DEFAULT_PROTOCOL_SEED = parse(Int, get(ENV, "DR_BAT_PROTOCOL_SEED", "20260804")) + +"Frozen horizon of the correctness case." +const DEFAULT_HORIZON = parse(Int, get(ENV, "DR_BAT_HORIZON", "48")) + +"Shape and scenario dimensions the manifest freezes a protocol digest for." +const PROTOCOL_STAGES = parse(Int, get(ENV, "DR_BAT_PROTOCOL_STAGES", "48")) +const PROTOCOL_SCENARIOS = parse(Int, get(ENV, "DR_BAT_PROTOCOL_SCENARIOS", "200")) + +""" +Fraction of stored energy a battery retains across one one-hour stage. + +A physical 0.1 %/h standing loss. It is deliberately NOT 1: with ``\\alpha = 1`` +the multiplier transform that turns stage duals into the actor signal reduces to +a plain difference and a sign or scaling error in the ``\\alpha`` term would go +unnoticed by every test. +""" +const SELF_DISCHARGE = 0.999 + +""" +Degradation price charged on battery throughput, per pu·h of +``\\Delta t (p^{ch} + p^{dis})``. + +Small against the case's marginal generation cost — about 0.2 % of it — so it +does not distort dispatch, but STRICTLY positive, which is what makes +simultaneous charging and discharging strictly suboptimal in the continuous +relaxation instead of merely unattractive. +""" +const THROUGHPUT_COST = 5.0 + +""" + build(; case, dir, num_batteries, buses, seed, horizon, mirror) -> BatteryCase + +Build the correctness case: a system-wide three-atom demand support on a mild +diurnal profile, with batteries drawn from the load buses. + +# Notes +The demand sampler is written out in full rather than hidden behind a constant, +because this function is also the smallest complete EXAMPLE of the public +workflow: acquire, place, rate, freeze, build. +""" +function build(; case::AbstractString = DEFAULT_CASE, + dir::AbstractString = get(ENV, "DR_BAT_DIR", joinpath(@__DIR__, "case", DEFAULT_CASE)), + num_batteries::Integer = DEFAULT_NUM_BATTERIES, + buses = _env_buses(), + seed::Integer = DEFAULT_PLACEMENT_SEED, + horizon::Integer = DEFAULT_HORIZON, + mirror::Union{Nothing,AbstractString} = get(ENV, "DR_BAT_MIRROR", nothing), + quiet::Bool = false) + + source = acquire_pglib_case(case) + + # ── batteries ──────────────────────────────────────────────────────────── + strategy = buses === nothing ? SampledPlacement(num_batteries; seed = seed) : + ExplicitPlacement(buses) + chosen, placement_record = select_battery_buses(source.network, strategy) + total_load = sum(values(nominal_load_at_bus(source.network))) + fleet, capacity_record = battery_fleet(source.network, chosen; + power = 0.10 * total_load, + energy_hours = 2.0, + self_discharge = SELF_DISCHARGE, + throughput_cost = THROUGHPUT_COST, + initial_fraction = 0.5) + + # ── demand ─────────────────────────────────────────────────────────────── + # Three symmetric system-wide atoms with equal probability. Symmetry means + # the process has mean 1, so the deterministic shape alone describes expected + # demand and the uncertainty is a pure spread around it. Three atoms is small + # enough that an SDDP backward pass enumerates it exactly and large enough + # that a policy must hedge rather than track a single forecast. + sampler = SystemMultiplier(DiscreteNonParametric([0.95, 1.0, 1.05], + [1 / 3, 1 / 3, 1 / 3])) + support = freeze_demand_support(sampler, source.network, horizon; + seed = DEFAULT_PROTOCOL_SEED, + method = :exact, + profile = diurnal_profile(horizon), + protocol_seed = DEFAULT_PROTOCOL_SEED, + stage_hours = 1.0) + + return build_case(source; + dir = dir, + batteries = fleet, + support = support, + placement = Dict{String,Any}("buses" => placement_record, + "capacity" => capacity_record, + "capacity_rule" => + "power = 10% of nominal system load; energy = 2 h"), + protocol_stages = PROTOCOL_STAGES, + protocol_scenarios = PROTOCOL_SCENARIOS, + mirror = mirror, + quiet = quiet) +end + +""" + ensure_case(dir; kwargs...) -> BatteryCase + +Read the frozen case at `dir`, BUILDING it first if it is not there. + +# Notes +Cases are constructed, never committed: the artifacts are a pure function of this +file's builder and its recorded seeds. Anything that needs a case — a test, a +diagnostic, an engine — calls this rather than assuming someone checked one in. +""" +function ensure_case(dir::AbstractString = joinpath(@__DIR__, "case", DEFAULT_CASE); + quiet::Bool = true, kwargs...) + isfile(joinpath(dir, "case_manifest.json")) && return read_battery_case(dir) + return build(; dir = dir, quiet = quiet, kwargs...) +end + +# ───────────────────────────────────────────────────────────────────────────── +# The research case +# +# Constructed from the same public API as the correctness case, with three +# differences, each of which was MEASURED rather than chosen: +# +# • the benchmark is a congested PGLib operating condition, selected because +# its SOC-WR relaxation misprices stored energy at a decision level; +# • the deterministic profile has a quiet window where charging is cheap and a +# stressed window where stored energy is valuable; +# • the uncertainty is a small JOINT REGIONAL support that stresses the +# constrained pocket and the rest of the system independently, so WHERE +# energy is stored matters and not only HOW MUCH. +# +# Every constant below is part of the frozen benchmark and travels into the +# manifest. The evidence that selected them is in the Phase-2 record. +# ───────────────────────────────────────────────────────────────────────────── + +""" + research_profile(horizon; low, high, peak_hour, period) -> Vector{Float64} + +The deterministic hourly profile of the research case. + +# Notes +A raised cosine on `[low, high]` rather than a mean-1 profile: the LEVEL matters +here, because the case is built on a congested operating condition where the +network's ability to deliver is the binding physics. The quiet hours sit low +enough that charging is cheap and uncongested; the peak sits at the highest level +the base ACP problem still serves with NO recourse under every atom, which is the +admissibility precondition of the whole strict-target construction. +""" +function research_profile(horizon::Integer; low::Real = 0.78, high::Real = 1.00, + peak_hour::Integer = 19, period::Integer = 24) + mid = (low + high) / 2 + amp = (high - low) / 2 + return [mid + amp * cos(2π * (t - peak_hour) / period) for t in 1:horizon] +end + +""" + regional_demand_sampler(network; pocket_buses, quiet_stages, horizon, + pocket_atoms, rest_atoms) -> DemandSampler + +The research case's authoring sampler: deterministic quiet hours, and a joint +two-region support in the stressed hours. + +# Arguments +- `pocket_buses`: the buses of the constrained region, measured from the nodal + prices and the binding limits of the base dispatch. + +# Keywords +- `quiet_stages`: a predicate `t -> Bool` marking the stages with no uncertainty. +- `pocket_atoms`, `rest_atoms`: the finite supports of the two regional + multipliers. + +# Notes +Two regions, two atoms each, is the smallest construction that makes the +LOCATION of stored energy a hedging decision rather than a bookkeeping detail: +the pocket and the rest move independently, so a policy that has put its energy +in the wrong place cannot move it in time. A system-wide sampler with the same +marginal spread would produce a purely temporal problem, and every battery in it +would be interchangeable. + +The quiet stages carry a DEGENERATE support (one atom, probability 1). That is +deliberate and is not the same as having no stages there: the quiet hours are +where the policy charges, and the value of doing so is exactly what the stressed +hours reveal. +""" +function regional_demand_sampler(network::AbstractDict; + pocket_buses, + quiet_stages, + horizon::Integer, + pocket_atoms = ([0.96, 1.04], [0.5, 0.5]), + rest_atoms = ([0.99, 1.01], [0.5, 0.5])) + meta = demand_meta(network) + pocket = Set(Int.(pocket_buses)) + pocket_loads = [meta.load_ids[j] for j in 1:meta.num_loads if meta.load_bus[j] in pocket] + rest_loads = [meta.load_ids[j] for j in 1:meta.num_loads if !(meta.load_bus[j] in pocket)] + isempty(pocket_loads) && error("regional_demand_sampler: the pocket contains no load") + isempty(rest_loads) && error("regional_demand_sampler: every load is in the pocket") + + stressed = GroupMultiplier([pocket_loads, rest_loads], + [DiscreteNonParametric(pocket_atoms...), + DiscreteNonParametric(rest_atoms...)]) + quiet = DeterministicMultiplier(1.0) + return StageMultiplier([quiet_stages(t) ? quiet : stressed for t in 1:horizon]) +end + +""" + nearest_bus_regions(network, centers) -> Vector{Vector{Int}} + +Partition every load bus among `centers` by electrical hop distance: each load +bus joins the center it is closest to over the branch graph. + +# Notes +Automatic, and it applies to any PGLib case and any set of centers. Passing the +battery buses as the centers gives each battery its OWN region, which is the +precondition for the demand process to say anything locational: if two batteries +sit in one region they see the same signal and one of them is redundant. + +Ties go to the lower-numbered center, so the partition is a deterministic +function of the network and the centers. Buses unreachable from every center +(an islanded component) join the first center; a PGLib case is connected, so +this is a guard rather than a case that arises. + +The manual path is to skip this and hand region load lists straight to +[`JointRegionMultiplier`](@ref) — which is what to do when a measured region +(nodal prices, binding limits) is wanted instead of a distance partition. +""" +function nearest_bus_regions(network::AbstractDict, centers) + ctr = Int.(collect(centers)) + isempty(ctr) && throw(ArgumentError("nearest_bus_regions: no centers given")) + + adj = Dict{Int,Vector{Int}}() + for (_, br) in network["branch"] + get(br, "br_status", 1) == 0 && continue + f, t = Int(br["f_bus"]), Int(br["t_bus"]) + push!(get!(adj, f, Int[]), t) + push!(get!(adj, t, Int[]), f) + end + + # One multi-source BFS rather than one BFS per center: the frontier carries + # its owner, so every bus is settled at its true nearest center in one sweep. + owner = Dict{Int,Int}() + for (i, c) in enumerate(ctr) + haskey(owner, c) || (owner[c] = i) + end + frontier = copy(ctr) + while !isempty(frontier) + nxt = Int[] + for b in frontier, nb in get(adj, b, Int[]) + haskey(owner, nb) && continue + owner[nb] = owner[b] + push!(nxt, nb) + end + frontier = nxt + end + + regions = [Int[] for _ in ctr] + for b in sort!(collect(keys(nominal_load_at_bus(network)))) + push!(regions[get(owner, b, 1)], b) + end + return regions +end + +""" + rotating_regime_sampler(network; centers, horizon, low, high, period, + peak_hour, stress_min, stress_max, joint_share, + spread, min_probability, groups, modes, + mode_probabilities) -> DemandSampler + +A demand process whose regional means, tail and inter-region CORRELATION all +change with the stage. + +# Keywords +- `centers`: the region centers, normally the battery buses. Ignored when + `groups` is given. +- `groups`: explicit region bus lists — the manual path past the automatic + [`nearest_bus_regions`](@ref) partition. +- `low`, `high`: the slack and stressed regional multipliers. +- `period`, `peak_hour`: the daily cycle the regime rotates on. +- `stress_min`, `stress_max`: total probability that SOME region is stressed, at + the trough and at the peak of the cycle. +- `joint_share`: at the cycle peak, the share of that stress probability going + to the all-regions-stressed mode. Below the peak it is scaled down, so heavy + hours are also the CORRELATED hours. +- `spread`: `0` makes every region equally likely to be the stressed one at + every stage; `1` makes the stressed region rotate sharply with the cycle. +- `min_probability`: modes below this at a stage are dropped and the rest + renormalized. +- `modes`, `mode_probabilities`: fully manual overrides — an explicit + `(num_regions, K)` mode matrix and a `t -> probabilities` callable. + +# Notes +The modes are the joint outcomes worth naming: everything slack, exactly one +region stressed (one mode per region), and everything stressed. So `R` regions +cost `R + 2` atoms rather than the `2^R` of independent regions. + +What makes the process hard to operate is that the three things a policy would +want to know move independently: + +- the MEAN moves, because the probability of any stress at all follows the daily + cycle between `stress_min` and `stress_max`; +- the TAIL moves, because the all-regions-stressed mode is scaled by the cycle + on top of that, so the heavy outcome is concentrated in a few hours; +- the CORRELATION moves, and it changes SIGN. When mass sits on the single-region + modes the regions are negatively correlated — one is stressed exactly when the + others are slack, and energy stored in the right place is worth much more than + the same energy stored elsewhere. When mass sits on the calm and all-stressed + modes they are positively correlated, and location buys nothing. + +A policy therefore cannot reduce the problem to one storage schedule copied +across sites, nor to a per-site schedule computed independently: the right +charge in region `r` depends on the phase of the cycle and on what the other +regions are expected to do. That is the multi-dimensional structure the study +needs, and it is also precisely what a perfect-foresight solution exploits — +knowing WHICH region gets stressed, not merely how much total demand arrives. + +`spread` is the knob that sets how much of that is locational: at `spread=0` the +identity of the stressed region is pure coin-flip noise with no time structure, +and the process degenerates to a temporal one. +""" +function rotating_regime_sampler(network::AbstractDict; + centers = Int[], + horizon::Integer, + low::Real = 0.85, + high::Real = 1.15, + period::Integer = 24, + peak_hour::Integer = 19, + stress_min::Real = 0.10, + stress_max::Real = 0.90, + joint_share::Real = 0.35, + spread::Real = 0.85, + min_probability::Real = 1e-3, + groups = nothing, + modes = nothing, + mode_probabilities = nothing) + region_buses = groups === nothing ? nearest_bus_regions(network, centers) : + [sort!(collect(Int.(g))) for g in groups] + R = length(region_buses) + R >= 2 || throw(ArgumentError("rotating_regime_sampler needs at least 2 regions")) + any(isempty, region_buses) && + throw(ArgumentError("rotating_regime_sampler: a region contains no load bus")) + + # Columns: calm, then one per region, then all-stressed. + M = modes === nothing ? + hcat(fill(Float64(low), R), + [[r == c ? Float64(high) : Float64(low) for r in 1:R] for c in 1:R]..., + fill(Float64(high), R)) : + (modes isa AbstractMatrix ? Float64.(Matrix(modes)) : + reduce(hcat, [Float64.(collect(m)) for m in modes])) + K = size(M, 2) + + "Mode probabilities at stage `t`: the cycle sets how much stress and how correlated." + function default_probs(t) + # Cycle intensity in [0, 1], peaking at `peak_hour`. + s = (1 + cos(2π * (t - peak_hour) / period)) / 2 + total = stress_min + (stress_max - stress_min) * s + joint = total * joint_share * s # tail concentrates at the peak + local_total = total - joint + # Which region is the stressed one rotates through the cycle: region r's + # turn is offset by r/R of a period. + w = [(1 - spread) + spread * + max(0.0, cos(2π * (t - peak_hour) / period - 2π * (r - 1) / R)) + for r in 1:R] + sw = sum(w) + sw > 0 || (w = fill(1.0, R); sw = R) + return vcat(1 - total, local_total .* (w ./ sw), joint) + end + + probs_at = mode_probabilities === nothing ? default_probs : mode_probabilities + + stages = Vector{DemandSampler}(undef, horizon) + for t in 1:horizon + p = Float64.(collect(probs_at(t))) + length(p) == K || error("mode probabilities at stage $t have length $(length(p)), expected $K") + # Strictly positive as well as above the threshold: at the trough of the + # cycle the all-stressed mode has probability exactly zero, and a + # zero-probability atom is not a mode of the law, it is an absent one. + keep = [k for k in 1:K if p[k] >= min_probability && p[k] > 0] + isempty(keep) && (keep = [argmax(p)]) + q = p[keep] ./ sum(p[keep]) + # A single surviving mode stays a JointRegionMultiplier carrying one + # atom: it keys by BUS, where DeterministicMultiplier's dict form keys + # by LOAD, and mixing the two keyings is a silent way to get it wrong. + stages[t] = JointRegionMultiplier(region_buses, M[:, keep], q; by = :bus) + end + return StageMultiplier(stages) +end + +""" + build_research_case(; case, dir, pocket_buses, battery_buses, horizon, + report_stages, power_fraction, energy_hours, + profile_low, profile_high, pocket_atoms, rest_atoms, + protocol_scenarios, mirror) -> BatteryCase + +Build a multiperiod research case from the public API. + +# Keywords +- `case::AbstractString`: PGLib benchmark, including its `__api` / `__sad` suffix. +- `pocket_buses`: the constrained region, from the base-dispatch measurement. +- `battery_buses`: where the batteries go, from the storage-value measurement. +- `horizon::Integer`: stages FROZEN, i.e. reported window plus look-ahead tail. +- `report_stages::Integer`: the reported window, recorded in the manifest. +- `power_fraction::Real`: each battery's power rating as a fraction of nominal + active load — of the WHOLE SYSTEM under `power_basis = :system`, or of the + battery's OWN region under `:region`; `energy_hours` its duration. +- `power_basis::Symbol`: `:system` or `:region`. Use `:region` on a large network + with concentrated regions, where a system-wide fraction can make one battery + large enough to dominate its own neighbourhood. +- `profile_low`, `profile_high`: the deterministic profile's band. +- `pocket_atoms`, `rest_atoms`: `(values, probabilities)` of the two regional + multipliers in the stressed hours. `:pocket` regime only. +- `demand_regime`: `:pocket` for the two-region product process, or `:rotating` + for the time-varying joint process of [`rotating_regime_sampler`](@ref), whose + regions carry independent means, tails and a correlation that changes sign + through the cycle. +- `region_centers`: the `:rotating` regions' centers; defaults to the battery + buses, which is what gives each battery a region of its own. +- `region_groups`: explicit region bus lists — the manual path past the + automatic partition. +- `regime`: a NamedTuple of [`rotating_regime_sampler`](@ref) keywords + (`low`, `high`, `stress_min`, `stress_max`, `joint_share`, `spread`, …). + +# Notes +Everything the benchmark IS is an argument here, and every argument lands in the +manifest, so the frozen case can be rebuilt from the recorded values alone. + +**Horizon and tail.** The reported window is a whole number of daily cycles, so a +storage decision taken in it is completed inside it. The tail exists for one +reason: with a finite horizon and no terminal value, the optimal thing to do in +the last stages is to empty every battery, and if the reported window ended at +the horizon that dump would be a large part of the reported cost. Reporting a +prefix and letting the tail absorb the terminal effect is what keeps the +comparison about the policy rather than about the boundary condition. + +**Quiet hours.** Stages in the first half of each daily cycle carry a degenerate +one-atom support. That is where charging happens, and it is deterministic on +purpose: the study is about valuing STORED energy under uncertainty about when it +will be needed, not about a policy's ability to forecast the hour it charges in. +""" +function build_research_case(; case::AbstractString, + dir::AbstractString, + pocket_buses, + battery_buses, + horizon::Integer = 36, + report_stages::Integer = 24, + power_fraction::Real = 0.04, + energy_hours::Real = 2.0, + profile_low::Real = 0.78, + profile_high::Real = 1.00, + pocket_atoms = ([0.96, 1.04], [0.5, 0.5]), + rest_atoms = ([0.99, 1.01], [0.5, 0.5]), + pocket_fraction::Real = 0.0, + demand_regime::Symbol = :pocket, + power_basis::Symbol = :system, + region_centers = Int[], + region_groups = nothing, + regime = NamedTuple(), + self_discharge::Real = SELF_DISCHARGE, + throughput_cost::Real = THROUGHPUT_COST, + initial_fraction::Real = 0.5, + reserve_fraction::Real = 0.0, + protocol_seed::Integer = DEFAULT_PROTOCOL_SEED, + protocol_scenarios::Integer = 500, + screening_seed::Integer = DEFAULT_PROTOCOL_SEED + 1, + screening_scenarios::Integer = 64, + recourse_factor::Real = 50, + quiet_stages = t -> mod1(t, 24) <= 12, + mirror::Union{Nothing,AbstractString} = nothing, + quiet::Bool = false) + source = acquire_pglib_case(case) + + # A pocket given as a FRACTION selects that share of the load buses, largest + # demand first. It is the automatic path; an explicit `pocket_buses` list is + # the manual one, for when a measured region is wanted instead. + pocket = pocket_fraction > 0 ? + (l = nominal_load_at_bus(source.network); + r = sort!(collect(keys(l)); by = b -> -max(0.0, l[b])); + r[1:max(1, round(Int, pocket_fraction * length(r)))]) : pocket_buses + + buses, placement_record = select_battery_buses(source.network, + ExplicitPlacement(battery_buses)) + load_at = nominal_load_at_bus(source.network) + total_load = sum(max(0.0, v) for v in values(load_at)) + + # `:system` rates every battery at a fraction of TOTAL system load; `:region` + # rates it at a fraction of its OWN region's load. + # + # `:system` is a trap on a large network with concentrated regions. On + # case300 a 0.04 system fraction is 9.54 pu, and the region around bus 138 + # holds 24 pu of load — so charging that battery is a 40 % local demand + # spike, and there are states where it is the only thing between the region + # and a shortfall. The dual of stored energy is then the RECOURSE price + # rather than an energy price, and SDDP builds cuts whose coefficients span + # ten orders of magnitude, which is what makes later subproblems report false + # infeasibility. Sizing against the battery's own region keeps the machine + # proportionate to the load it serves at every site. + power_rule = if power_basis === :region + regions = region_groups === nothing ? + nearest_bus_regions(source.network, + isempty(region_centers) ? buses : region_centers) : + [sort!(collect(Int.(g))) for g in region_groups] + region_load = Dict{Int,Float64}() + for (i, r) in enumerate(regions) + l = sum(max(0.0, get(load_at, b, 0.0)) for b in r) + for b in r + region_load[b] = l + end + i <= length(buses) || continue + end + bus -> power_fraction * get(region_load, bus, total_load) + elseif power_basis === :system + power_fraction * total_load + else + throw(ArgumentError("power_basis must be :system or :region, got :$power_basis")) + end + + fleet, capacity_record = battery_fleet(source.network, buses; + power = power_rule, + energy_hours = energy_hours, + self_discharge = self_discharge, + throughput_cost = throughput_cost, + initial_fraction = initial_fraction, + reserve_fraction = reserve_fraction) + + # `:pocket` is the two-region product process; `:rotating` is the + # time-varying joint one, whose regions are the batteries' own neighbourhoods. + sampler = if demand_regime === :rotating + rotating_regime_sampler(source.network; + centers = isempty(region_centers) ? buses : region_centers, + horizon = horizon, + groups = region_groups, + regime...) + elseif demand_regime === :pocket + regional_demand_sampler(source.network; + pocket_buses = pocket, + quiet_stages = quiet_stages, + horizon = horizon, + pocket_atoms = pocket_atoms, + rest_atoms = rest_atoms) + else + throw(ArgumentError("demand_regime must be :pocket or :rotating, got :$demand_regime")) + end + support = freeze_demand_support(sampler, source.network, horizon; + seed = protocol_seed, + method = :exact, + profile = research_profile(horizon; + low = profile_low, + high = profile_high), + profile_period = 24, + protocol_seed = protocol_seed, + stage_hours = 1.0) + + return build_case(source; + dir = dir, + batteries = fleet, + support = support, + recourse = recourse_prices(source.network; factor = recourse_factor), + placement = Dict{String,Any}( + "recourse_factor" => Float64(recourse_factor), + "buses" => placement_record, + "capacity" => capacity_record, + "capacity_rule" => "power = $(power_fraction) × nominal $(power_basis === :region ? "region" : "system") load; energy = $(energy_hours) h", + "power_basis" => String(power_basis), + "pocket_buses" => sort!(collect(Int.(pocket))), + "pocket_fraction" => Float64(pocket_fraction), + "profile" => Dict{String,Any}("low" => Float64(profile_low), + "high" => Float64(profile_high), + "peak_hour" => 19, + "period" => 24), + "pocket_atoms" => Dict{String,Any}("values" => Float64.(pocket_atoms[1]), + "probabilities" => Float64.(pocket_atoms[2])), + "rest_atoms" => Dict{String,Any}("values" => Float64.(rest_atoms[1]), + "probabilities" => Float64.(rest_atoms[2])), + "demand_regime" => String(demand_regime), + "regime" => Dict{String,Any}(String(k) => v for (k, v) in pairs(regime)), + "sampler" => sampler_to_dict(sampler), + "report_stages" => Int(report_stages), + "lookahead_stages" => Int(horizon) - Int(report_stages)), + protocol_stages = Int(horizon), + protocol_scenarios = Int(protocol_scenarios), + screening_seed = Int(screening_seed), + screening_scenarios = Int(screening_scenarios), + mirror = mirror, + quiet = quiet) +end + +"Explicit battery buses from `DR_BAT_BUSES`, or `nothing` for the seeded draw." +function _env_buses() + raw = get(ENV, "DR_BAT_BUSES", "") + isempty(strip(raw)) && return nothing + return [parse(Int, strip(x)) for x in split(raw, ",") if !isempty(strip(x))] +end + +# ───────────────────────────────────────────────────────────────────────────── +# Engineered relaxation-gap modules (Phase 3A) +# ───────────────────────────────────────────────────────────────────────────── + +""" + CycleModuleSpec(; kwargs...) + +The parameters of one meshed cycle module. Every field is recorded in the +manifest and enters the case digest, so a module is reproducible from numbers +alone. + +# Fields +- `load_p`, `load_q`: the remote bus's demand, pu. +- `local_pmax`, `local_cost`: the remote generator's capacity and LINEAR cost. + `pmin` is zero, so it is a convex, always-feasible fallback and never a + commitment decision. +- `local_qmin`, `local_qmax`: its reactive band, sized so reactive feasibility + at the remote bus is never the binding physics. +- `r_hm, x_hm, r_mr, x_mr, r_hr, x_hr`: the three cycle branches' impedances. +- `rate_hm, rate_mr, rate_hr`: their apparent-power ratings. +- `vmin`, `vmax`: voltage band of the two new buses. +- `base_kv`: carried from the host bus when zero. + +# Notes +The module exists to make ONE omitted condition matter. `SOCWRConicPowerModel` +constrains each branch's voltage-product block by +`wr^2 + wi^2 <= w_fr * w_to` but never requires the recovered angle differences +to sum to zero around a cycle, so on a loop it admits `W` matrices that no real +voltage profile realises. On a radial network the condition is vacuous, which is +why the relaxation is exact there. + +The amplifier is loop RESISTANCE. Around a cycle the relaxation can settle on a +`W` whose implied flows do not pay the full `I^2 R` a consistent voltage profile +would, so SOC systematically believes the remote bus can be served more cheaply +through the loop than AC can actually serve it. The expensive local generator +turns that belief into money: where SOC imports cheap power around the cycle, +AC must dispatch the local unit instead. + +This is a hypothesis about mechanism, and the point of the Phase 3A gate is to +measure whether it produces a different STORAGE ACTION rather than merely a +different objective level. A relaxation gap in cost alone changes nothing about +what a policy should do. +""" +Base.@kwdef struct CycleModuleSpec + load_p::Float64 = 0.60 + load_q::Float64 = 0.20 + local_pmax::Float64 = 1.20 + local_cost::Float64 = 260.0 + local_qmin::Float64 = -0.80 + local_qmax::Float64 = 0.80 + r_hm::Float64 = 0.030 + x_hm::Float64 = 0.030 + r_mr::Float64 = 0.030 + x_mr::Float64 = 0.030 + r_hr::Float64 = 0.010 + x_hr::Float64 = 0.060 + rate_hm::Float64 = 0.50 + rate_mr::Float64 = 0.50 + rate_hr::Float64 = 0.50 + vmin::Float64 = 0.94 + vmax::Float64 = 1.06 + base_kv::Float64 = 0.0 +end + +""" + attach_cycle_module!(network, host_bus, spec; tag) -> NamedTuple + +Attach one triangular meshed module to `host_bus` IN PLACE, and report every +identifier and parameter it added. + +# Arguments +- `network`: a parsed PowerModels network, mutated in place. +- `host_bus`: any existing in-service bus. The module is generic; nothing here + is specific to one PGLib case. +- `spec::CycleModuleSpec`: the parameters. + +# Returns +A `NamedTuple` with the new `mid_bus`, `remote_bus`, the three `branches`, the +`gen` and `load` identifiers, and `record`, a plain dictionary of everything +added — which is what travels into the manifest and the digest. + +# Notes +Identifiers are allocated above the current maximum of EVERY table, so they +cannot collide with the backbone's own nonconsecutive numbering. Units are +untouched: the network stays in whatever per-unit convention it arrived in, and +`base_kv` is inherited from the host bus unless overridden. + +The topology is deliberately the smallest object that carries a cycle: host, +one intermediate bus, one remote bus, three branches. The battery and the +uncertainty attach at the remote bus, so the storage state sits BEHIND the loop +and its value depends on how the loop is modelled — which is the whole point. +""" +function attach_cycle_module!(network::AbstractDict, host_bus::Integer, + spec::CycleModuleSpec = CycleModuleSpec(); + tag::AbstractString = "cyc") + haskey(network["bus"], string(host_bus)) || + throw(ArgumentError("host bus $host_bus is not in the network")) + host = network["bus"][string(host_bus)] + Int(get(host, "bus_type", 1)) == 4 && + throw(ArgumentError("host bus $host_bus is out of service")) + + nextid(tbl) = isempty(get(network, tbl, Dict())) ? 1 : + maximum(parse(Int, k) for k in keys(network[tbl])) + 1 + bkv = spec.base_kv > 0 ? spec.base_kv : Float64(get(host, "base_kv", 1.0)) + + mid = nextid("bus") + rem = mid + 1 + for (id, nm) in ((mid, "$(tag)_mid"), (rem, "$(tag)_remote")) + network["bus"][string(id)] = Dict{String,Any}( + "index" => id, "bus_i" => id, "bus_type" => 1, + "vmin" => spec.vmin, "vmax" => spec.vmax, + "vm" => 1.0, "va" => 0.0, "base_kv" => bkv, + "zone" => Int(get(host, "zone", 1)), "area" => Int(get(host, "area", 1)), + "name" => nm, "source_id" => Any["bus", id]) + end + + b1, b2, b3 = nextid("branch"), nextid("branch") + 1, nextid("branch") + 2 + function addbranch!(id, f, t, r, x, rate) + network["branch"][string(id)] = Dict{String,Any}( + "index" => id, "f_bus" => f, "t_bus" => t, + "br_r" => r, "br_x" => x, + "g_fr" => 0.0, "b_fr" => 0.0, "g_to" => 0.0, "b_to" => 0.0, + "tap" => 1.0, "shift" => 0.0, "br_status" => 1, + "angmin" => -pi / 3, "angmax" => pi / 3, + "rate_a" => rate, "rate_b" => rate, "rate_c" => rate, + "transformer" => false, "source_id" => Any["branch", id]) + end + addbranch!(b1, Int(host_bus), mid, spec.r_hm, spec.x_hm, spec.rate_hm) + addbranch!(b2, mid, rem, spec.r_mr, spec.x_mr, spec.rate_mr) + addbranch!(b3, Int(host_bus), rem, spec.r_hr, spec.x_hr, spec.rate_hr) + + gid = nextid("gen") + network["gen"][string(gid)] = Dict{String,Any}( + "index" => gid, "gen_bus" => rem, + "pg" => 0.0, "qg" => 0.0, + "pmin" => 0.0, "pmax" => spec.local_pmax, + "qmin" => spec.local_qmin, "qmax" => spec.local_qmax, + "vg" => 1.0, "mbase" => Float64(network["baseMVA"]), "gen_status" => 1, + # Linear and convex on purpose: an expensive fallback, never a + # commitment decision, so nothing here makes the problem nonconvex. + "model" => 2, "ncost" => 2, "cost" => [spec.local_cost, 0.0], + "startup" => 0.0, "shutdown" => 0.0, + "source_id" => Any["gen", gid]) + + lid = nextid("load") + network["load"][string(lid)] = Dict{String,Any}( + "index" => lid, "load_bus" => rem, + "pd" => spec.load_p, "qd" => spec.load_q, "status" => 1, + "source_id" => Any["load", lid]) + + record = Dict{String,Any}( + "tag" => String(tag), "host_bus" => Int(host_bus), + "mid_bus" => mid, "remote_bus" => rem, + "branch_hm" => b1, "branch_mr" => b2, "branch_hr" => b3, + "gen" => gid, "load" => lid, "base_kv" => bkv, + "spec" => Dict{String,Any}(string(f) => getfield(spec, f) + for f in fieldnames(CycleModuleSpec))) + return (mid_bus = mid, remote_bus = rem, branches = (b1, b2, b3), + gen = gid, load = lid, record = record) +end + +""" + attach_scheduled_generator!(network, bus; pmax, cost, pmin=0.0, qmin=0.0, + qmax=0.0, availability=Float64[], tag="sched") + -> NamedTuple + +Attach one dispatchable generator to an existing bus IN PLACE, optionally +available in only some stages, and report everything it added. + +# Arguments +- `network`: a parsed PowerModels network, mutated in place. +- `bus`: any existing in-service bus. + +# Keywords +- `pmax::Real`, `pmin::Real`: active limits (pu). +- `cost`: polynomial coefficients HIGHEST ORDER FIRST, PowerModels' own + convention — `[c2, c1, c0]` for `c2 pg^2 + c1 pg + c0`. +- `qmin::Real`, `qmax::Real`: reactive limits (pu). Both default to zero, which + is a unit that supplies active power only and leaves the reactive picture of + the case exactly as it was. +- `availability`: per-stage multiplier vector written to + [`STAGE_AVAILABILITY_KEY`](@ref); empty means available in every stage. +- `tag::AbstractString`: recorded, and used in the generator's name. + +# Returns +A `NamedTuple` with the new `gen` identifier and `record`, a plain dictionary of +every parameter — which is what travels into the placement artifact and is +therefore hashed with the case. + +# Notes +Generic: any parsed PGLib case, any bus, and every value is an argument, so a +specific unit can be constructed by hand exactly as an automatic placement rule +would construct it. The identifier is allocated above the current maximum of the +generator table, so it cannot collide with a backbone's nonconsecutive numbering. + +The cost is required to be CONVEX and nondecreasing over the unit's own operating +interval — a negative quadratic coefficient, or a marginal cost that goes +negative inside `[pmin, pmax]`, would make a stage problem either nonconvex in +its relaxed form or paid to generate, and both would be found much later as a +strange dispatch rather than here as a rejected case. +""" +function attach_scheduled_generator!(network::AbstractDict, bus::Integer; + pmax::Real, + cost::AbstractVector, + pmin::Real = 0.0, + qmin::Real = 0.0, + qmax::Real = 0.0, + availability::AbstractVector = Float64[], + tag::AbstractString = "sched") + haskey(network["bus"], string(bus)) || + throw(ArgumentError("bus $bus is not in the network")) + Int(get(network["bus"][string(bus)], "bus_type", 1)) == 4 && + throw(ArgumentError("bus $bus is out of service")) + 0 <= pmin <= pmax || throw(ArgumentError("need 0 <= pmin <= pmax, got [$pmin, $pmax]")) + pmax > 0 || throw(ArgumentError("pmax must be strictly positive, got $pmax")) + qmin <= qmax || throw(ArgumentError("need qmin <= qmax, got [$qmin, $qmax]")) + c = Float64.(collect(cost)) + (!isempty(c) && all(isfinite, c)) || + throw(ArgumentError("cost must be a non-empty vector of finite coefficients")) + length(c) <= 3 || + throw(ArgumentError("only constant, linear and quadratic costs are supported, got $(length(c)) coefficients")) + # Highest order first: the quadratic coefficient is c[end-2] when present. + c2 = length(c) >= 3 ? c[end - 2] : 0.0 + c1 = length(c) >= 2 ? c[end - 1] : 0.0 + c2 >= 0 || throw(ArgumentError("quadratic cost coefficient $c2 is negative, so the cost is not convex")) + for p in (Float64(pmin), Float64(pmax)) + 2 * c2 * p + c1 >= 0 || + throw(ArgumentError("marginal cost $(2 * c2 * p + c1) at pg = $p is negative")) + end + av = Float64.(collect(availability)) + all(x -> isfinite(x) && x >= 0, av) || + throw(ArgumentError("availability multipliers must be finite and nonnegative, got $av")) + + gid = isempty(get(network, "gen", Dict())) ? 1 : + maximum(parse(Int, k) for k in keys(network["gen"])) + 1 + gen = Dict{String,Any}( + "index" => gid, "gen_bus" => Int(bus), + "pg" => 0.0, "qg" => 0.0, + "pmin" => Float64(pmin), "pmax" => Float64(pmax), + "qmin" => Float64(qmin), "qmax" => Float64(qmax), + "vg" => 1.0, "mbase" => Float64(network["baseMVA"]), "gen_status" => 1, + "model" => 2, "ncost" => length(c), "cost" => c, + "startup" => 0.0, "shutdown" => 0.0, + "name" => "$(tag)_gen", "source_id" => Any["gen", gid]) + isempty(av) || (gen[STAGE_AVAILABILITY_KEY] = av) + network["gen"][string(gid)] = gen + + record = Dict{String,Any}( + "tag" => String(tag), "gen" => gid, "bus" => Int(bus), + "pmin" => Float64(pmin), "pmax" => Float64(pmax), + "qmin" => Float64(qmin), "qmax" => Float64(qmax), + "cost" => c, "availability" => av) + return (gen = gid, record = record) +end + +""" + module_digest(backbone_hash, seed, records) -> String + +A deterministic digest over the backbone, the seed and every module parameter. + +# Notes +The generated case is never committed, so the digest is what makes a run +identifiable: two runs agree if and only if they built the same network from the +same backbone bytes. +""" +function module_digest(backbone_hash::AbstractString, seed::Integer, records) + io = IOBuffer() + print(io, backbone_hash, "|", seed) + for r in records + print(io, "|", r["tag"], ":", r["host_bus"], ":", r["mid_bus"], ":", r["remote_bus"]) + for k in sort!(collect(keys(r["spec"]))) + print(io, ",", k, "=", r["spec"][k]) + end + end + return bytes2hex(SHA.sha256(take!(io)))[1:16] +end + +if abspath(PROGRAM_FILE) == @__FILE__ + if "--verify" in ARGS + verify() + else + build() + end +end diff --git a/examples/BatteryStorageOPF/test/runtests.jl b/examples/BatteryStorageOPF/test/runtests.jl new file mode 100644 index 0000000..67b14d2 --- /dev/null +++ b/examples/BatteryStorageOPF/test/runtests.jl @@ -0,0 +1,1044 @@ +# Consolidated regression suite for the JuMP/PowerModels/SDDP battery engine. +# +# One file, grouped by the property being protected. Each group guards something +# that can silently corrupt the science rather than fail loudly: a case artifact +# that stopped being reproducible, a sampler that stopped being reproducible from +# its seed, a frozen support the two engines would read differently, a problem +# specification that stopped being PowerModels', a recourse variable that +# acquired a bound, a strict target that stopped being strict, a nodal price with +# the wrong sign, or an SDDP graph whose two passes stopped being the two +# formulations the study claims they are. +# +# julia --project=. test/runtests.jl + +using Test +using JuMP +using PowerModels +using SDDP +using Ipopt +using Clarabel +using Distributions +using Statistics +using StableRNGs +using SHA +using JSON + +const EXAMPLE = dirname(@__DIR__) +include(joinpath(EXAMPLE, "battery_sddp.jl")) # → battery_powermodels.jl → case, schema +include(joinpath(EXAMPLE, "battery_diagnostics.jl")) +include(joinpath(EXAMPLE, "battery_demand.jl")) +include(joinpath(EXAMPLE, "battery_analysis.jl")) +include(joinpath(EXAMPLE, "build_battery_case.jl")) + +const CASE_DIR = joinpath(EXAMPLE, "case", "pglib_opf_case14_ieee") +const OPT = acp_optimizer() + +@testset "battery storage OPF (JuMP engine)" begin + + # The case is CONSTRUCTED, not committed: the suite builds it from the + # public builder, which also makes the build itself part of what is tested. + case = ensure_case(CASE_DIR) + + # ── The frozen case contract ───────────────────────────────────────────── + @testset "case contract" begin + # Canonical JSON must be a pure function of the value, or hashing an + # artifact proves nothing. + a = Dict("b" => 1, "a" => [1.0, 2.5], "c" => Dict("z" => true, "y" => nothing)) + b = Dict("c" => Dict("y" => nothing, "z" => true), "a" => [1.0, 2.5], "b" => 1) + @test canonical_json(a) == canonical_json(b) + @test JSON.parse(canonical_json(a))["a"] == [1.0, 2.5] + @test_throws ErrorException canonical_json(Dict("x" => NaN)) + + # Every artifact hash, the support digest and the protocol digest + # re-verify on disk. + @test read_battery_case(CASE_DIR; verify = true) isa BatteryCase + for (file, want) in case.manifest["artifacts"] + @test sha256_file(joinpath(CASE_DIR, file)) == want + end + @test support_digest(case.demand) == case.manifest["support"]["sha256"] + @test protocol_digest(case.demand, + Int(case.manifest["protocol"]["num_stages"]), + Int(case.manifest["protocol"]["num_scenarios"])) == + case.manifest["protocol"]["sha256"] + + # Stage duration is a contract, not a default. + @test stage_hours(case) > 0 + @test stage_hours(case) == Float64(case.manifest["stage_hours"]) + + # The support covers exactly the network's loads, in sorted order. + @test case.demand.load_ids == sort!([Int(l["index"]) for (_, l) in case.network["load"]]) + @test issorted(case.demand.load_ids) && allunique(case.demand.load_ids) + validate_support(case.demand) + + # Stage indices outside the frozen horizon FAIL rather than wrap: a + # cyclic reinterpretation of the horizon is how a study silently changes + # which stage is the peak. + @test_throws ArgumentError demand_multipliers(case.demand, horizon(case.demand) + 1, 1) + @test_throws ArgumentError demand_multipliers(case.demand, 1, 0) + + # The demand process preserves each LOAD's power factor exactly. + by_id = Dict(Int(l["index"]) => l for (_, l) in case.network["load"]) + for t in (1, 7, 19), k in 1:num_atoms(case.demand, t) + m = demand_multipliers(case.demand, t, k) + pd, qd = realized_bus_demand(case, t, k) + expect_p = Dict{Int,Float64}(i => 0.0 for i in keys(pd)) + expect_q = Dict{Int,Float64}(i => 0.0 for i in keys(qd)) + for (j, id) in enumerate(case.demand.load_ids) + l = by_id[id] + expect_p[Int(l["load_bus"])] += Float64(l["pd"]) * m[j] + expect_q[Int(l["load_bus"])] += Float64(l["qd"]) * m[j] + end + for i in keys(pd) + @test pd[i] ≈ expect_p[i] atol = 1e-14 + @test qd[i] ≈ expect_q[i] atol = 1e-14 + end + end + for t in 1:horizon(case.demand) + @test sum(atom_probabilities(case.demand, t)) ≈ 1 + end + + # The protocol is reproducible by construction, not stored, and every + # index lies inside its own stage's support. + m1 = scenario_index_matrix(case.demand, 12, 5) + m2 = scenario_index_matrix(case.demand, 12, 5) + @test m1 == m2 + for t in 1:12 + @test all(1 .<= m1[t, :] .<= num_atoms(case.demand, t)) + end + @test_throws ArgumentError scenario_index_matrix(case.demand, + horizon(case.demand) + 1, 2) + end + + # ── The authoring samplers ─────────────────────────────────────────────── + @testset "demand samplers" begin + meta = demand_meta(case.network) + @test meta.load_ids == case.demand.load_ids + @test length(meta.nominal_pd) == meta.num_loads + + # A system-wide discrete law: one scalar per stage, applied to every load. + sys = SystemMultiplier(DiscreteNonParametric([0.9, 1.1], [0.4, 0.6])) + r = validate_sampler(sys, case.network, 6) + @test r.num_loads == meta.num_loads + A, p = finite_support(sys, 1, meta) + @test size(A) == (meta.num_loads, 2) + @test p ≈ [0.4, 0.6] + @test all(A[:, 1] .== 0.9) + + # Independence is a particular joint law, not the representation. + ind = IndependentMultiplier(Uniform(0.8, 1.2)) + ri = validate_sampler(ind, case.network, 4) + @test 0.8 <= ri.multiplier_min && ri.multiplier_max <= 1.2 + one_draw = sample_multiplier_path(ind, meta, 1; seed = 5) + @test length(unique(one_draw)) > 1 # really per-load, not broadcast + + # A regional group law is CORRELATED: loads inside a group move together. + groups = [meta.load_ids[1:3], meta.load_ids[4:end]] + grp = GroupMultiplier(groups, [DiscreteNonParametric([0.8, 1.2], [0.5, 0.5]), + DiscreteNonParametric([1.0], [1.0])]) + v = sample_multiplier_path(grp, meta, 1; seed = 9) + @test length(unique(v[1:3])) == 1 + @test all(v[4:end] .== 1.0) + Ag, pg = finite_support(grp, 1, meta) + @test size(Ag, 2) == 2 + @test sum(pg) ≈ 1 + @test_throws ArgumentError GroupMultiplier([[1, 2], [2, 3]], Normal()) + + # Joint regions express what independent ones cannot: a NEGATIVE + # correlation between regions, which is the whole locational case for + # storage. Two regions, two modes, each stressing exactly one region. + jr = JointRegionMultiplier(groups, [[1.2, 0.8], [0.8, 1.2]], [0.5, 0.5]) + Aj, pj = finite_support(jr, 1, meta) + @test size(Aj, 2) == 2 && sum(pj) ≈ 1 + m1 = Aj[1, :]; m2 = Aj[4, :] + e1 = sum(pj .* m1); e2 = sum(pj .* m2) + cov12 = sum(pj .* (m1 .- e1) .* (m2 .- e2)) + @test cov12 < 0 # unreachable with GroupMultiplier + @test all(all(Aj[1:3, k] .== Aj[1, k]) for k in 1:2) # region moves as one + # Plain numbers throughout, so unlike the group sampler it round-trips. + jb = sampler_from_dict(sampler_to_dict(jr)) + @test finite_support(jb, 1, meta)[1] == Aj + @test finite_support(jb, 1, meta)[2] == pj + @test_throws ArgumentError JointRegionMultiplier(groups, [[1.0, 1.0]], [0.6]) + @test_throws ArgumentError JointRegionMultiplier(groups, [[1.0]], [1.0]) + + # Composition multiplies. + prod = ProductMultiplier(sys, grp) + Ap, pp = finite_support(prod, 1, meta) + @test size(Ap, 2) == 4 + @test sum(pp) ≈ 1 + vp = sample_multiplier_path(prod, meta, 1; seed = 3) + @test all(isfinite, vp) + + # A user callable is validated on every draw. + bad = CallableMultiplier((rng, t, m) -> [1.0]; name = "wrong-length") + @test_throws ErrorException sample_multiplier_path(bad, meta, 1; seed = 1) + good = CallableMultiplier((rng, t, m) -> fill(1.0 + 0.1 * rand(rng), m.num_loads); + name = "jitter") + @test validate_sampler(good, case.network, 3).num_loads == meta.num_loads + + # Stage dependence. + st = StageMultiplier(Dict(1 => DeterministicMultiplier(1.0), 2 => sys); + default = DeterministicMultiplier(0.5)) + @test all(sample_multiplier(st, StableRNG(1), 1, meta) .== 1.0) + @test all(sample_multiplier(st, StableRNG(1), 9, meta) .== 0.5) + + # Round-trip of the samplers that can be serialized. + fin = FiniteMultiplier([0.9, 1.0, 1.1], [0.25, 0.5, 0.25]) + back = sampler_from_dict(sampler_to_dict(fin)) + @test finite_support(back, 1, meta)[2] ≈ [0.25, 0.5, 0.25] + @test_throws ErrorException sampler_from_dict(sampler_to_dict(good)) + end + + # ── Freezing: one support, consumed by both methods ────────────────────── + @testset "finite-support freezing" begin + meta = demand_meta(case.network) + + # An explicitly discrete sampler keeps its support and probabilities. + fin = FiniteMultiplier([0.9, 1.0, 1.1], [0.25, 0.5, 0.25]) + s1 = freeze_demand_support(fin, case.network, 4; seed = 1, method = :exact, + profile = 1.0) + @test num_atoms(s1, 1) == 3 + @test atom_probabilities(s1, 1) ≈ [0.25, 0.5, 0.25] + @test s1.atoms[1][:, 1] == fill(0.9, meta.num_loads) + + # A continuous sampler is discretized transparently and reproducibly. + cont = SystemMultiplier(Uniform(0.9, 1.1)) + s2 = freeze_demand_support(cont, case.network, 3; seed = 7, atoms_per_stage = 5, + method = :empirical, profile = 1.0) + s3 = freeze_demand_support(cont, case.network, 3; seed = 7, atoms_per_stage = 5, + method = :empirical, profile = 1.0) + @test support_digest(s2) == support_digest(s3) + @test num_atoms(s2, 1) == 5 + @test all(atom_probabilities(s2, 1) .≈ 1 / 5) + s4 = freeze_demand_support(cont, case.network, 3; seed = 8, atoms_per_stage = 5, + method = :empirical, profile = 1.0) + @test support_digest(s2) != support_digest(s4) + @test_throws ErrorException freeze_demand_support(cont, case.network, 2; + seed = 1, method = :exact) + + # Exact duplicates merge, and the probabilities they carried are summed. + dup = FiniteMultiplier([1.0, 1.0, 2.0], [0.25, 0.25, 0.5]) + s5 = freeze_demand_support(dup, case.network, 1; seed = 1, method = :exact, + profile = 1.0) + @test num_atoms(s5, 1) == 2 + @test sort(atom_probabilities(s5, 1)) ≈ [0.5, 0.5] + + # The profile is materialized, not stored as a period, and it is + # separable from the multiplier. + prof = diurnal_profile(6; amplitude = 0.1, peak_hour = 3, period = 6) + s6 = freeze_demand_support(fin, case.network, 6; seed = 1, method = :exact, + profile = prof, profile_period = 6) + @test profile_period(s6) == 6 + for t in 1:6 + @test all(s6.profile[:, t] .≈ prof[t]) + @test demand_multipliers(s6, t, 1) ≈ fill(prof[t] * 0.9, meta.num_loads) + end + + # Stage-dependent supports survive freezing with different K per stage. + st = StageMultiplier([FiniteMultiplier([1.0], [1.0]), + FiniteMultiplier([0.8, 1.2], [0.5, 0.5])]) + s7 = freeze_demand_support(st, case.network, 2; seed = 1, method = :exact, + profile = 1.0) + @test num_atoms(s7, 1) == 1 + @test num_atoms(s7, 2) == 2 + + # A support round-trips through the artifacts byte-identically. + tmp = mktempdir() + try + write_battery_case(tmp; name = case.name, network = case.network, + batteries = case.batteries, recourse = case.recourse, + demand = s6, source_version = "test", + protocol_stages = 6, protocol_scenarios = 4) + reread = read_battery_case(tmp) + @test support_digest(reread.demand) == support_digest(s6) + @test reread.demand.atoms == s6.atoms + @test reread.demand.profile == s6.profile + # Rewriting produces identical bytes: the artifact is a pure function + # of the value, which is the whole point of mirroring it. + before = sha256_file(joinpath(tmp, "demand.json")) + write_battery_case(tmp; name = case.name, network = case.network, + batteries = case.batteries, recourse = case.recourse, + demand = s6, source_version = "test", + protocol_stages = 6, protocol_scenarios = 4) + @test sha256_file(joinpath(tmp, "demand.json")) == before + finally + rm(tmp; recursive = true, force = true) + end + end + + # ── Battery placement ──────────────────────────────────────────────────── + @testset "regional demand regime" begin + net = case.network + loads = load_buses(net) + + # Every load bus lands in exactly one region, and a bus that IS a center + # belongs to its own region. + centers = [loads[1], loads[end]] + regs = nearest_bus_regions(net, centers) + @test length(regs) == 2 + @test sort(vcat(regs...)) == sort(loads) + @test centers[1] in regs[1] && centers[2] in regs[2] + @test nearest_bus_regions(net, centers) == regs # deterministic + @test_throws ArgumentError nearest_bus_regions(net, Int[]) + + # R regions cost R+2 atoms, not the 2^R of an independent product. + s = rotating_regime_sampler(net; centers = centers, horizon = 24, + min_probability = 0.0) + meta = demand_meta(net) + A, p = finite_support(s, 19, meta) + @test size(A, 2) == length(centers) + 2 + @test sum(p) ≈ 1 + + # The three things a policy would want to know all move with the stage. + j1 = findfirst(==(regs[1][1]), meta.load_bus) + j2 = findfirst(==(regs[2][1]), meta.load_bus) + stats = map(1:24) do t + At, pt = finite_support(s, t, meta) + m1 = At[j1, :]; m2 = At[j2, :] + e1 = sum(pt .* m1); e2 = sum(pt .* m2) + v1 = sum(pt .* (m1 .- e1) .^ 2); v2 = sum(pt .* (m2 .- e2) .^ 2) + c = sum(pt .* (m1 .- e1) .* (m2 .- e2)) + (mean1 = e1, corr = (v1 > 1e-12 && v2 > 1e-12) ? c / sqrt(v1 * v2) : 0.0) + end + @test maximum(x -> x.mean1, stats) - minimum(x -> x.mean1, stats) > 0.05 + # Two regions is the MINIMUM construction and gives the smallest possible + # rotation: with R regions the stressed one is offset by 1/R of a period, + # so the correlation swing grows with R. Measured 0.09 here against 0.60 + # on the three-region research case, hence a threshold that asserts the + # correlation genuinely moves rather than one calibrated on the big case. + @test maximum(x -> x.corr, stats) - minimum(x -> x.corr, stats) > 0.05 + + # Pruning drops negligible modes, so quiet stages cost fewer atoms than + # the peak — the knob that decides whether SDDP converges affordably. + sp = rotating_regime_sampler(net; centers = centers, horizon = 24, + min_probability = 0.06) + counts = [length(finite_support(sp, t, meta)[2]) for t in 1:24] + @test minimum(counts) < maximum(counts) + @test all(c -> c >= 1, counts) + @test all(sum(finite_support(sp, t, meta)[2]) ≈ 1 for t in 1:24) + + # `spread = 0` removes the rotation: every region is equally likely to be + # the stressed one, and the process degenerates to a temporal one. + flat = rotating_regime_sampler(net; centers = centers, horizon = 24, + spread = 0.0, min_probability = 0.0) + Af, pf = finite_support(flat, 19, meta) + @test pf[2] ≈ pf[3] + + # The manual path: explicit region lists bypass the distance partition. + man = rotating_regime_sampler(net; groups = [loads[1:2], loads[3:end]], + horizon = 4, min_probability = 0.0) + @test size(finite_support(man, 1, meta)[1], 2) == 4 + @test_throws ArgumentError rotating_regime_sampler(net; groups = [loads], + horizon = 4) + end + + @testset "battery placement" begin + net = case.network + loads = load_buses(net) + @test issorted(loads) && allunique(loads) + + # Explicit placement is honoured; an ineligible identifier is refused. + b1, r1 = select_battery_buses(net, ExplicitPlacement([loads[1], loads[3]])) + @test b1 == sort([loads[1], loads[3]]) + @test r1["strategy"] == "explicit" + @test_throws ErrorException select_battery_buses(net, ExplicitPlacement([10_000])) + dup = ExplicitPlacement([loads[1], loads[1]]) + @test_throws ErrorException select_battery_buses(net, dup) + + # A seeded draw is reproducible and depends on the seed. + s1, _ = select_battery_buses(net, SampledPlacement(3; seed = 11)) + s2, _ = select_battery_buses(net, SampledPlacement(3; seed = 11)) + @test s1 == s2 + @test length(s1) == 3 && allunique(s1) + # Different seeds give different draws. Not every PAIR of seeds must + # differ — with 11 candidates and 3 picks a collision is ordinary — so + # the property asserted is that the seed is a real input. + draws = unique([select_battery_buses(net, SampledPlacement(3; seed = s))[1] + for s in 1:12]) + @test length(draws) > 1 + @test_throws ArgumentError select_battery_buses(net, + SampledPlacement(length(loads) + 1; seed = 1)) + + # Weights are recorded, and a weight that concentrates all mass picks + # the intended bus. + load_at = nominal_load_at_bus(net) + w, rw = select_battery_buses(net, SampledPlacement(1; seed = 3, + weight = b -> b == loads[2] ? 1.0 : 0.0)) + @test w == [loads[2]] + @test rw["strategy"] == "weighted" + @test length(rw["weights"]) == length(loads) + @test_throws ErrorException select_battery_buses(net, + SampledPlacement(1; seed = 3, + weight = b -> -1.0)) + + # An eligibility predicate narrows the pool; a callable is validated + # exactly like any other strategy's output. + big = eligible_buses(net; eligible = b -> Int(b["index"]) in loads[1:2]) + @test big == sort(loads[1:2]) + cb, rc = select_battery_buses(net, CallablePlacement( + (cands, meta) -> [first(cands)]; name = "first")) + @test cb == [first(loads)] + @test startswith(rc["strategy"], "callable:") + @test_throws ErrorException select_battery_buses(net, CallablePlacement( + (cands, meta) -> [10_000])) + + # Ratings, their validation, and a SAMPLED capacity expressed as a + # callable closing over a distribution. + fleet, crec = battery_fleet(net, b1; power = 0.5, energy_hours = 3.0, + self_discharge = 0.99, throughput_cost = 1.0, + initial_fraction = 0.25) + @test length(fleet) == 2 + @test all(f -> f.energy_max ≈ 1.5, fleet) + @test all(f -> f.energy_initial ≈ 0.375, fleet) + @test [f.bus for f in fleet] == b1 + @test [f.index for f in fleet] == [1, 2] + @test length(crec["power_pu"]) == 2 + rng = StableRNG(4) + sampled, _ = battery_fleet(net, b1; power = _ -> rand(rng, Uniform(0.2, 0.4)), + energy_hours = 2.0) + @test all(f -> 0.2 <= f.charge_max <= 0.4, sampled) + @test_throws ErrorException battery_fleet(net, b1; power = -1.0, energy_hours = 2.0) + @test_throws ErrorException battery_fleet(net, b1; power = 1.0, energy_hours = 2.0, + charge_efficiency = 1.5) + end + + # ── Battery physics, independent of any optimizer ──────────────────────── + @testset "battery dynamics" begin + Δt = stage_hours(case) + for b in case.batteries, e in (b.energy_min, b.energy_initial, b.energy_max) + lo, hi = reachable_interval(b, e, Δt) + @test b.energy_min - 1e-12 <= lo <= hi <= b.energy_max + 1e-12 + for frac in (0.0, 0.5, 1.0) + tgt = lo + frac * (hi - lo) + pch, pdis = dispatch_for_target(b, e, tgt, Δt) + @test pch >= -1e-12 && pdis >= -1e-12 + @test pch <= b.charge_max + 1e-9 + @test pdis <= b.discharge_max + 1e-9 + @test min(pch, pdis) <= 1e-12 # never both at once + @test b.self_discharge * e + b.charge_efficiency * Δt * pch - + (Δt / b.discharge_efficiency) * pdis ≈ tgt atol = 1e-10 + end + end + end + + # ── Provenance: the network formulation is PowerModels', not ours ──────── + @testset "external-model provenance" begin + pm_acp = battery_stage_model(case, PowerModels.ACPPowerModel; + optimizer = OPT, stage = 1, atom = 2, mode = :none) + @test pm_acp isa PowerModels.ACPPowerModel + @test typeof(pm_acp) === PowerModels.ACPPowerModel + assert_powermodels_provenance(pm_acp, PowerModels.ACPPowerModel) + @test_throws ErrorException assert_powermodels_provenance(pm_acp, + PowerModels.SOCWRConicPowerModel) + + pm_soc = battery_stage_model(case, PowerModels.SOCWRConicPowerModel; + stage = 1, atom = 2, mode = :none) + @test typeof(pm_soc) === PowerModels.SOCWRConicPowerModel + assert_powermodels_provenance(pm_soc, PowerModels.SOCWRConicPowerModel) + + # No network equation is written by hand in the problem specification or + # in the diagnostics. Scanning for trigonometry and for the W-space + # lifted variables catches a reimplementation of either formulation; the + # case builder and the residual checker are out of scope because neither + # builds an optimization model. + for f in ("battery_powermodels.jl", "battery_sddp.jl", "battery_diagnostics.jl") + src = read(joinpath(EXAMPLE, f), String) + code = join([l for l in split(src, '\n') if !startswith(strip(l), "#")], '\n') + for pat in ("cos(", "sin(", "atan(", "tan(") + @test !occursin(pat, code) + end + for pat in ("var(pm)[:w]", "var(pm)[:wr]", "var(pm)[:wi]") + @test !occursin(pat, code) + end + end + end + + # ── Base network: the specification reduces to ordinary PowerModels OPF ── + @testset "base network" begin + # Find a stage/atom whose total multiplier is exactly 1, where the + # battery layer's demand deviation is identically zero. + t0, a0 = 0, 0 + for t in 1:horizon(case.demand), k in 1:num_atoms(case.demand, t) + if all(demand_multipliers(case.demand, t, k) .≈ 1.0) + t0, a0 = t, k + break + end + end + @test t0 > 0 + pm = battery_stage_model(case, PowerModels.ACPPowerModel; + optimizer = OPT, stage = t0, atom = a0, mode = :none) + JuMP.set_silent(pm.model) + JuMP.optimize!(pm.model) + ours = extract_stage_solution(pm) + stock = PowerModels.solve_opf(deepcopy(case.network), PowerModels.ACPPowerModel, OPT) + + @test ours.solved + @test stock["termination_status"] == JuMP.LOCALLY_SOLVED + # The physical dispatch is the same to solver tolerance. + # Active power carries the objective and is determined to 1e-6 pu. + # Reactive power carries NO objective coefficient at all: it is pinned + # only through the balance, and a direction the objective is flat in is + # determined by an interior-point solve to whatever its own stopping rule + # buys. The two sides here are two differently SCALED NLPs — ours divides + # the objective by the cost scale, PowerModels' does not — so Ipopt's own + # gradient-based scaling differs and the two iterates stop at slightly + # different points of the same solution. Measured worst disagreement on + # this case: 1.1e-6 pu = 1.1e-4 MVAr on a 100 MVA base, against 1.3e-2 pu + # of reactive output. The cost and every active quantity agree at 1e-6, + # which is what the comparison is for; the reactive tolerance is set to + # the level the quantity is actually determined at, and the aggregate is + # reported beside it so a real redistribution between generators sharing + # a bus would still be caught. + stock_qg_bus = Dict{Int,Float64}(i => 0.0 for i in keys(ours.qg_bus)) + for (k, g) in stock["solution"]["gen"] + i = parse(Int, k) + @test ours.pg[i] ≈ g["pg"] atol = 1e-6 + @test ours.qg[i] ≈ g["qg"] atol = 1e-5 + stock_qg_bus[Int(case.network["gen"][k]["gen_bus"])] += g["qg"] + end + for (i, q) in stock_qg_bus + @test ours.qg_bus[i] ≈ q atol = 1e-5 + end + for (k, b) in stock["solution"]["bus"] + i = parse(Int, k) + @test ours.vm[i] ≈ b["vm"] atol = 1e-6 + @test ours.va[i] ≈ b["va"] atol = 1e-6 + end + # The generation cost is the stock objective. The two OBJECTIVES differ + # by the recourse variables' interior-point barrier slack — an optimizer + # parks a nonnegative variable a tolerance below its zero bound, and a + # positively priced variable there lowers the objective by a + # near-constant amount. That is a solver artefact, not a model + # difference, so the comparison is made on the cost component the two + # models actually share. + @test ours.cost_generation ≈ stock["objective"] atol = 1e-5 + @test abs(ours.objective - ours.cost_stage) < 1e-8 + end + + # ── A generator that exists in some stages and not others ──────────────── + # The failure this guards against is silence: a schedule that is written into + # a case, hashed, mirrored, and then ignored by the stage builder would give + # every consumer a generator that is always available while every record says + # otherwise. + @testset "per-stage generator availability" begin + # The convention is OPTIONAL and additive: the frozen case carries no + # schedule, so nothing is scaled and the network is untouched. + net0 = deepcopy(case.network) + @test apply_stage_availability!(net0, 1) == 0 + @test canonical_json(net0) == canonical_json(case.network) + + # ── The construction helper rejects what it cannot model ────────────── + src = acquire_pglib_case("pglib_opf_case14_ieee") + host = 3 + @test_throws ArgumentError attach_scheduled_generator!(src.network, 10_000; + pmax = 1.0, cost = [1.0, 0.0]) + @test_throws ArgumentError attach_scheduled_generator!(src.network, host; + pmax = -1.0, cost = [1.0, 0.0]) + # A concave cost would make the conic stage problem a relaxation of + # nothing, and a negative marginal cost pays the case to generate. + @test_throws ArgumentError attach_scheduled_generator!(src.network, host; + pmax = 1.0, cost = [-1.0, 5.0, 0.0]) + @test_throws ArgumentError attach_scheduled_generator!(src.network, host; + pmax = 1.0, cost = [1.0, -5.0, 0.0]) + @test_throws ArgumentError attach_scheduled_generator!(src.network, host; + pmax = 1.0, cost = [1.0, 0.0], + availability = [1.0, -0.5]) + ngen0 = length(src.network["gen"]) + + # A quadratic unit at a load bus, available in stage 1 and absent in 2. + PMAX, C2, C1 = 0.35, 40.0, 900.0 + acq = attach_scheduled_generator!(src.network, host; + pmax = PMAX, cost = [C2, C1, 0.0], + availability = [1.0, 0.0], tag = "acq") + @test length(src.network["gen"]) == ngen0 + 1 + @test !haskey(src.network["gen"], string(acq.gen + 1)) + @test src.network["gen"][string(acq.gen)][STAGE_AVAILABILITY_KEY] == [1.0, 0.0] + # A malformed schedule is rejected while the case is still data. + @test validate_network(src.network).scheduled_generators == 1 + bad = deepcopy(src.network) + bad["gen"][string(acq.gen)][STAGE_AVAILABILITY_KEY] = Float64[] + @test_throws ErrorException validate_network(bad) + + # ── Scaling is per stage, and covers reactive as well as active ─────── + two = deepcopy(src.network) + two["gen"][string(acq.gen)]["qmin"] = -0.2 + two["gen"][string(acq.gen)]["qmax"] = 0.4 + s1 = deepcopy(two); s2 = deepcopy(two) + @test apply_stage_availability!(s1, 1) == 1 + @test apply_stage_availability!(s2, 2) == 1 + @test s1["gen"][string(acq.gen)]["pmax"] == PMAX + @test s1["gen"][string(acq.gen)]["qmax"] == 0.4 + @test s2["gen"][string(acq.gen)]["pmax"] == 0.0 + @test s2["gen"][string(acq.gen)]["pmin"] == 0.0 + @test s2["gen"][string(acq.gen)]["qmin"] == 0.0 + @test s2["gen"][string(acq.gen)]["qmax"] == 0.0 + # Every other generator is untouched by either stage. + for k in keys(two["gen"]) + k == string(acq.gen) && continue + @test s1["gen"][k]["pmax"] == two["gen"][k]["pmax"] + @test s2["gen"][k]["pmax"] == two["gen"][k]["pmax"] + end + # A stage the schedule does not cover is an error, never the last entry. + @test_throws ErrorException apply_stage_availability!(deepcopy(two), 3) + + # ── The schedule survives the frozen case, and the digest covers it ─── + fleet, crec = battery_fleet(src.network, [host]; + power = 0.10, energy_hours = 4.0, + self_discharge = 0.999, throughput_cost = 1.0, + initial_fraction = 0.5, reserve_fraction = 0.05) + support = freeze_demand_support(FiniteMultiplier([1.0], [1.0]), src.network, 2; + seed = 20260810, method = :exact, + profile = 1.0, stage_hours = 1.0) + dir = mktempdir() + sched_case = build_case(src; dir = dir, batteries = fleet, support = support, + placement = Dict{String,Any}("acquisition" => acq.record), + protocol_stages = 2, protocol_scenarios = 4, quiet = true) + @test sched_case.network["gen"][string(acq.gen)][STAGE_AVAILABILITY_KEY] == [1.0, 0.0] + # Same case with a different schedule is a DIFFERENT network artifact, so + # a run can never mistake one for the other. + alt = acquire_pglib_case("pglib_opf_case14_ieee") + attach_scheduled_generator!(alt.network, host; pmax = PMAX, cost = [C2, C1, 0.0], + availability = [1.0, 1.0], tag = "acq") + dir2 = mktempdir() + alt_case = build_case(alt; dir = dir2, batteries = fleet, support = support, + protocol_stages = 2, protocol_scenarios = 4, quiet = true) + @test sched_case.manifest["artifacts"]["network.json"] != + alt_case.manifest["artifacts"]["network.json"] + + # ── What the stage models actually contain ─────────────────────────── + bounds = Float64[] + for t in 1:2 + pm = battery_stage_model(sched_case, PowerModels.ACPPowerModel; + optimizer = OPT, stage = t, atom = 1, mode = :none) + push!(bounds, JuMP.upper_bound(PowerModels.var(pm, :pg, acq.gen))) + end + @test bounds == [PMAX, 0.0] + + # And what they DISPATCH. The unit is priced above the case's own + # marginal cost at zero output, so it earns its place only where the + # network is short: what is asserted is the stage-2 zero, which is the + # property the schedule exists for, and that the cost decomposition + # still adds up on both stages. + for t in 1:2 + s = base_feasibility(sched_case, PowerModels.ACPPowerModel; stage = t, atom = 1) + @test s.solved + @test abs(s.objective - s.cost_stage) < 1e-8 + if t == 2 + @test abs(s.pg[acq.gen]) <= 1e-8 + end + end + # The always-available twin is the null control for that zero: same unit, + # same price, same bus, schedule [1, 1] — so a stage-2 dispatch that is + # zero for any reason other than the schedule would be zero here too. + avail2 = base_feasibility(alt_case, PowerModels.ACPPowerModel; stage = 2, atom = 1) + @test avail2.solved + @test JuMP.upper_bound(PowerModels.var( + battery_stage_model(alt_case, PowerModels.ACPPowerModel; + optimizer = OPT, stage = 2, atom = 1, mode = :none), + :pg, acq.gen)) == PMAX + end + + # ── Nodal prices: the SIGN is derived, not guessed ─────────────────────── + @testset "nodal prices" begin + # ∂(stage cost)/∂(demand at bus i) must equal the reported active price. + # The demand is moved through the battery layer's own deviation variable, + # which is exactly how a demand realization enters, so the finite + # difference measures the same derivative the price claims to be. + base = base_feasibility(case, PowerModels.ACPPowerModel; stage = 3, atom = 2) + @test base.solved + @test !isempty(base.price_active) + i0 = argmax(Dict(i => v for (i, v) in base.pd)) # a real load bus + h = 1e-4 + vals = Float64[] + for δ in (+h, -h) + pm = battery_stage_model(case, PowerModels.ACPPowerModel; + optimizer = OPT, stage = 3, atom = 2, mode = :none) + bat = pm.ext[:battery] + JuMP.fix(bat[:dpd][i0], JuMP.fix_value(bat[:dpd][i0]) + δ; force = true) + JuMP.set_silent(pm.model) + JuMP.optimize!(pm.model) + push!(vals, extract_stage_solution(pm).cost_generation) + end + @test (vals[1] - vals[2]) / (2h) ≈ base.price_active[i0] rtol = 1e-3 + # A load bus prices energy positively: serving more demand costs more. + @test base.price_active[i0] > 0 + end + + # ── Admissibility: every demand atom is served without recourse ────────── + @testset "demand admissibility" begin + worst = 0.0 + for t in 1:horizon(case.demand), a in 1:num_atoms(case.demand, t) + b = base_feasibility(case, PowerModels.ACPPowerModel; stage = t, atom = a) + @test b.solved + worst = max(worst, b.worst_recourse) + end + # The base ACP problem is feasible at every atom with no recourse: this + # is the admissibility precondition of the strict-target construction. + @test worst < 1e-6 + end + + # ── Recourse structure ─────────────────────────────────────────────────── + @testset "recourse structure" begin + ein = Dict(b.index => b.energy_initial for b in case.batteries) + pm = battery_stage_model(case, PowerModels.ACPPowerModel; + optimizer = OPT, stage = 5, atom = 2, mode = :strict, + state_in = ein, target = ein) + bat = pm.ext[:battery] + d, s = bat[:d], bat[:s] + for i in bat[:buses] + @test JuMP.has_lower_bound(d[i]) && JuMP.lower_bound(d[i]) == 0.0 + @test JuMP.has_lower_bound(s[i]) && JuMP.lower_bound(s[i]) == 0.0 + @test !JuMP.has_upper_bound(d[i]) && !JuMP.has_upper_bound(s[i]) + @test !JuMP.is_fixed(d[i]) && !JuMP.is_fixed(s[i]) + end + i0 = first(case.batteries).bus + obj = JuMP.objective_function(pm.model) + # The objective the SOLVER sees is the PHYSICAL stage cost, so the + # recourse coefficients are the case's own prices, bit for bit. An exact + # comparison is the point: anything else means a rescaling crept back in + # between the case and the model. + @test JuMP.coefficient(obj, d[i0]) === case.recourse.deficit + @test JuMP.coefficient(obj, s[i0]) === case.recourse.surplus + @test case.recourse.deficit > 0 && case.recourse.surplus > 0 + + # Neither recourse variable touches the battery: not the transition, + # not the strict target equality. There is no target slack. + k0 = first(case.batteries).index + for con in (bat[:transition][k0], bat[:target_con][k0], bat[:energy_in_con][k0]) + f = JuMP.constraint_object(con).func + @test JuMP.coefficient(f, d[i0]) == 0.0 + @test JuMP.coefficient(f, s[i0]) == 0.0 + end + # The recourse pair enters exactly one balance row, with opposite signs. + rows = 0 + for (F, S) in JuMP.list_of_constraint_types(pm.model) + F <: Union{JuMP.AffExpr,JuMP.QuadExpr} || continue + for c in JuMP.all_constraints(pm.model, F, S) + f = JuMP.constraint_object(c).func + cd, cs = JuMP.coefficient(f, d[i0]), JuMP.coefficient(f, s[i0]) + (cd == 0 && cs == 0) && continue + rows += 1 + @test cd * cs < 0 + end + end + @test rows == 1 + end + + # ── Physical objective units ───────────────────────────────────────────── + # There is ONE unit system: the objective units of the underlying PGLib + # case. Nothing between the frozen case and the solver rescales a cost, and + # nothing on the way back converts one. What has to be protected is exactly + # that: a case that records no scale, a model whose generator polynomial is + # the case's own coefficient for coefficient, and a reported objective that + # is the solver's own number rather than a converted one. + @testset "physical objective units" begin + # A case carries no objective scale, in memory or on disk, because there + # is nothing to record: a second recorded unit is how two engines end up + # reporting costs that differ by a constant ratio while both look right. + @test !haskey(case.manifest, "cost_scale") + @test !haskey(case.manifest["units"], "cost_normalization") + tmp = mktempdir() + try + m = write_battery_case(tmp; name = case.name, network = case.network, + batteries = case.batteries, recourse = case.recourse, + demand = case.demand, source_version = "test", + protocol_stages = 4, protocol_scenarios = 2) + @test !haskey(m, "cost_scale") + @test !haskey(m["units"], "cost_normalization") + @test read_battery_case(tmp) isa BatteryCase + finally + rm(tmp; recursive = true, force = true) + end + + ein = Dict(b.index => b.energy_initial for b in case.batteries) + Δt = stage_hours(case) + tgt = Dict{Int,Float64}() + for b in case.batteries + lo, hi = reachable_interval(b, ein[b.index], Δt) + tgt[b.index] = lo + 0.6 * (hi - lo) + end + pm = battery_stage_model(case, PowerModels.ACPPowerModel; + optimizer = OPT, stage = 11, atom = 2, mode = :strict, + state_in = ein, target = tgt) + + # The cost polynomial PowerModels built its objective from is the case's + # own, BIT for bit — not equal to a tolerance, which a rescale-and-undo + # round trip would also pass. The case's network is unmoved by building + # a model, so a stock `solve_opf` on it stays a valid external reference. + ncoef = 0 + for (_, g) in case.network["gen"] + i = Int(g["index"]) + phys = Float64.(collect(g["cost"])) # a JSON-parsed Vector{Any} + got = Float64.(collect(PowerModels.ref(pm, :gen, i)["cost"])) + @test length(got) == length(phys) + for (a, b) in zip(got, phys) + @test a === b + ncoef += 1 + end + end + @test ncoef > 0 # the loop actually compared something + + JuMP.set_silent(pm.model); JuMP.optimize!(pm.model) + sol = extract_stage_solution(pm) + @test sol.solved + # The reported objective is the solver's own value, unconverted. + @test sol.objective === JuMP.objective_value(pm.model) + # And the generation component is the PHYSICAL polynomial at the reported + # dispatch, evaluated here from `case.network` rather than from `ref`. + phys_gen = sum(_polynomial_cost(g, sol.pg[Int(g["index"])]) + for (_, g) in case.network["gen"]) + @test sol.cost_generation ≈ phys_gen rtol = 1e-9 + # Recourse is priced at the case's prices, so a stage cost assembled from + # the case's own numbers reproduces the objective the solver minimized. + @test sol.cost_stage ≈ sol.objective rtol = 1e-7 + end + + # ── The strict formulation ─────────────────────────────────────────────── + @testset "strict targets" begin + Δt = stage_hours(case) + ein = Dict(b.index => b.energy_initial for b in case.batteries) + # Dynamic reachability does NOT imply network deliverability: at the + # demand peak, charging every battery at its rating can exceed what a + # small network delivers, and the uncapped deficit injection supplies the + # difference. That is the recourse doing its job, and it is why a + # selected policy is required to leave both recourse variables at zero + # rather than merely to exist. + peak = argmax([sum(values(realized_bus_demand(case, t, num_atoms(case.demand, t))[1])) + for t in 1:24]) + for frac in (0.0, 0.45, 1.0 - 1e-3) + tgt = Dict{Int,Float64}() + for b in case.batteries + lo, hi = reachable_interval(b, ein[b.index], Δt) + tgt[b.index] = lo + frac * (hi - lo) + end + sol = solve_strict_stage(case, PowerModels.ACPPowerModel; + stage = peak, atom = num_atoms(case.demand, peak), + energy_in = ein, target = tgt, optimizer = OPT) + @test sol.solved + for b in case.batteries + # The target is met EXACTLY: a strict equality, no slack, in + # every case — including one that needs recourse. + @test sol.energy_out[b.index] ≈ tgt[b.index] atol = 1e-9 + @test isfinite(sol.target_dual[b.index]) + @test min(sol.p_ch[b.index], sol.p_dis[b.index]) < 1e-6 + end + # The physics of the reported solution, recomputed independently. + r = physical_residuals(case.network, case.batteries, Δt, sol) + @test r.branch_flow < 1e-6 + @test r.active_balance < 1e-8 + @test r.reactive_balance < 1e-8 + @test r.transition < 1e-9 + @test r.thermal < 1e-6 + @test r.voltage < 1e-6 + end + + # The multiplier is the derivative of the solved value in the target. + tgt = Dict{Int,Float64}() + for b in case.batteries + lo, hi = reachable_interval(b, ein[b.index], Δt) + tgt[b.index] = lo + 0.45 * (hi - lo) + end + base = solve_strict_stage(case, PowerModels.ACPPowerModel; + stage = 17, atom = 3, energy_in = ein, + target = tgt, optimizer = OPT) + k = first(case.batteries).index + h = 1e-5 + up = copy(tgt); up[k] += h + dn = copy(tgt); dn[k] -= h + vp = solve_strict_stage(case, PowerModels.ACPPowerModel; stage = 17, atom = 3, + energy_in = ein, target = up, optimizer = OPT).objective + vm_ = solve_strict_stage(case, PowerModels.ACPPowerModel; stage = 17, atom = 3, + energy_in = ein, target = dn, optimizer = OPT).objective + @test (vp - vm_) / (2h) ≈ base.target_dual[k] rtol = 1e-3 + end + + # ── The diagnostic toolkit ─────────────────────────────────────────────── + @testset "diagnostics" begin + Δt = stage_hours(case) + + # B1: sampled incoming energies land inside their own bounds, and the + # draw is reproducible from the seed. + e1 = sample_incoming_energy(case; kind = :uniform, seed = 5, batch = 3) + e2 = sample_incoming_energy(case; kind = :uniform, seed = 5, batch = 3) + @test e1 == e2 + @test length(e1) == 3 + for e in e1, b in case.batteries + @test b.energy_min <= e[b.index] <= b.energy_max + end + efix = sample_incoming_energy(case; kind = :fixed, level = 0.5)[1] + @test all(b -> efix[b.index] ≈ 0.5 * b.energy_max, case.batteries) + @test_throws ErrorException sample_incoming_energy(case; kind = :explicit, + explicit = [Dict(b.index => 10.0 * b.energy_max for b in case.batteries)]) + + # B2: the targetless probe is myopic — nothing prices what it leaves + # behind — and its physics check out. + p = targetless_probe(case, PowerModels.ACPPowerModel; + energy_in = efix, stage = 19, atom = num_atoms(case.demand, 19)) + @test p.solved + @test worst_recourse(p) < 1e-6 + @test maximum(values(p.simultaneous)) < 1e-6 + @test p.residuals.active_balance < 1e-8 + @test p.residuals.transition < 1e-9 + @test all(b -> p.energy_out[b.index] <= efix[b.index] + 1e-6, case.batteries) + @test !isempty(p.energy_in_dual) + + # A `:free` model with every battery pinned IS the strict stage problem. + tgt = Dict(b.index => 0.5 * b.energy_max for b in case.batteries) + pinned = targetless_probe(case, PowerModels.ACPPowerModel; energy_in = efix, + stage = 19, atom = 3, pins = tgt) + strict = solve_strict_stage(case, PowerModels.ACPPowerModel; stage = 19, atom = 3, + energy_in = efix, target = tgt, optimizer = OPT) + @test pinned.cost_stage ≈ strict.cost_stage atol = 1e-8 + for b in case.batteries + @test pinned.pin_dual[b.index] ≈ strict.target_dual[b.index] atol = 1e-6 + end + @test_throws ArgumentError battery_stage_model(case, PowerModels.ACPPowerModel; + stage = 1, atom = 1, mode = :free, + target = tgt) + + # B3: the value curve, its multipliers and the finite-difference check. + b1 = first(case.batteries) + lo, hi = reachable_interval(b1, efix[b1.index], Δt) + curve = energy_value_curve(case, PowerModels.ACPPowerModel; battery = b1.index, + energy_in = efix, stage = 19, atom = 3, + grid = collect(range(lo, hi; length = 7))) + @test all(curve.solved) + @test curve.endpoint[1] + @test curve.endpoint[end] + smooth = [i for i in 2:6 if !curve.nonsmooth[i]] + @test !isempty(smooth) + @test all(i -> curve.fd_error[i] < 5e-3, smooth) + # Convexity in the outgoing energy: the value curve's slopes increase. + slopes = diff(curve.value) ./ diff(curve.energy) + @test all(diff(slopes) .> -1e-6) + # A target outside the reachable interval is reported, never solved. + wide = energy_value_curve(case, PowerModels.ACPPowerModel; battery = b1.index, + energy_in = efix, stage = 19, atom = 3, + grid = [hi + 1.0]) + @test !wide.reachable[1] + @test !wide.solved[1] + + cmp = compare_value_curves(case; battery = b1.index, energy_in = efix, + stage = 19, atom = 3, + grid = collect(range(lo, hi; length = 7))) + @test length(cmp.interior) >= 1 + @test isfinite(cmp.max_abs_dlambda) + + # B4: the deterministic equivalent is a horizon solved at once, and its + # cost is the sum of its stages'. + proto = scenario_index_matrix(case.demand, 6, 3) + de = deterministic_equivalent(case, proto[:, 1]) + @test de.solved + @test de.total_cost ≈ sum(de.stage_cost) atol = 1e-8 + @test de.worst_deficit < 1e-6 && de.worst_surplus < 1e-6 + # The state really propagates across stages. + for t in 2:de.horizon, b in case.batteries + @test de.stages[t].energy_in[b.index] ≈ de.stages[t - 1].energy_out[b.index] atol = 1e-8 + end + for r in de.residuals + @test r.active_balance < 1e-8 + @test r.transition < 1e-9 + @test r.branch_flow < 1e-6 + end + # Perfect foresight is at most as expensive as any nonanticipative + # decision on the SAME path: pinning the batteries to any admissible + # trajectory cannot beat optimizing them. + hold_cost = 0.0 + e = Dict(b.index => b.energy_initial for b in case.batteries) + for t in 1:6 + tgt_t = Dict(b.index => b.self_discharge * e[b.index] for b in case.batteries) + s = solve_strict_stage(case, PowerModels.ACPPowerModel; stage = t, + atom = proto[t, 1], energy_in = e, target = tgt_t, + optimizer = OPT) + hold_cost += s.cost_stage + e = copy(tgt_t) + end + @test de.total_cost <= hold_cost + 1e-6 + + # B5: the panel keeps every requested identifier and fails closed. + panel = perfect_foresight_panel(case, proto) + @test panel.complete + @test panel.num_solved == 3 + @test [r.scenario for r in panel.rows] == [1, 2, 3] + @test panel.mean ≈ mean([r.cost for r in panel.rows]) + sub = perfect_foresight_panel(case, proto; ids = [2]) + @test sub.rows[1].scenario == 2 + @test sub.rows[1].cost ≈ panel.rows[2].cost rtol = 1e-8 + @test_throws ArgumentError perfect_foresight_panel(case, proto; ids = [99]) + + pd = paired_difference([1.0, 2.0, 3.0], [1.5, 1.5, 1.5]) + @test pd.n == 3 + @test pd.mean ≈ 0.5 + @test pd.wins == 1 + end + + # ── Analysis helpers speak the shared schema ───────────────────────────── + @testset "analysis" begin + proto = scenario_index_matrix(case.demand, 4, 2) + de = deterministic_equivalent(case, proto[:, 1]) + rec = SolutionRecorder() + record_trajectory!(rec, de, case; scenario = 1) + df = solution_frame(rec) + @test all(in(SOLUTION_CLASSES), unique(df.class)) + @test nrow(df) > 0 + wide = pivot_class(df, "energy_out"; scenario = 1) + @test nrow(wide) == 4 + @test Symbol(string(first(case.batteries).index)) in propertynames(wide) + + ct = stage_cost_table(de) + @test nrow(ct) == 4 + @test ct.cumulative[end] ≈ de.total_cost atol = 1e-8 + bt = battery_table(de, case) + @test nrow(bt) == 4 * length(case.batteries) + @test maximum(bt.simultaneous) < 1e-6 + pt = price_table(de, case) + @test nrow(pt) == 4 * length(case.network["bus"]) + + @test competerank_desc([3.0, 1.0, 2.0]) == [1, 3, 2] + @test competerank_desc([1.0, 1.0, 2.0]) == [2, 2, 1] + + # A round-trip through the solution file preserves every record. + tmp = mktempdir() + try + path = write_solution(joinpath(tmp, "sol.csv"), rec) + back = read_solution(path) + @test length(back) == length(rec.rows) + @test nrow(solution_frame(path)) == nrow(df) + finally + rm(tmp; recursive = true, force = true) + end + end + + # ── Stock SDDP over the shared specification ───────────────────────────── + @testset "SDDP construction" begin + trained = train_battery_sddp(case; num_stages = 2, iteration_limit = 3) + # Both passes really are the formulations the study claims. + assert_graph_provenance(trained.backward, PowerModels.SOCWRConicPowerModel) + assert_graph_provenance(trained.forward, PowerModels.ACPPowerModel) + # Battery energy is a genuine SDDP state. + node = trained.forward.nodes[1] + @test length(node.states) == length(case.batteries) + # Stock cuts were created. + ncuts = sum(length(n.bellman_function.global_theta.cuts) for (_, n) in trained.backward.nodes) + @test ncuts > 0 + @test isfinite(trained.bound) + # The graph refuses a horizon the frozen support does not cover. + @test_throws ArgumentError battery_policy_graph(case, PowerModels.ACPPowerModel; + num_stages = horizon(case.demand) + 1, + optimizer = OPT) + + ids = [b.index for b in case.batteries] + sims = simulate_battery_sddp(trained, 3; ids = ids) + @test length(sims) == 3 + for path in sims + @test length(path) == 2 + # The outgoing state of stage 1 is the incoming state of stage 2. + @test path[1][:energy_out] ≈ path[2][:energy_in] atol = 1e-8 + for t in 1:2 + @test path[t][:deficit] < 1e-5 + @test path[t][:surplus] < 1e-5 + @test isfinite(path[t][:stage_objective]) + end + end + end +end diff --git a/examples/HydroPowerModels/LocalPreferences.toml b/examples/HydroPowerModels/LocalPreferences.toml deleted file mode 100644 index a956f6c..0000000 --- a/examples/HydroPowerModels/LocalPreferences.toml +++ /dev/null @@ -1,6 +0,0 @@ -# Use pip instead of uv as the pip backend for CondaPkg -# This is needed because uv requires libstdcxx-ng >=13, which is not available on this HPC system -# The environment variable JULIA_CONDAPKG_PIP_BACKEND=pip also works - -[CondaPkg] -pip_backend = "pip" diff --git a/examples/HydroPowerModels/Project.toml b/examples/HydroPowerModels/Project.toml index 135292b..f7083dc 100644 --- a/examples/HydroPowerModels/Project.toml +++ b/examples/HydroPowerModels/Project.toml @@ -1,12 +1,15 @@ [deps] +StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3" CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b" CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" +ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" Dates = "ade2ca70-3891-5945-98fb-dc099432e06a" DecisionRules = "47937410-f832-486f-8300-12c95b225dfc" DiffOpt = "930fe3bc-9c6b-11ea-2d94-6184641e85e7" Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c" +Functors = "d9f16b24-f501-4c13-a1f2-28368ffc5196" Ipopt = "b6b21f68-93f8-5de0-b562-5493be1d77c9" JLD2 = "033835bb-8acc-5ee8-8aae-3f567f8a3819" JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" @@ -17,6 +20,7 @@ MadNLP = "2621e9c9-9eb4-46b1-8089-e8c72242dfb6" MadNLPGPU = "d72a61cc-809d-412f-99be-fd81f4b8a598" Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +SHA = "ea8e919c-243c-51af-8825-aaa63cd721ce" Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" Wandb = "ad70616a-06c9-5745-b1f1-6a5f42545108" diff --git a/examples/HydroPowerModels/README.md b/examples/HydroPowerModels/README.md index 7a6d62b..93a63c3 100644 --- a/examples/HydroPowerModels/README.md +++ b/examples/HydroPowerModels/README.md @@ -1,148 +1,155 @@ -# HydroPowerModels — Long-Term Hydrothermal Dispatching (Bolivia LTHD) - -This directory contains the primary application from the paper: training -Two-Stage Deep Decision Rules (TS-DDR) for the Bolivia Long-Term -Hydrothermal Dispatching problem with 10 hydro units, 96 monthly stages, -and AC/SOC/DC power-flow formulations. - -## Problem overview - -The Bolivia LTHD problem couples hydro reservoir dynamics (water balance) -with a power network dispatch (OPF) at each stage. Stochastic inflows -drive reservoir levels; the decision rule maps (inflow history, current -state) to reservoir-level targets, and an NLP optimizer dispatches -generation to meet those targets at minimum cost. - -## Training scripts - -### TS-DDR (Deep Decision Rules — LSTM policy) - -| Script | Decomposition | Reference | -|--------|--------------|-----------| -| `train_dr_hydropowermodels.jl` | Deterministic equivalent (GPU-enabled) | Extension §1 | -| `train_dr_hydropowermodels_subproblems.jl` | Stage-wise (single shooting) | Extension §2 | -| `train_dr_hydropowermodels_multipleshooting.jl` | Windowed (multiple shooting) | Extension §3 | - -These use a `StateConditionedPolicy` (LSTM encoder + state-conditioned dense -layers, `[128, 128]`, sigmoid activation). - -### TS-LDR (Linear Decision Rules — linear policy) - -| Script | Decomposition | Reference | -|--------|--------------|-----------| -| `train_ldr_hydropowermodels.jl` | Deterministic equivalent (GPU-enabled) | §3 | - -TS-LDR uses `dense_multilayer_nn` with identity activation — a composition -of linear layers that is equivalent to a single linear map from -(uncertainties, state) to targets. Same training pipeline as TS-DDR; the -only difference is the policy architecture. - -All training scripts share the data loader (`load_hydropowermodels.jl`), -log to Weights & Biases, and save the best model to JLD2. - -### GPU training - -`train_dr_hydropowermodels.jl` auto-detects CUDA and switches to -MadNLP+CUDSS on GPU when available. Submit via: +# Bolivia hydro — JuMP engine + +Everything needed to reproduce the long-term hydrothermal planning case study: +the case, the JuMP/MathOptFormat engine, the SDDP baseline, the paired +evaluation, and the figures. The GPU trainer that produced the published policy +lives in the companion package, `DecisionRulesExa.jl/examples/HydroPowerModels`. + +**The science is in the documentation**, under *Case studies → Long-term +hydrothermal planning*: the problem, how each method values water, the measured +comparison and its interpretation. This file is the operating manual — what the +files are and what to run. + +## The frozen case + +| | | +|---|---| +| network, generators, costs, limits, nominal load | `bolivia/PowerModels.json` | +| hydro topology, bounds, production factors, `stage_hours` | `bolivia/hydro.json` | +| historical inflow scenarios | `bolivia/inflows.csv` | +| machine-readable contract and its verifier | `bolivia/case_manifest.json`, `generate_canonical_case_artifacts.jl` | + +- 28 buses, 31 branches, 34 generators, 11 hydro units. +- Weekly stages: `stage_hours = 168`, so the water balance converts flow to + volume with `K = 0.0036 × 168 = 0.6048`. A run that leaves `stage_hours` at + its default of 1 silently models a week as an hour; both the manifest verifier + and the stage-model loader fail closed on that. +- Demand is **deterministic**: `0.6 ×` the `PowerModels.json` active *and* + reactive load at every stage. There are no demand atoms and no demand file — + the verifier fails if one appears. +- Uncertainty is **inflow only**. +- Reservoirs start **empty**. `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. That is the state the published result was produced + from, and the input bytes are not repaired. +- Physical load shedding is the per-bus active-balance slack `deficit[b]`, + priced at `6000` per pu per stage (`cost_deficit = 60 × baseMVA = 100`). + The case files do not declare a currency for their cost coefficients, so costs + and prices are reported in objective units here and in the figures rather than + named as a currency. `case_manifest.json` still records the derivation in the + upstream form (`60 USD/MWh × 100`), because the manifest is a frozen artifact + that is verified by hash and is not edited for presentation. + Reactive balance is **hard** — there is no reactive slack anywhere. +- 126 stages are simulated; costs are reported over the first 96. The 30-stage + tail is a look-ahead buffer that keeps the reported window free of + end-of-horizon reservoir dumping. +- The paired protocol is reproducible by construction rather than stored: + entry `[t, s]` of `rand(StableRNG(20260706), 1:nCen, 126, 500)` is the inflow + scenario realized at stage `t` of paired column `s`. The manifest records a + SHA-256 of that index matrix. + +## Layout + +| file | role | +|---|---| +| `generate_canonical_case_artifacts.jl` | the frozen-case contract and its verifier; writes `bolivia/case_manifest.json`; byte-identical in both packages | +| `export_subproblem_mof.jl` | the ONLY supported producer of `bolivia/*.mof.json` — builds the case through HydroPowerModels and serializes one stage subproblem per formulation | +| `load_hydropowermodels.jl` | reads a serialized stage model per stage and re-parameterizes it into incoming state, inflow and target; the JuMP engine's model builder | +| `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 both engines write a full physical solution; byte-identical in both packages | +| `train_dr_hydropowermodels_strict.jl` | strict TS-DDR training on CPU (the smoke path; the published policy was trained with the GPU engine) | +| `eval_paired_tsddr.jl` | paired evaluation of a checkpoint through the JuMP stage models | +| `eval_jump_de.jl` | full-horizon deterministic-equivalent cross-check | +| `plot_hydro_results.jl` | the publication figures, from `results/` | +| `sddp/run_sddp_inconsistent.jl` | the SDDP baseline: SOC-WR backward, true-ACP forward | +| `sddp/eval_paired_sddp.jl` | paired evaluation of the frozen cut policy | +| `sddp/merge_sddp_shards.jl` | shard merge; refuses gaps, duplicates and partial sets | +| `sddp/sddp_ac_starts.jl` | non-singular voltage starts for the ACP forward graph | +| `results/` | the compact published evidence the figures and the documentation are built from | + +## Commands + +Every command below is run from this directory. `--project=.` uses +`Project.toml`; the SDDP scripts use `--project=sddp`, which additionally +carries HydroPowerModels, PowerModels, SDDP and Clarabel. + +**1. Verify the case and regenerate the stage models.** ```bash -cd examples/HydroPowerModels -mkdir -p logs -sbatch run_train_deteq_gpu.sbatch +julia --project=. generate_canonical_case_artifacts.jl --verify +julia --project=sddp export_subproblem_mof.jl \ + --exa-root=/path/to/DecisionRulesExa.jl ``` -### Penalty schedule - -All training scripts support `:default_annealed` penalty schedules that -gradually increase target-violation penalties during training, improving -convergence on the nonconvex AC formulation. +The exporter verifies the three input hashes, applies the 0.6 load factor at +model construction, passes `stage_hours` into HydroPowerModels, re-reads each +serialized model and asserts its invariants (including `K = 0.6048`), rewrites +the manifest from the generated bytes, and mirrors the whole case into the other +engine. It is byte-reproducible: two runs produce identical files. -### Rollout metrics +**2. Small CPU smoke test** — a few stages, a few updates, no GPU: -For deterministic-equivalent training, `metrics/loss` is computed on the same -target-state history produced by the policy. The matching held-out metric is -`metrics/rollout_objective_no_deficit`, which now uses `RolloutEvaluation(...; -policy_state=:target)` in `train_dr_hydropowermodels.jl`. +```bash +DR_NUM_STAGES=4 DR_NUM_EPOCHS=2 DR_NUM_BATCHES=5 \ + julia --project=. train_dr_hydropowermodels_strict.jl +``` -The same script also logs -`metrics/rollout_realized_objective_no_deficit` with `policy_state=:realized`. -That is the closed-loop deployment diagnostic: each stage passes the optimizer's -realized reservoir state back to the policy. It can be harder than the target-state -metric, especially while the policy is trained through the deterministic equivalent. +**3. SDDP baseline.** Training writes cuts to +`bolivia/ACPPowerModel/SOCWRConicPowerModel-ACPPowerModel.cuts.json`: -All rollout objective metrics exclude the target-slack/deficit penalty term. Track -the paired target-violation share and `metrics/target_penalty_multiplier` to see -whether a low operational objective is coming from feasible targets or from the -policy relying on slack. +```bash +julia --project=sddp -t auto sddp/run_sddp_inconsistent.jl +``` -## Evaluation and baselines +**4. Paired evaluation of the frozen SDDP policy** (shardable; ids are GLOBAL +protocol columns, so shards and a full run agree exactly): -| Script | Purpose | -|--------|---------| -| `evaluate_hydro_policies.jl` | Load all trained TS-DDR and TS-LDR models and evaluate on a common out-of-sample scenario set using stage-wise ACP rollout; writes `eval_costs.csv` | -| `eval_jump_de.jl` | Solve the DE with a constant policy and save a reference solution (JLD2) for cross-validation with ExaModels | -| `check_consistent_state_paths.jl` | Verify that stage-wise, deterministic equivalent, and multiple-shooting decompositions produce identical state trajectories under the same policy and inflows | +```bash +DR_SCENARIO_FIRST=1 DR_SCENARIO_LAST=25 DR_PHYSICAL_AUDIT=1 \ + julia --project=sddp -t auto sddp/eval_paired_sddp.jl +julia --project=sddp sddp/merge_sddp_shards.jl \ + --dir=bolivia/ACPPowerModel --first=1 --last=500 +``` -## SDDP baselines +**5. Paired evaluation of a TS-DDR checkpoint through the JuMP stage models:** -These scripts use a dedicated Julia environment in `sddp/`. The inconsistent -SOC-backward/AC-forward baseline uses -[HydroPowerModels.jl](https://github.com/LAMPSPUC/HydroPowerModels.jl), SDDP.jl, -Clarabel for the SOC backward pass, and MadNLP for the AC forward pass. Training -runs log iteration and final simulation metrics to Weights & Biases using the -same keys as the DR runs: `metrics/loss` is the SDDP bound, and -`metrics/rollout_realized_objective_no_deficit` is the SDDP forward-pass -objective. SDDP iterations are logged as `batch` so W&B plots can share the same -x-axis as the DR training runs. Because SDDP solves the forward policy -stage-wise, that forward-pass objective is already the no-target-penalty -objective. +```bash +julia --project=. -t auto eval_paired_tsddr.jl /path/to/checkpoint.jld2 +``` -| Script | Description | -|--------|-------------| -| `sddp/run_sddp.jl` | Train SDDP with a consistent convex (SOCWRConic) formulation | -| `sddp/run_sddp_inconsistent.jl` | Train SDDP with SOCWRConic backward pass and ACP forward pass | -| `sddp/run_sddp_inconsistent.sbatch` | Submit the SOC-backward/AC-forward run with a 12-hour wall time | -| `sddp/simulate_sddp_policy.jl` | Simulate a pre-trained SDDP policy under ACP and produce comparison plots | +**6. Figures:** -## Learning-to-Optimize (L2O) pipeline +```bash +julia --project=. plot_hydro_results.jl +``` -| Script | Description | -|--------|-------------| -| `gen_inputs_l2O_hydropowermodels.jl` | Generate input datasets for the L2O supervised pipeline (requires [L2O.jl](https://github.com/andrewrosemberg/L2O.jl)) | -| `train_dr_l2O_supervised.jl` | Supervised pre-training of a decision rule from L2O-generated optimal solutions | +## Recording the full physical solution -## Subproblem export (generating `.mof.json` files) +The four aggregate CSVs the evaluators always write answer *how much* thermal, +*how much* water, and *was any load shed*. They cannot answer what energy was +worth at a given bus in a given week — that is a dual, and it exists nowhere +else. -The training pipeline (`load_hydropowermodels.jl`) reads pre-exported `.mof.json` -subproblem templates rather than depending on HydroPowerModels.jl at training time. -These files already ship with the repository: +`DR_SOLUTION_DUMP=1` therefore makes either evaluator additionally write the +FULL physical solution of every stage, in the long format of +`hydro_solution_schema.jl`: ``` -bolivia/ACPPowerModel.mof.json -bolivia/SOCWRConicPowerModel.mof.json -bolivia/DCPPowerModel.mof.json -case3/ACPPowerModel.mof.json +scenario,stage,class,index,value ``` -To regenerate them (e.g. after updating HydroPowerModels data or adding a new -formulation), use `export_subproblem_mof.jl`: +with one row per scalar: reservoir storage in and out, target, inflow, turbine +outflow, spill, thermal active and reactive dispatch, bus voltage magnitudes and +angles, branch flows at both ends, load shedding, the strict target multipliers, +and — from the JuMP/SDDP evaluator, which has the duals — the **nodal prices** +`price_active` and `price_reactive`. A companion `*_trace.csv` records the +decision trajectory (incoming state, realized inflow, outgoing reservoir level) +that reproduces it. ```bash -julia export_subproblem_mof.jl bolivia ACPPowerModel -julia export_subproblem_mof.jl bolivia SOCWRConicPowerModel +DR_SCENARIO_FIRST=2 DR_SCENARIO_LAST=2 DR_PHYSICAL_AUDIT=1 DR_SOLUTION_DUMP=1 \ + julia --project=sddp -t auto sddp/eval_paired_sddp.jl ``` -This builds the full SDDP model via HydroPowerModels.jl, extracts one stage's -subproblem from the policy graph, removes the unnamed slack variable that -HydroPowerModels adds, and writes a clean JuMP `.mof.json` to disk. Requires -HydroPowerModels.jl and a solver (Mosek by default). - -## Data - -- `bolivia/` — Bolivia case: `hydro.json` (10 hydro units), `inflows.csv` (historical scenarios), `ACPPowerModel.mof.json` / `SOCWRConicPowerModel.mof.json` / `DCPPowerModel.mof.json` (subproblem templates) -- `case3/` — Small 3-bus test case for development - -## Dependencies - -See `Project.toml` in this directory. Key packages: DecisionRules, DiffOpt, -Ipopt+HSL, MadNLP+MadNLPGPU+CUDA (GPU), Flux, JuMP, Wandb. +This is what the stagewise and price figures are built from. 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/ACPPowerModel/MeanGeneration.csv b/examples/HydroPowerModels/bolivia/ACPPowerModel/MeanGeneration.csv deleted file mode 100644 index d0b560d..0000000 --- a/examples/HydroPowerModels/bolivia/ACPPowerModel/MeanGeneration.csv +++ /dev/null @@ -1,97 +0,0 @@ -TS-DDR,TS-LDR,SDDP-DCLL,SDDP-SOC -147.0247133419527,299.7450624492452,100.8484585807442,209.86380882088514 -157.58814081813028,225.6675464897668,104.86242775104952,209.53839385906838 -185.43371546547627,180.7943849292062,107.48502989328503,209.52017504171553 -199.3134646164604,199.83572444735833,107.55475020324891,209.4783394659705 -206.61858480532382,231.35910431382658,106.18650990754062,209.52518234738324 -214.3697084291256,189.64814901428522,113.67317158934263,209.6034477390574 -187.9473304345247,241.6103392896273,116.58714528380276,209.65384702850434 -171.46565827999535,187.4542766440176,129.25366035880148,209.51238800566185 -170.2002528391322,233.150743363177,114.76063596215229,209.45259355985954 -182.98142893312487,185.52122552406792,109.93768423864336,209.34525985187597 -202.19901785621693,215.06714163113537,116.98303295186679,209.44039837517906 -193.96716199312775,199.9910790500363,121.32762963754153,209.3672289663951 -193.52811950138334,205.21889018439646,118.81044678071419,209.32163376554064 -195.13814426290378,184.97486998527484,140.68919880246779,209.6614054735699 -226.57039256458856,167.1372529242544,157.98870219622455,210.19631956661485 -248.08925112087996,177.07636222131532,182.13344732161957,210.70698165532528 -233.5593017377245,206.24124265365077,213.25680127887568,211.4401169112003 -212.98635880030474,203.58562602361448,219.65332808686793,211.48105832602775 -208.1182840666282,225.62114837627547,215.53856096654266,211.94334659983778 -205.87501153760303,282.5815380137001,218.69325537706618,211.8784711569352 -218.77529830243512,261.2652681819222,229.70401987822862,211.85037808628837 -219.5621182240177,228.86267450841828,233.80086503295337,212.00653608776338 -215.15355785846822,278.8379771241615,219.9540629779893,211.71653085812682 -225.44578342326264,208.6334543644992,227.25750181666496,211.72866526590903 -216.46699729157837,233.62842636523723,228.98664748977347,211.79095480066385 -210.99855030225916,236.77260170176334,245.24308942520355,211.9396216916039 -200.82120574954234,257.832718296366,266.63858091994916,212.2412014072736 -217.00901852303974,206.80316405135653,287.580525250383,211.96614587275292 -205.60116177559695,247.22715853816413,288.43119570669523,212.0593948656155 -204.48717949362427,242.7626603477798,295.40865231198757,212.13189528353013 -215.01700896149435,264.8798596812393,316.4539931784796,212.48730840572054 -194.39594990932568,253.05048627557306,329.7940889425171,212.170191104127 -212.44246770637898,281.106369677497,327.59228806131625,212.68099082676446 -218.88119237987075,264.11335838123404,330.87683426769047,212.9854607332948 -209.54103152313093,265.672452188459,320.54817802711284,212.90364434114954 -232.50511220115487,242.47928625172216,336.16459151820277,212.98400917882333 -246.55559517109822,250.15790720527644,328.4530145309637,212.90706046302626 -259.1804770347488,241.4580174607301,306.6623006700101,212.78491180246007 -243.65212407401336,216.2392032573588,311.05102021329515,213.50440427222605 -268.3327047244221,244.87238185642838,313.43043807340126,214.71903130733853 -259.25135590920064,212.7607093726518,289.6446657672623,215.71309550713656 -239.7596346992519,211.60973323507133,236.34688350288008,214.21514981807115 -225.1627151901455,224.31226414469103,227.41520899884554,214.14602835221518 -226.300220128706,190.17002437882283,237.60749837482643,213.05570166141047 -246.5897657016228,197.34726823968018,242.14935260524663,214.3397929974062 -200.45447214778832,159.42600322266816,217.0164054870767,212.87589299860522 -177.65036023699594,199.6529727342857,200.46699991530508,210.512610777988 -152.7449270008933,184.7732720253377,215.7682105980341,208.87860648289214 -116.54920043933797,185.46879418205066,111.6333307935832,205.95870346385465 -118.11835868140619,166.0896692911,101.80408752144571,205.70698904522408 -135.40331893488192,159.49003675324482,106.15347696391866,205.4160873909239 -165.39822644830028,182.5511233035246,108.92328402254266,205.59700933991252 -164.63498605950215,157.20350355656583,103.94596690664551,205.58479725277505 -166.92019582010437,188.70842110946302,103.82258613108722,205.77526373955115 -153.73417427187314,161.11055875216002,112.13281054476954,205.88135777815637 -164.778321612267,181.93462654464733,161.52068981849445,206.02649485451556 -160.9396855926067,146.59967315111336,169.88300890301332,205.8871588917278 -161.6813291137583,157.86943128110318,177.59131665764,206.70433459244137 -161.9520731591163,129.58260488127797,172.45550740547597,206.366999884319 -161.5166767553574,192.37516226972488,177.4638905803286,206.38870455127955 -171.23315428685606,169.81265452067095,176.73862367347002,206.249716219982 -203.84334411204006,189.01908062873738,182.19685255887867,206.63455688813036 -243.88748126609443,185.3643782473636,192.64656185901407,205.9797537356252 -255.36863069633904,189.10691135198536,210.14038242475175,206.03555271847185 -275.72231730419776,177.47926018459844,214.11405852350882,206.51953984726723 -231.14746381351682,203.55835450764843,216.8881876993481,206.12018860291096 -239.70981393223852,185.15015653078225,206.20963274723462,206.250132372938 -236.55408488066604,209.9345245251102,228.06281826263384,206.1138429495153 -232.50309001204022,247.09182945796942,232.53663833367236,206.4146828063853 -211.09249114427467,224.13559766576765,229.0267023271387,206.5605843384091 -222.7816613997703,251.3620122443193,232.90850460804563,206.40037604289813 -219.16351862667358,241.65598188514326,228.66399277324248,206.5295113131882 -207.22133488700123,260.0058643392084,266.0049119099325,206.8315496621826 -217.06224817213152,249.65113999794553,228.7078025295844,207.13270789037426 -210.07761177326952,201.43928958603075,257.88491102881073,207.77068168915991 -216.6438147791045,209.70322997573356,256.3000900779569,208.16087070287398 -201.41487156994177,254.6147418912871,260.0864123226794,208.40830707759466 -207.97135419475285,233.44163279290632,245.1593291381967,207.38456438434162 -211.26689971022438,206.86923643700797,266.2262958784643,206.9039133561306 -240.1582296197083,249.82887487767167,286.04078934122384,207.77917011114187 -233.02195021621122,218.9756433172769,302.4507102096619,207.558738022174 -237.29598744217932,254.3292021981702,310.8026658382449,208.03806284333123 -262.7454036444481,254.22526995036333,312.90905574443457,209.270249411708 -277.54946543623424,228.08210258025755,326.2879316740818,208.91105191830513 -259.14118496809317,237.00317892462166,325.13527205939647,208.38620445160527 -258.0603903695542,268.0249997632043,305.61306417662183,207.98642330663995 -263.1354853907414,238.83057850845063,298.7323501222888,209.43087634497854 -280.35492909981747,216.14279418347928,318.1451091369037,211.27160719784078 -271.56374567280704,229.39964558658272,286.6845872174376,210.0236414480106 -229.35820796650296,212.93348980868046,245.77044877320677,208.8917459728048 -230.49394051322878,203.67236378550288,224.55512987384654,205.8564923994707 -225.7601668320821,219.35714063162678,238.83881638414672,208.55931411570532 -230.75407630714457,198.06757965648347,238.36899164573157,208.37478598750155 -221.31628509636886,149.20055233004982,218.55183620363255,205.669374135596 -200.12300075458802,167.6799930782707,209.6087072026431,200.7031326575932 -138.65216945726675,143.81558253281227,219.38832428287833,201.49222415721096 diff --git a/examples/HydroPowerModels/bolivia/ACPPowerModel/MeanVolume.csv b/examples/HydroPowerModels/bolivia/ACPPowerModel/MeanVolume.csv deleted file mode 100644 index 6b0f78f..0000000 --- a/examples/HydroPowerModels/bolivia/ACPPowerModel/MeanVolume.csv +++ /dev/null @@ -1,97 +0,0 @@ -TS-DDR,TS-LDR,SDDP-DCLL,SDDP-SOC -22.51732496848532,37.919375441643616,15.010226053947687,29.88884403814745 -47.20258811999907,71.04409366252557,27.799866146567854,58.85398607133367 -72.83176865479658,87.01935425652064,41.809771632008996,82.61277155868845 -91.6036862853376,110.9546703800459,54.779619691636846,105.02407149811434 -111.75802365829193,124.62427072370988,67.41758956472614,127.58313808354393 -132.06225985386516,140.7114941122255,76.61311783876522,147.63328200911607 -151.88292311509423,163.09183590390472,85.64543943322955,168.65289410472099 -167.62574263315506,176.9949496837815,90.09866940534309,189.75454495424944 -184.1432711637443,192.12358945548075,97.21306040484191,218.11088982453344 -199.10712684414443,211.72514898332275,100.754649277593,246.93492472290026 -213.03560361830984,234.5026497996314,107.46682144224346,272.21531353974717 -224.76897734579637,261.6236901648443,111.30922724569007,292.90711864275784 -238.39447203378649,282.426645017808,114.62593628727466,311.83209342410777 -245.37549219043413,285.94648083840264,113.43065917802855,322.5848167767246 -252.4494932363904,296.90814187996295,110.20680607797237,322.2425933406325 -250.45907641085287,296.9831633048792,106.20779976718435,320.00444979375743 -248.8524629192563,300.7632599043702,101.76735381105871,312.8087106999844 -245.3285907233545,290.30183231928174,95.88402955956306,303.1966369847269 -237.90416834064467,290.15844458648814,89.15470564095466,296.46398240261857 -230.9413064277374,281.77833258453296,82.17436482998376,286.69479612549327 -221.1118971810357,281.1300748339776,74.6379921116223,275.7387873489527 -209.82043242344366,273.15550833073513,66.46062403663097,264.90582250183024 -197.17838472323572,255.4079970540009,58.1801555890566,252.08676360007652 -184.5082417295772,243.31108770222295,49.643407346969596,237.85231993230704 -171.364986731152,236.8863043514778,40.88630847779404,224.51757587451243 -158.67507679180278,228.75659130962944,32.42172641872411,211.62777515165263 -145.70893099014296,228.60197560222855,25.915677587474477,197.57381524080466 -132.80165423375078,219.4870486506905,17.949546658738377,182.8952051783611 -118.76446158949864,212.842623503242,10.91236331395401,169.0595060088052 -105.47673733968136,197.82735475771423,6.342665426831365,156.70187722582688 -92.28262527930282,183.60880119824964,2.9637113646432924,143.70426904824114 -80.08178289428561,178.21417462426308,1.4904346490510063,131.34345908273133 -68.05075167883604,174.38024725627528,0.6542767511259123,119.6560155151396 -57.33892828225943,163.75151223638323,-2.1629451753485584e-7,107.89499970347059 -47.91122996837452,158.30124789510745,0.01699339492037168,95.99205089892341 -39.71203072777365,146.6433762840449,0.013683141695575645,81.98936536386094 -32.08903884626882,138.74956149885196,-2.776369796429933e-5,70.22278074065235 -25.567879137873327,117.64643250247984,0.02029723087689403,57.957500191547524 -20.226109971544595,105.87824541767543,0.02942785780510852,48.218945817433884 -15.822029319315941,95.26193888634329,0.0015619407570932227,36.867704663165426 -11.86482403506727,82.88471848733366,0.0139202251526318,29.26424780181313 -11.41444238123061,89.84998297693535,0.0666095021126761,25.92639157504742 -11.760709387675428,80.56903002626132,0.02911519239806684,26.098422131593825 -15.608653812842075,84.4812008303581,0.1451610159592241,22.394312574066713 -18.46652374296125,75.10873866189522,0.257529864394238,19.330147292287013 -19.154852416425946,79.66424881896181,0.34310578392406726,19.064203280951464 -17.76382346268219,82.33214023398799,0.04020249114668608,20.09172473445721 -11.770417835270539,77.16028138611318,0.1601258590007935,19.35396878018543 -28.575902113160843,100.30120799881679,8.290616244150943,46.258638018871736 -44.6500656371219,133.7662232684492,18.826473984628194,73.04283772380003 -58.93359681990834,144.39896871097727,26.967830366959436,95.94410009405843 -78.81921579909906,157.05027238202555,36.00161441777166,117.71853421648952 -96.31823829542331,172.46207271242636,47.67488678462672,140.18906733662052 -113.68465589999252,199.6980903165839,56.815618070614086,161.20146693953137 -131.44733746695687,218.31345641963154,65.0298903498588,181.69307761993895 -143.57022598996326,248.0669589387606,78.12103160217615,199.8999392076057 -160.2545160514829,276.4730547448535,95.53937029048053,220.31192988484966 -173.71546658765067,294.32632069405474,107.5932705161822,239.09635346381702 -188.87717865623495,289.0248763377732,118.23444331568548,255.85211397472423 -200.72440725109396,310.47111738812987,125.58297208702875,272.7401007551301 -211.54578497851003,321.62467412938156,135.04096202155375,292.5534588326327 -219.67787470209927,322.9377982306577,138.23259862143857,305.2552176250861 -225.5911712053431,313.0818205198798,137.52220454328514,306.9497613201085 -225.39958719867292,303.0418832885243,134.56161843454288,303.58072451918565 -223.0003148921021,295.41511330313085,130.39480512697176,295.56194440948934 -219.3358500411617,292.2241103571665,124.0594015578791,285.94793100031006 -215.7865012983455,282.52479046838965,117.20362201093069,278.35828561341475 -208.9688074571684,270.8475139202375,109.91183630093335,268.7469595331369 -200.25820568279497,268.14577165979705,102.18413675040794,256.9288932038997 -189.3589474950667,274.8028403967962,94.29202902742942,246.23379738459545 -179.11347981019935,269.33461930444184,86.51972305194262,235.28235566184617 -166.46173064664583,261.0404132262943,77.8672879103141,222.9405685439762 -154.36450314445943,258.2200123763158,69.45071513510558,209.73529860734234 -142.61948735542381,250.57594722312155,61.04749888339048,197.4097594424145 -130.39403275688142,237.56983972063503,53.57905190860542,183.16067786345798 -118.09172135231981,232.9065992805976,45.31949038232733,167.08432725260056 -107.2702477985387,215.22999411819978,37.242727577570335,153.20481806438926 -97.0065973471623,205.80014155651824,28.961340379753675,140.27220558777037 -84.6333338632984,192.9275305544331,20.748060187265494,128.88089859059698 -74.44115642907373,175.65153529061962,13.951363389962466,115.32978413235291 -65.89676047851572,159.63588608030236,9.971531743391353,102.90650396427401 -59.101026640990746,157.6032563807769,5.649949808269948,91.77112364358631 -50.4628042074048,151.14613237451394,2.8422167357923183,81.38224893770428 -43.380434756627224,142.1297446607122,0.8089371675179539,69.40743842003496 -37.2402039626919,131.15093810046022,-2.7757075579902497e-5,58.51697840372556 -32.6377410503266,127.61272326799181,0.014576637404480192,49.72583740775145 -29.407339371204802,122.7377666202245,0.020931438505678426,41.99241630483234 -24.06393930942189,85.84155793018172,0.0062571966267834424,29.914239653894793 -23.127901917898463,65.85303059430143,0.03619878202007641,21.935606087997716 -22.924839043559988,62.40507538369134,0.23070127422069103,18.650205536148956 -22.007801580404273,59.154416378847564,0.49709652305249996,16.31324545284173 -21.136620549198433,54.197233720503064,0.12869349623927082,12.457190721911122 -19.031142363960612,38.14249299045677,0.2798932995958727,8.11780690376344 -17.40204173868524,30.7482859887398,0.6275685251939801,6.793617876065368 -12.246953654446704,19.1380483634613,0.7553403609073082,6.373971458330337 -0.40074148030873114,1.9740202514084515,-2.7761152226093412e-5,4.45582104449006 diff --git a/examples/HydroPowerModels/bolivia/ACPPowerModel/SDDP-bolivia-SOCWRConicPowerModel-ACPPowerModel-Volume.png b/examples/HydroPowerModels/bolivia/ACPPowerModel/SDDP-bolivia-SOCWRConicPowerModel-ACPPowerModel-Volume.png deleted file mode 100644 index b8d3b29..0000000 Binary files a/examples/HydroPowerModels/bolivia/ACPPowerModel/SDDP-bolivia-SOCWRConicPowerModel-ACPPowerModel-Volume.png and /dev/null differ diff --git a/examples/HydroPowerModels/bolivia/ACPPowerModel/SDDP-bolivia-SOCWRConicPowerModel-ACPPowerModel-thermal.png b/examples/HydroPowerModels/bolivia/ACPPowerModel/SDDP-bolivia-SOCWRConicPowerModel-ACPPowerModel-thermal.png deleted file mode 100644 index 715ae9f..0000000 Binary files a/examples/HydroPowerModels/bolivia/ACPPowerModel/SDDP-bolivia-SOCWRConicPowerModel-ACPPowerModel-thermal.png and /dev/null differ diff --git a/examples/HydroPowerModels/bolivia/ACPPowerModel/old-MeanGeneration.csv b/examples/HydroPowerModels/bolivia/ACPPowerModel/old-MeanGeneration.csv deleted file mode 100644 index 6bf1b1f..0000000 --- a/examples/HydroPowerModels/bolivia/ACPPowerModel/old-MeanGeneration.csv +++ /dev/null @@ -1,97 +0,0 @@ -GML-DR,DCLL,SOC -754.4380411076402,777.5000651388794,808.39146191929 -763.9338127015435,778.6161308037656,810.4497359087477 -785.9866799686756,776.4738316365374,810.4318435400083 -798.9650234534897,774.1895110920148,810.4423713894863 -813.4093404065882,771.6175127585612,810.3100922886454 -815.2527405533946,769.690756237791,809.3646788843366 -816.0761214220428,763.9602229253526,809.6296361744973 -815.9278044939564,759.9185330443215,808.9811315866672 -816.2248384806808,758.7161487106753,810.0848989444605 -817.0593183012866,757.9903509856464,809.8935871312706 -816.9420038699978,760.7144728418867,810.2634538875843 -815.9311674960618,764.893555187324,810.2298093180908 -814.9734425771874,776.083268362073,806.9890210623968 -814.3931652596028,775.3553660707729,809.469570261239 -813.3512123823888,776.9872382164215,806.435412035197 -813.1122812015799,781.5748299383691,803.76047266804 -804.8618803981434,786.2693470500913,793.0922070043873 -806.2898779952249,786.9996462426633,794.806228574939 -786.208330418676,787.0407923936033,795.7484303621592 -758.1841473201359,783.0101201728759,794.778484126119 -787.6337465139567,780.9496091705703,787.9572526300502 -796.9792045296797,773.9760290997818,776.583212797999 -802.3693851175619,766.827175226718,771.4982891208599 -788.0815507309667,764.6808066370883,755.4577320962522 -775.0347152285249,760.4479050181461,755.0043200632325 -759.5944409641353,765.8616285179032,761.0840670780419 -784.0274406120802,758.8419091307348,772.7181473276644 -768.1636874444753,757.6595828696588,765.2516543577224 -766.7909261363316,765.4111818579225,769.1487212847389 -801.7427696771513,769.0581981318577,769.2150160717428 -759.6712829783723,765.4972828454335,760.0092503283103 -728.0438969154229,770.1136410121375,762.1179895248088 -751.1738628393955,771.8778092125971,768.4138660134898 -722.6577336306378,767.730738620023,750.6386385431216 -734.0645028852999,775.5375839140122,762.0683852608834 -705.1459454564006,767.6501682200304,760.8443896963369 -719.5842626149821,771.9412835266903,735.1583918670707 -707.622022963946,775.781590137983,743.9602088754466 -723.9226473233679,777.568830549518,741.4438832896664 -712.272654064274,778.4165649399346,728.123064313974 -772.4580726724691,792.0033174249965,736.8381101791307 -804.3579270580236,795.9480401497609,758.9049213487806 -807.9254005836405,798.3318682485603,764.5351529332345 -811.7771550293503,801.0668707823942,765.440419192272 -806.7993508472589,793.534195321957,770.4462210663334 -814.719814858749,800.4028567706356,788.6182171766468 -814.9662528373694,800.9080967317402,782.9359446960024 -815.3263396264077,797.0711832642471,792.0297225560246 -817.36643800248,806.25785896623,811.4585252821596 -818.1009043416572,802.3835813346869,811.4579775125437 -817.7042232871696,805.8152785865863,811.5237436173679 -817.5214211368775,800.2588723834264,811.5740501501193 -817.6246037521263,796.0059956561496,811.4102383669313 -817.5523331523607,794.1244281496903,811.3992603373346 -817.5683990401894,800.3486654896047,810.8131674913677 -817.2468737001973,796.3086154225991,811.2922217607369 -816.0550258163016,794.4768775438704,811.3407731635045 -816.1253598581076,804.0053246540949,811.036779529396 -811.0775283889437,800.1905068085806,810.5345314158844 -814.0413864671765,798.0680869350742,811.1047061356844 -814.8690585904386,804.1979243956881,810.3864900272891 -811.0535142359602,798.3829256703368,810.7395550799902 -805.9612047823363,807.0523956047546,807.0746463980634 -804.434799288345,806.5292618802507,810.6008814572381 -799.1285430072628,807.3768430796312,811.8187972027611 -787.4515992368827,805.4715193075425,811.0125075668489 -788.0698127409845,803.4683560124454,766.2206543097622 -735.3352819865137,797.1358770819222,754.4961078912702 -769.7530685575643,790.0583106727498,746.9474851414313 -782.8180496117515,789.8754023923361,760.55761781127 -735.9829960997624,771.070931343801,739.8918575493474 -718.4021048263588,781.6161297777758,754.4162551716479 -758.8242849203803,766.2215854069902,745.8935557659299 -750.3666020524627,784.9844170884469,748.4972624080244 -759.4658226893457,772.9461093995488,752.3144989443666 -793.5802109166256,781.0316618961466,794.4705010023529 -757.7686567016194,781.8532321750729,795.4634344709691 -754.4252426956816,796.8406123327378,778.2733904161771 -735.9099137485754,788.3122362476504,777.0882003380447 -726.4415625010873,787.6332078117692,786.1776499145394 -791.217403649708,792.6741682299566,789.7076202098386 -782.0193799545071,791.9785743266382,802.0264384575532 -782.5333504908076,796.939099327117,791.7380220931328 -769.2441459073468,804.7458255497274,738.5301893131789 -762.0043241717357,795.274816894758,727.3592400914573 -776.8404374053248,799.7203396837523,754.8186355518964 -735.9596635746384,794.6978943788807,771.0713090788967 -678.5051820668782,798.907472984408,781.3203602091523 -740.2769510256798,796.4323245425782,792.5088156491465 -772.0833156882261,798.7907230008044,810.0358570939472 -804.7401749446402,801.7066053353444,809.1241160805272 -809.4881364541553,796.4190897870487,808.5860350057526 -807.5660917517047,787.2074697391735,808.4291407710223 -816.4883193962507,786.175611358594,805.3821081189133 -811.1723743997717,791.3580188304669,804.310819517889 -813.9184447975906,789.8675395790939,795.8202596397342 diff --git a/examples/HydroPowerModels/bolivia/ACPPowerModel/old-MeanVolume.csv b/examples/HydroPowerModels/bolivia/ACPPowerModel/old-MeanVolume.csv deleted file mode 100644 index f54eca6..0000000 --- a/examples/HydroPowerModels/bolivia/ACPPowerModel/old-MeanVolume.csv +++ /dev/null @@ -1,97 +0,0 @@ -GML-DR,SOC,DCLL -24.42024368612913,22.813843592801046,32.786944267097354 -52.61296437285968,49.9387637668155,60.08755636972764 -73.48352463262623,69.16518326259805,89.10076373782104 -91.83805322425037,91.63763049422144,119.1136564261727 -110.86761016381314,114.40974519474337,142.367084671324 -130.33535100787216,135.7043932333,164.90256387218213 -149.96564788150093,157.90672206387407,191.55668276787995 -164.8842109660702,172.26288984042617,213.12305119321826 -184.2736304550699,193.50197715274084,236.38462361546289 -201.07120806949973,210.92576592197278,258.37960024706706 -213.98948002403523,224.97520272484363,282.53703862091106 -225.72688322725935,238.69437732719206,301.8386483528583 -239.1668901198572,253.98443801763932,317.39838590799064 -241.60838349393734,258.4052680519806,328.69101529756347 -243.87005338216596,258.4225558386635,332.7887145768762 -236.40957247481768,254.99062372579897,333.02687591833075 -227.95434435922692,249.51064036503595,328.66271995409966 -220.622918585445,242.58885321920985,322.6138801165465 -212.56362040852184,234.61600624675012,314.84266603963636 -205.2029039491568,227.0110914080873,306.0370894823131 -192.11172746537042,218.63936557614426,293.8318800609729 -182.64174725153643,211.71242915887638,282.2501801738648 -170.47323265401315,204.7414057781976,272.3282077354793 -159.3982266944243,195.3880108559675,260.8362925582277 -149.83275468177777,185.3149879812562,249.53346699740231 -138.64025236257154,176.8474604105602,237.00709718717204 -128.49981121700947,164.61635553908977,225.76780484813725 -119.55808956485505,149.16393814327247,211.5026393115996 -109.40994797473343,138.17046488554612,197.22679766654065 -101.19943831752322,129.34971036513215,184.19028548468307 -93.0950380662557,118.31050939709739,174.14476196657523 -84.12683336412759,108.59144397404403,164.13679962956442 -74.31425566082584,95.48746670794944,152.26879863592214 -64.68251988150816,83.74441412661264,143.77789824223262 -55.93273512854179,71.78851104659745,133.39397041051134 -47.470230714780435,60.9918011685822,122.72382529725357 -42.902251002571404,53.600632677179114,112.70684783747458 -36.783300544222826,47.90093899852285,105.625010131762 -33.84886683504263,42.8456382174302,97.34773147425156 -30.539060756940593,36.67447495499788,85.91961378719297 -24.253147300947152,31.918336786741225,76.8412058771763 -19.37421242647696,30.661511320096842,72.84207341542009 -19.84415330662441,31.90301593886835,69.29262949312975 -18.691311496242008,30.7903760321419,66.14902283703876 -15.539802441267089,28.992890695169088,63.32356262537361 -13.12883827578762,31.493795242185534,60.9028333992819 -10.285098591264575,33.11838011051926,63.44246709801223 -4.304177338190841,33.270321240759145,62.33637379525817 -24.78912364920815,65.17296628387666,82.02837027982252 -46.128564933125965,90.28542730203827,105.53323736109894 -64.76391535600754,113.07871638440982,126.16962264883219 -83.68469255678947,131.4767403670748,147.02119576713332 -102.62576751085504,151.1793263646652,174.06997953247634 -122.10884547505285,168.9485496840517,197.82419456597168 -139.0909362617462,187.3915507036424,218.00654868937 -155.61642050719266,203.96616374195102,239.1612504688632 -173.85502380009012,225.07846869778504,266.43497423848623 -189.94357321868284,241.04455533480413,285.02677789942834 -205.10542110474128,258.5410732406748,303.17090110135 -215.07972350994615,272.6301659815547,315.7204201538163 -227.59214018171318,287.5338142107001,330.1498278588481 -238.35900989155587,293.88007438043957,338.2637387637943 -239.71734286536073,297.0518966344584,340.9333444059024 -234.57097188762512,289.4556520547937,336.62103456097304 -229.3653070056195,277.85806814774884,329.36972652216167 -225.24123129953014,266.74068632947535,317.86517131584753 -223.40755563346332,266.8566800999722,309.37362783456604 -214.71780354727954,267.0158147988449,298.28694552670055 -205.58213381979897,266.13060450702403,285.79060986552383 -199.63638289165294,263.19296222844577,274.34100321724 -196.9476255915581,261.6158545963803,261.49259589585097 -194.4338549997918,257.7831110006971,248.7448444879332 -184.44008688689235,250.04913847095594,233.60751146988588 -173.09125454485738,243.2333713249594,221.32008173318954 -159.78808641494453,228.9311234566315,210.4880383840154 -147.54040572653105,213.558622333515,198.620683417788 -133.80975465042192,198.677421201316,185.78538507750906 -127.36292166442063,187.49318401090244,173.52912314377903 -112.03242464451118,173.40295666748415,161.09909456832656 -105.96512844688678,157.9553391121576,143.95590030132936 -96.7158810392197,139.19770564782658,127.46913985919082 -84.57566495709078,121.51323250732996,110.06384661411236 -74.0859960981055,102.81492301691021,95.61702989063306 -64.1471888014527,93.56352480978265,82.02985876882259 -56.610735085880044,85.35925892242258,68.43545545665778 -46.06540066642355,75.26905287491292,55.036243630604645 -39.177180780946124,66.37318261061246,44.235264155017134 -36.97198268578548,52.831682182498604,31.65521267976576 -34.51914070410228,43.23240862060199,23.146899861026462 -30.16428798379447,38.35776429158663,18.50747085437594 -28.3731107822482,35.07077696849485,16.001883654731756 -24.328388479164293,31.135171755718282,10.919668971956984 -18.1810374571695,24.294709467605973,6.87540044562625 -12.201931607410033,21.52000166844794,6.001554697768045 -7.8039381182538,17.884997616871818,5.411654192570554 -0.29612398857184563,6.23867643771192,2.2520288707474343 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/DCPPowerModel/MeanGeneration.csv b/examples/HydroPowerModels/bolivia/DCPPowerModel/MeanGeneration.csv deleted file mode 100644 index 088cda7..0000000 --- a/examples/HydroPowerModels/bolivia/DCPPowerModel/MeanGeneration.csv +++ /dev/null @@ -1,97 +0,0 @@ -TS-DDR,TS-LDR,SDDP-DCLL -310.36670246669604,190.6722286458643,195.63543555612705 -300.0402745493755,190.90652301539131,195.63543555612705 -284.2826155974511,171.63943917880493,195.63543555612705 -262.4530038156778,121.21508100972635,195.63543555612705 -206.35392491538158,145.20801477325261,195.63543555612705 -208.21355603480114,195.98400612739056,195.63543555612705 -208.12952287519298,184.48014396809722,195.63543555612705 -253.52436583713765,190.87603531657106,195.63543555612705 -197.49385757780357,172.23381096355334,195.63543555612705 -176.1998239554637,201.74198937392333,195.63543555612705 -143.10638487256296,215.0539330108239,195.63543555612705 -164.09784216489297,279.54855006541385,195.63543555612705 -143.1526001495168,277.8093653960411,195.63543555612705 -138.63716756407192,310.53456997649914,205.06045742923942 -146.71750713493958,292.79909971339623,195.68074015203655 -165.70724922362527,280.8412648986776,218.95066904257948 -180.37133573496948,242.6055000405791,214.6528862348388 -182.27104743289698,211.40288408393354,211.1054538655554 -168.42200067480422,189.96593864844323,260.57719886696566 -179.7805579103504,222.72866315226474,217.74141764153222 -186.53255590422555,188.0834764164419,254.5907971550042 -189.88534980456515,212.1772302952223,220.55556816454924 -192.64091374776072,184.23100125319985,241.7186585644044 -200.9301606923647,190.13865800309074,236.28538901803387 -202.34954433985894,189.68633560207715,206.54775010047405 -200.9866375374354,235.3745249877977,201.06423440985083 -203.76899870404935,208.9381063062943,232.46315214214115 -208.7689367428301,200.89825960442676,202.1997333790202 -209.7058885606046,196.46027964947436,225.48464506177243 -208.96462536876243,201.61431229939222,244.56542551393068 -206.00901496381934,232.08174739174302,226.8034266106153 -207.20778628305524,187.6391060127259,221.28204920509333 -199.19117583288852,192.98150505420466,214.05141183202468 -203.15270955387152,201.76227664281953,211.0935640959868 -209.85397010503294,194.04919342207475,215.56155138387948 -218.71254016547692,194.34063393564193,202.24166962659464 -223.81357497445498,193.37694522056964,205.39173990288145 -223.74031219381095,188.90063688959074,198.4646397532116 -218.99258706266096,216.37849071059196,213.4374784310854 -222.7025714993219,203.73663739141742,199.60722350983716 -216.77625720460864,219.20930629489536,198.64676921113056 -205.0103191395091,196.49835753972692,196.64561661028762 -197.17276078678094,210.6199490865397,195.63543555612705 -217.31712583372683,201.570851580731,198.48143862072405 -219.98278229746552,212.02989485796223,197.74495843974967 -211.7039073704681,189.78408466394114,195.73571568661347 -192.18950081162296,201.1333859563303,196.18353246666993 -163.092361244188,196.5808845249248,198.04021844833525 -96.76269175973658,192.40059021930801,195.63543555612705 -100.26213496508751,209.01783947283775,195.63543555612705 -109.91843911835947,220.64445830261405,195.63543555612705 -113.24432444864752,211.58290813823123,195.63543555612705 -141.1923600640126,235.30799469944805,195.63543555612705 -136.97710286806029,248.91380108044092,195.63543555612705 -178.0270514797749,240.5595514171583,195.63543555612705 -192.46092554811065,217.23457441612854,195.63543555612705 -192.0162957802997,240.95160128460026,195.63543555612705 -187.74857008028843,209.3346844558812,194.9253208161026 -202.29790020677325,201.51557361871764,195.63543555612705 -219.65550967542032,206.133340668758,195.63543555612705 -206.78985827380035,186.7210675712195,195.63543555612705 -179.7013026157542,183.78919648173925,194.72758839453945 -197.31107210219633,232.6798077533337,195.63543555612705 -212.439322870421,225.05275971183332,195.63543555612705 -226.74491915517856,201.95125030170584,194.72758839453945 -237.79138575748794,176.9880820056647,198.0280615072656 -226.89559668358947,195.57764057424754,195.63543555612705 -217.60134072120286,218.83179558896828,198.88667325565396 -231.72878349789417,214.69100870050383,195.63543555612705 -227.0683054446563,189.2320686725807,195.63543555612705 -224.92155019669514,183.63297229068797,195.37658029993136 -236.17496516463643,203.93108537154325,196.54256154065575 -228.84145861660085,200.11195150876443,200.54398701323652 -229.11282698547083,197.9668663386743,195.2172455505036 -226.5767931911686,190.32425702793915,198.67432998232522 -238.22139125690848,191.82982117902986,195.63543555612705 -240.89940714128525,191.7053259677584,201.13300981547155 -256.6425204679863,198.07109788256338,206.23013823631223 -247.5685121967173,218.50360796809645,217.76809622840392 -251.1982331042891,196.6345740039764,210.86786458701357 -254.6770881224796,205.372872209885,197.4677205061156 -258.18891393972154,192.1025949538282,218.76785691473236 -260.50366533628454,182.05702658151841,217.44158367759582 -266.7744191032485,211.0941326340786,199.20517688659322 -262.18305797809705,224.42347228545017,218.6708379876769 -264.5284965211532,183.68965348029684,200.8819480106621 -269.543963845514,192.5882816556022,199.37219233451157 -255.854599395458,224.12638548857277,198.63415544514888 -249.11738406633398,187.6468399549652,201.36332435620503 -219.32291557005183,198.97333357041174,198.97666234394302 -213.99198952029354,226.58079801132834,199.38470919629063 -195.1052709011372,199.9536689558037,199.08211041079875 -197.84827109234902,187.12185781448508,202.8952239438802 -188.89680487713747,182.17304414521956,206.53396022668508 -139.0596776361857,187.7534456796539,202.58241502431267 -108.02245305886454,186.34717231009637,206.65594669592264 diff --git a/examples/HydroPowerModels/bolivia/DCPPowerModel/MeanVolume.csv b/examples/HydroPowerModels/bolivia/DCPPowerModel/MeanVolume.csv deleted file mode 100644 index 2edbb9d..0000000 --- a/examples/HydroPowerModels/bolivia/DCPPowerModel/MeanVolume.csv +++ /dev/null @@ -1,97 +0,0 @@ -TS-DDR,TS-LDR,SDDP-DCLL -38.958495018736116,17.130585473843684,27.874693324526913 -79.57195679283215,45.68439084172373,56.71467250787193 -110.55874084691052,70.93824472798421,88.06062850522831 -141.8267345086011,86.43965837214422,115.12645836187994 -165.5759268543863,98.08518640650003,142.6344581862854 -189.6358481580032,128.07469716843963,169.4129801445691 -217.54689887599085,160.93381738667807,186.94443457555718 -240.19368066440876,178.7422985584664,203.89754858517156 -260.2737700877564,187.2905433325719,220.48934110850604 -276.9236454489721,211.68981468123792,234.95426165012623 -292.61247994840903,230.41964676845515,251.8077758940849 -307.48590169050277,260.99123181586754,266.6540086179669 -321.52328341440153,280.3779622297759,280.75619401845177 -327.1173921706853,304.8928676382792,287.3423698618699 -323.05918119227397,312.9061680235575,284.1681465535943 -317.4664549593109,315.6690801996624,283.7719411519089 -309.35517544113753,311.09393582910207,275.834584387439 -300.0750637727323,305.45492216298584,266.0494109902844 -289.03651583859147,292.6583655037422,265.31452510495876 -275.07303450242244,290.08485595443545,253.38069767898887 -261.8427066958466,277.13451859712904,248.94323317814306 -248.86239349799212,265.88093479540953,236.42853990629496 -235.46635395266176,254.76779820829188,229.52347770735145 -220.78667923080667,240.64771533562885,222.2582720201533 -204.9770602732612,223.02259073281593,207.04530521958108 -191.6544460489402,212.02661423274566,193.42173975183667 -177.29733439437422,199.37066138511904,184.4697108979918 -162.21999811791144,179.43792518158358,175.45696402427058 -148.6105367318184,165.32604909736332,163.81669153258977 -135.5938770045921,155.73668652792986,159.1103911753594 -120.0893483818111,147.3513765470368,151.0881137276778 -105.91749943004193,128.92533364780613,141.48785700926615 -91.65345611071938,114.29581063871674,130.1760616251962 -79.47307091611815,102.04591909823968,122.92253512328007 -67.33722797579078,92.8476061711399,113.38185929200922 -55.23855010913335,77.7890370109465,103.07791918909045 -45.83741441672373,62.691907685719265,92.2945434637947 -38.61412205422517,54.00765586365262,85.4210912848469 -31.63056162802122,47.37364668023581,83.36485816864356 -21.32417685458367,34.889093081302484,72.50285462025153 -14.266860562079515,27.5050457739738,64.27252525392315 -11.45014901187418,23.167821143333953,61.25712310698867 -10.232698030361556,24.09993888275193,60.46255602646365 -9.04400721387735,19.823169460942125,56.307393838050096 -7.613186068236918,20.95118436567993,49.164102745380504 -7.829756312889151,15.939152696162262,44.69635911315326 -7.1865005788796905,17.570143022795488,46.25974831948863 -1.9599019083672864,14.45474645304031,42.883165751467686 -13.431509106880418,40.40161662052895,60.61198563088284 -23.025212643751342,67.19955087233191,86.08063166181535 -34.0222944315804,101.09639573209235,106.53770001025177 -41.995635921446784,118.9519358249189,125.12042854653373 -58.669755259091616,146.10117589528755,151.38086726797366 -75.29623867317059,170.60560491640814,174.83057441976348 -96.10877630265247,200.53908427604537,197.78165603383025 -116.2190069766931,216.34332771877015,218.54796893824428 -139.4484199486382,244.43656652346516,242.78684354616058 -158.8471503567775,267.3498238132938,259.7799919905168 -179.98838589582726,287.3438070499536,275.40286780038934 -196.55905346202454,297.93249616214615,287.4508625545051 -214.62067264782303,315.3425282292789,302.7312274552182 -223.6774064748447,323.78135556271855,309.85533790070923 -227.8192596423052,329.2334940914427,309.9199757698897 -227.1613515925031,325.5858820006127,301.8388353736157 -224.06850690144537,326.8279502879563,295.0647765143938 -219.95259678249994,309.50772333524367,291.1562282654021 -215.7658416669313,305.08246698241754,283.87090566300384 -207.03917682436037,291.53844138895437,277.0790023106266 -196.76136783649176,281.34935079081947,268.8973427593418 -188.00297625726654,272.2211159425081,259.36430780045987 -177.78215818907478,255.11032797070393,250.45075682149917 -167.2597892825757,246.0806480978211,238.53471329948312 -156.02384176333638,229.61273665893842,223.78318595584696 -144.0618046423668,218.89110733760972,212.5310121430707 -132.07125295513026,198.3253528999702,198.65365901615957 -120.64167003968433,183.87051802712685,184.63471199501183 -111.99816111911787,170.71196626313184,170.5199786025954 -103.35746609518817,155.30198600158013,158.9421934517964 -93.68434659871168,143.80608477524197,146.18355913278452 -83.1870979723749,129.1813200865881,132.89987149224856 -74.63930560134624,114.29354783389779,118.93468189644855 -66.77405304017188,98.09595063124705,107.44226422139188 -59.33920637989013,79.98619441923441,96.34015346909277 -51.629009392635986,74.08293877084728,78.9814824778216 -46.238066897370494,64.30323409122255,67.39101880851085 -43.052346829568236,49.19462719196427,57.38811690562784 -41.02708134922135,42.02238723698468,47.618877050336074 -34.950504624252645,33.629109724010284,33.53636726930454 -31.56968840198332,21.317193842664192,24.389496795049983 -29.821494545957542,19.20446609070339,19.42424196164047 -29.291420152563443,18.20020914865798,17.94161422026617 -25.640764538837267,15.612462672853287,13.298067090794396 -22.21815606029822,10.37035864672095,8.586838703223071 -20.348368009477216,4.891566681276742,7.764704835657223 -14.426641928607959,4.352589131753303,7.74535885717992 -1.7942628156016251,0.0,5.987261568084981 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/case3/ACPPowerModel.mof.json b/examples/HydroPowerModels/case3/ACPPowerModel.mof.json deleted file mode 100644 index 4c70c02..0000000 --- a/examples/HydroPowerModels/case3/ACPPowerModel.mof.json +++ /dev/null @@ -1,3799 +0,0 @@ -{ - "name": "MathOptFormat Model", - "version": { - "major": 1, - "minor": 7 - }, - "variables": [ - { - "name": "reservoir[1]_in", - "primal_start": 0.0 - }, - { - "name": "inflow[1]", - "primal_start": 0.0 - }, - { - "name": "0_vm[2]", - "primal_start": 1.0 - }, - { - "name": "0_vm[3]", - "primal_start": 1.0 - }, - { - "name": "0_vm[1]", - "primal_start": 1.0 - }, - { - "name": "0_pg[2]", - "primal_start": 0.0 - }, - { - "name": "0_pg[3]", - "primal_start": 0.0 - }, - { - "name": "0_pg[1]", - "primal_start": 0.0 - }, - { - "name": "0_qg[2]", - "primal_start": 0.0 - }, - { - "name": "0_qg[3]", - "primal_start": 0.0 - }, - { - "name": "0_qg[1]", - "primal_start": 0.0 - }, - { - "name": "0_p[(2, 3, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(3, 1, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(1, 1, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(2, 2, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(3, 2, 1)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(1, 3, 1)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(2, 3, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(3, 1, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(1, 1, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(2, 2, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(3, 2, 1)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(1, 3, 1)]", - "primal_start": 0.0 - }, - { - "name": "reservoir[1]_out", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[1]", - "primal_start": 0.0 - }, - { - "name": "outflow[1]", - "primal_start": 0.0 - }, - { - "name": "spill[1]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[1]", - "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": "0_va[2]", - "primal_start": 0.0 - }, - { - "name": "0_va[3]", - "primal_start": 0.0 - }, - { - "name": "0_va[1]", - "primal_start": 0.0 - } - ], - "objective": { - "sense": "min", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100010.0, - "variable": "deficit[1]" - }, - { - "coefficient": 100010.0, - "variable": "deficit[2]" - }, - { - "coefficient": 100010.0, - "variable": "deficit[3]" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]" - } - ], - "constant": 0.0 - } - }, - "constraints": [ - { - "name": "c1", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.09975062344139651, - "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[2]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 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.09975062344139651, - { - "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[2]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "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.9950124688279303, - { - "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": "c2", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.6450124688279302, - "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[2]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 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.9950124688279303, - { - "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[2]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "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.09975062344139651, - { - "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": "c3", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.09975062344139651, - "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[2]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 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.09975062344139651, - { - "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[2]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "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.9950124688279303, - { - "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": "c4", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 1.6450124688279302, - "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[2]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 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.9950124688279303, - { - "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[2]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "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.09975062344139651, - { - "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": "c5", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.04192604246109862, - "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[2]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 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.04192604246109862, - { - "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[2]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[1]" - ] - }, - { - "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": [ - 0.9982391062166338, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(3, 1, 2)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c6", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.8482391062166338, - "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[2]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 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.9982391062166338, - { - "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[2]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[1]" - ] - }, - { - "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.04192604246109862, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(3, 1, 2)]", - { - "type": "node", - "index": 20 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c7", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 20 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.04192604246109862, - "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[2]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 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.04192604246109862, - { - "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[2]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[1]" - ] - }, - { - "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": [ - 0.9982391062166338, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(3, 2, 1)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c8", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.8482391062166338, - "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[2]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 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.9982391062166338, - { - "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[2]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[1]" - ] - }, - { - "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.04192604246109862, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(3, 2, 1)]", - { - "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.06472653040902189, - "0_vm[1]", - "0_vm[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[1]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 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.06472653040902189, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[1]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[1]" - ] - }, - { - "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": [ - 0.9957927755234136, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(1, 1, 3)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c10", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.7707927755234136, - "0_vm[1]", - "0_vm[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[1]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 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.9957927755234136, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[1]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[1]" - ] - }, - { - "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.06472653040902189, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(1, 1, 3)]", - { - "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.06472653040902189, - "0_vm[3]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 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.06472653040902189, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[1]" - ] - }, - { - "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": [ - 0.9957927755234136, - { - "type": "node", - "index": 17 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - }, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "-", - "args": [ - "0_p[(1, 3, 1)]", - { - "type": "node", - "index": 19 - } - ] - } - ] - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c12", - "function": { - "type": "ScalarNonlinearFunction", - "root": { - "type": "node", - "index": 21 - }, - "node_list": [ - { - "type": "*", - "args": [ - 0.7707927755234136, - "0_vm[3]", - "0_vm[3]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 1 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 3 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 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.9957927755234136, - { - "type": "node", - "index": 9 - } - ] - }, - { - "type": "-", - "args": [ - { - "type": "node", - "index": 2 - }, - { - "type": "node", - "index": 10 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_vm[3]", - "0_vm[1]" - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 12 - } - ] - }, - { - "type": "*", - "args": [ - 1.0, - "0_va[3]" - ] - }, - { - "type": "*", - "args": [ - -1.0, - "0_va[1]" - ] - }, - { - "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.06472653040902189, - { - "type": "node", - "index": 18 - } - ] - }, - { - "type": "+", - "args": [ - { - "type": "node", - "index": 11 - }, - { - "type": "node", - "index": 19 - } - ] - }, - { - "type": "-", - "args": [ - "0_q[(1, 3, 1)]", - { - "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_pg[1]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c3_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c4_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c5_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c6_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c7_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]" - } - ], - "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": 1.0, - "variable": "spill[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]" - } - ], - "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_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": "c1_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]" - } - ], - "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[2]" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]" - } - ], - "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[3]" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]" - } - ], - "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[(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": 0.42250000000000004 - } - }, - { - "name": "c2_3", - "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": 0.42250000000000004 - } - }, - { - "name": "c3_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]", - "variable_2": "0_p[(3, 1, 2)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]", - "variable_2": "0_q[(3, 1, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c4_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]", - "variable_2": "0_p[(3, 2, 1)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]", - "variable_2": "0_q[(3, 2, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c5_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]", - "variable_2": "0_p[(1, 1, 3)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]", - "variable_2": "0_q[(1, 1, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c6_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]", - "variable_2": "0_p[(1, 3, 1)]" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]", - "variable_2": "0_q[(1, 3, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.18 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[1]" - }, - "set": { - "type": "EqualTo", - "value": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]" - }, - "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[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]" - }, - "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[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_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": "outflow[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]" - }, - "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": "0_vm[2]" - }, - "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[1]" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - } - ] -} diff --git a/examples/HydroPowerModels/case3/ACPPowerModel_det_equivalent.mof.json b/examples/HydroPowerModels/case3/ACPPowerModel_det_equivalent.mof.json deleted file mode 100644 index b93bb87..0000000 --- a/examples/HydroPowerModels/case3/ACPPowerModel_det_equivalent.mof.json +++ /dev/null @@ -1,57057 +0,0 @@ -{ - "name": "MathOptFormat Model", - "version": { - "major": 1, - "minor": 7 - }, - "variables": [ - { - "name": "0_vm[2]#1" - }, - { - "name": "0_vm[3]#1" - }, - { - "name": "0_vm[1]#1" - }, - { - "name": "0_pg[2]#1" - }, - { - "name": "0_pg[3]#1" - }, - { - "name": "0_pg[1]#1" - }, - { - "name": "0_qg[2]#1" - }, - { - "name": "0_qg[3]#1" - }, - { - "name": "0_qg[1]#1" - }, - { - "name": "0_p[(2, 3, 2)]#1" - }, - { - "name": "0_p[(3, 1, 2)]#1" - }, - { - "name": "0_p[(1, 1, 3)]#1" - }, - { - "name": "0_p[(2, 2, 3)]#1" - }, - { - "name": "0_p[(3, 2, 1)]#1" - }, - { - "name": "0_p[(1, 3, 1)]#1" - }, - { - "name": "0_q[(2, 3, 2)]#1" - }, - { - "name": "0_q[(3, 1, 2)]#1" - }, - { - "name": "0_q[(1, 1, 3)]#1" - }, - { - "name": "0_q[(2, 2, 3)]#1" - }, - { - "name": "0_q[(3, 2, 1)]#1" - }, - { - "name": "0_q[(1, 3, 1)]#1" - }, - { - "name": "min_volume_violation[1]#1" - }, - { - "name": "outflow[1]#1" - }, - { - "name": "spill[1]#1" - }, - { - "name": "min_outflow_violation[1]#1" - }, - { - "name": "deficit[1]#1" - }, - { - "name": "deficit[2]#1" - }, - { - "name": "deficit[3]#1" - }, - { - "name": "reservoir[1]_out#1" - }, - { - "name": "0_vm[2]#2" - }, - { - "name": "0_vm[3]#2" - }, - { - "name": "0_vm[1]#2" - }, - { - "name": "0_pg[2]#2" - }, - { - "name": "0_pg[3]#2" - }, - { - "name": "0_pg[1]#2" - }, - { - "name": "0_qg[2]#2" - }, - { - "name": "0_qg[3]#2" - }, - { - "name": "0_qg[1]#2" - }, - { - "name": "0_p[(2, 3, 2)]#2" - }, - { - "name": "0_p[(3, 1, 2)]#2" - }, - { - "name": "0_p[(1, 1, 3)]#2" - }, - { - "name": "0_p[(2, 2, 3)]#2" - }, - { - "name": "0_p[(3, 2, 1)]#2" - }, - { - "name": "0_p[(1, 3, 1)]#2" - }, - { - "name": "0_q[(2, 3, 2)]#2" - }, - { - "name": "0_q[(3, 1, 2)]#2" - }, - { - "name": "0_q[(1, 1, 3)]#2" - }, - { - "name": "0_q[(2, 2, 3)]#2" - }, - { - "name": "0_q[(3, 2, 1)]#2" - }, - { - "name": "0_q[(1, 3, 1)]#2" - }, - { - "name": "min_volume_violation[1]#2" - }, - { - "name": "outflow[1]#2" - }, - { - "name": "spill[1]#2" - }, - { - "name": "min_outflow_violation[1]#2" - }, - { - "name": "deficit[1]#2" - }, - { - "name": "deficit[2]#2" - }, - { - "name": "deficit[3]#2" - }, - { - "name": "reservoir[1]_out#2" - }, - { - "name": "0_vm[2]#3" - }, - { - "name": "0_vm[3]#3" - }, - { - "name": "0_vm[1]#3" - }, - { - "name": "0_pg[2]#3" - }, - { - "name": "0_pg[3]#3" - }, - { - "name": "0_pg[1]#3" - }, - { - "name": "0_qg[2]#3" - }, - { - "name": "0_qg[3]#3" - }, - { - "name": "0_qg[1]#3" - }, - { - "name": "0_p[(2, 3, 2)]#3" - }, - { - "name": "0_p[(3, 1, 2)]#3" - }, - { - "name": "0_p[(1, 1, 3)]#3" - }, - { - "name": "0_p[(2, 2, 3)]#3" - }, - { - "name": "0_p[(3, 2, 1)]#3" - }, - { - "name": "0_p[(1, 3, 1)]#3" - }, - { - "name": "0_q[(2, 3, 2)]#3" - }, - { - "name": "0_q[(3, 1, 2)]#3" - }, - { - "name": "0_q[(1, 1, 3)]#3" - }, - { - "name": "0_q[(2, 2, 3)]#3" - }, - { - "name": "0_q[(3, 2, 1)]#3" - }, - { - "name": "0_q[(1, 3, 1)]#3" - }, - { - "name": "min_volume_violation[1]#3" - }, - { - "name": "outflow[1]#3" - }, - { - "name": "spill[1]#3" - }, - { - "name": "min_outflow_violation[1]#3" - }, - { - "name": "deficit[1]#3" - }, - { - "name": "deficit[2]#3" - }, - { - "name": "deficit[3]#3" - }, - { - "name": "reservoir[1]_out#3" - }, - { - "name": "0_vm[2]#4" - }, - { - "name": "0_vm[3]#4" - }, - { - "name": "0_vm[1]#4" - }, - { - "name": "0_pg[2]#4" - }, - { - "name": "0_pg[3]#4" - }, - { - "name": "0_pg[1]#4" - }, - { - "name": "0_qg[2]#4" - }, - { - "name": "0_qg[3]#4" - }, - { - "name": "0_qg[1]#4" - }, - { - "name": "0_p[(2, 3, 2)]#4" - }, - { - "name": "0_p[(3, 1, 2)]#4" - }, - { - "name": "0_p[(1, 1, 3)]#4" - }, - { - "name": "0_p[(2, 2, 3)]#4" - }, - { - "name": "0_p[(3, 2, 1)]#4" - }, - { - "name": "0_p[(1, 3, 1)]#4" - }, - { - "name": "0_q[(2, 3, 2)]#4" - }, - { - "name": "0_q[(3, 1, 2)]#4" - }, - { - "name": "0_q[(1, 1, 3)]#4" - }, - { - "name": "0_q[(2, 2, 3)]#4" - }, - { - "name": "0_q[(3, 2, 1)]#4" - }, - { - "name": "0_q[(1, 3, 1)]#4" - }, - { - "name": "min_volume_violation[1]#4" - }, - { - "name": "outflow[1]#4" - }, - { - "name": "spill[1]#4" - }, - { - "name": "min_outflow_violation[1]#4" - }, - { - "name": "deficit[1]#4" - }, - { - "name": "deficit[2]#4" - }, - { - "name": "deficit[3]#4" - }, - { - "name": "reservoir[1]_out#4" - }, - { - "name": "0_vm[2]#5" - }, - { - "name": "0_vm[3]#5" - }, - { - "name": "0_vm[1]#5" - }, - { - "name": "0_pg[2]#5" - }, - { - "name": "0_pg[3]#5" - }, - { - "name": "0_pg[1]#5" - }, - { - "name": "0_qg[2]#5" - }, - { - "name": "0_qg[3]#5" - }, - { - "name": "0_qg[1]#5" - }, - { - "name": "0_p[(2, 3, 2)]#5" - }, - { - "name": "0_p[(3, 1, 2)]#5" - }, - { - "name": "0_p[(1, 1, 3)]#5" - }, - { - "name": "0_p[(2, 2, 3)]#5" - }, - { - "name": "0_p[(3, 2, 1)]#5" - }, - { - "name": "0_p[(1, 3, 1)]#5" - }, - { - "name": "0_q[(2, 3, 2)]#5" - }, - { - "name": "0_q[(3, 1, 2)]#5" - }, - { - "name": "0_q[(1, 1, 3)]#5" - }, - { - "name": "0_q[(2, 2, 3)]#5" - }, - { - "name": "0_q[(3, 2, 1)]#5" - }, - { - "name": "0_q[(1, 3, 1)]#5" - }, - { - "name": "min_volume_violation[1]#5" - }, - { - "name": "outflow[1]#5" - }, - { - "name": "spill[1]#5" - }, - { - "name": "min_outflow_violation[1]#5" - }, - { - "name": "deficit[1]#5" - }, - { - "name": "deficit[2]#5" - }, - { - "name": "deficit[3]#5" - }, - { - "name": "reservoir[1]_out#5" - }, - { - "name": "0_vm[2]#6" - }, - { - "name": "0_vm[3]#6" - }, - { - "name": "0_vm[1]#6" - }, - { - "name": "0_pg[2]#6" - }, - { - "name": "0_pg[3]#6" - }, - { - "name": "0_pg[1]#6" - }, - { - "name": "0_qg[2]#6" - }, - { - "name": "0_qg[3]#6" - }, - { - "name": "0_qg[1]#6" - }, - { - "name": "0_p[(2, 3, 2)]#6" - }, - { - "name": "0_p[(3, 1, 2)]#6" - }, - { - "name": "0_p[(1, 1, 3)]#6" - }, - { - "name": "0_p[(2, 2, 3)]#6" - }, - { - "name": "0_p[(3, 2, 1)]#6" - }, - { - "name": "0_p[(1, 3, 1)]#6" - }, - { - "name": "0_q[(2, 3, 2)]#6" - }, - { - "name": "0_q[(3, 1, 2)]#6" - }, - { - "name": "0_q[(1, 1, 3)]#6" - }, - { - "name": "0_q[(2, 2, 3)]#6" - }, - { - "name": "0_q[(3, 2, 1)]#6" - }, - { - "name": "0_q[(1, 3, 1)]#6" - }, - { - "name": "min_volume_violation[1]#6" - }, - { - "name": "outflow[1]#6" - }, - { - "name": "spill[1]#6" - }, - { - "name": "min_outflow_violation[1]#6" - }, - { - "name": "deficit[1]#6" - }, - { - "name": "deficit[2]#6" - }, - { - "name": "deficit[3]#6" - }, - { - "name": "reservoir[1]_out#6" - }, - { - "name": "0_vm[2]#7" - }, - { - "name": "0_vm[3]#7" - }, - { - "name": "0_vm[1]#7" - }, - { - "name": "0_pg[2]#7" - }, - { - "name": "0_pg[3]#7" - }, - { - "name": "0_pg[1]#7" - }, - { - "name": "0_qg[2]#7" - }, - { - "name": "0_qg[3]#7" - }, - { - "name": "0_qg[1]#7" - }, - { - "name": "0_p[(2, 3, 2)]#7" - }, - { - "name": "0_p[(3, 1, 2)]#7" - }, - { - "name": "0_p[(1, 1, 3)]#7" - }, - { - "name": "0_p[(2, 2, 3)]#7" - }, - { - "name": "0_p[(3, 2, 1)]#7" - }, - { - "name": "0_p[(1, 3, 1)]#7" - }, - { - "name": "0_q[(2, 3, 2)]#7" - }, - { - "name": "0_q[(3, 1, 2)]#7" - }, - { - "name": "0_q[(1, 1, 3)]#7" - }, - { - "name": "0_q[(2, 2, 3)]#7" - }, - { - "name": "0_q[(3, 2, 1)]#7" - }, - { - "name": "0_q[(1, 3, 1)]#7" - }, - { - "name": "min_volume_violation[1]#7" - }, - { - "name": "outflow[1]#7" - }, - { - "name": "spill[1]#7" - }, - { - "name": "min_outflow_violation[1]#7" - }, - { - "name": "deficit[1]#7" - }, - { - "name": "deficit[2]#7" - }, - { - "name": "deficit[3]#7" - }, - { - "name": "reservoir[1]_out#7" - }, - { - "name": "0_vm[2]#8" - }, - { - "name": "0_vm[3]#8" - }, - { - "name": "0_vm[1]#8" - }, - { - "name": "0_pg[2]#8" - }, - { - "name": "0_pg[3]#8" - }, - { - "name": "0_pg[1]#8" - }, - { - "name": "0_qg[2]#8" - }, - { - "name": "0_qg[3]#8" - }, - { - "name": "0_qg[1]#8" - }, - { - "name": "0_p[(2, 3, 2)]#8" - }, - { - "name": "0_p[(3, 1, 2)]#8" - }, - { - "name": "0_p[(1, 1, 3)]#8" - }, - { - "name": "0_p[(2, 2, 3)]#8" - }, - { - "name": "0_p[(3, 2, 1)]#8" - }, - { - "name": "0_p[(1, 3, 1)]#8" - }, - { - "name": "0_q[(2, 3, 2)]#8" - }, - { - "name": "0_q[(3, 1, 2)]#8" - }, - { - "name": "0_q[(1, 1, 3)]#8" - }, - { - "name": "0_q[(2, 2, 3)]#8" - }, - { - "name": "0_q[(3, 2, 1)]#8" - }, - { - "name": "0_q[(1, 3, 1)]#8" - }, - { - "name": "min_volume_violation[1]#8" - }, - { - "name": "outflow[1]#8" - }, - { - "name": "spill[1]#8" - }, - { - "name": "min_outflow_violation[1]#8" - }, - { - "name": "deficit[1]#8" - }, - { - "name": "deficit[2]#8" - }, - { - "name": "deficit[3]#8" - }, - { - "name": "reservoir[1]_out#8" - }, - { - "name": "0_vm[2]#9" - }, - { - "name": "0_vm[3]#9" - }, - { - "name": "0_vm[1]#9" - }, - { - "name": "0_pg[2]#9" - }, - { - "name": "0_pg[3]#9" - }, - { - "name": "0_pg[1]#9" - }, - { - "name": "0_qg[2]#9" - }, - { - "name": "0_qg[3]#9" - }, - { - "name": "0_qg[1]#9" - }, - { - "name": "0_p[(2, 3, 2)]#9" - }, - { - "name": "0_p[(3, 1, 2)]#9" - }, - { - "name": "0_p[(1, 1, 3)]#9" - }, - { - "name": "0_p[(2, 2, 3)]#9" - }, - { - "name": "0_p[(3, 2, 1)]#9" - }, - { - "name": "0_p[(1, 3, 1)]#9" - }, - { - "name": "0_q[(2, 3, 2)]#9" - }, - { - "name": "0_q[(3, 1, 2)]#9" - }, - { - "name": "0_q[(1, 1, 3)]#9" - }, - { - "name": "0_q[(2, 2, 3)]#9" - }, - { - "name": "0_q[(3, 2, 1)]#9" - }, - { - "name": "0_q[(1, 3, 1)]#9" - }, - { - "name": "min_volume_violation[1]#9" - }, - { - "name": "outflow[1]#9" - }, - { - "name": "spill[1]#9" - }, - { - "name": "min_outflow_violation[1]#9" - }, - { - "name": "deficit[1]#9" - }, - { - "name": "deficit[2]#9" - }, - { - "name": "deficit[3]#9" - }, - { - "name": "reservoir[1]_out#9" - }, - { - "name": "0_vm[2]#10" - }, - { - "name": "0_vm[3]#10" - }, - { - "name": "0_vm[1]#10" - }, - { - "name": "0_pg[2]#10" - }, - { - "name": "0_pg[3]#10" - }, - { - "name": "0_pg[1]#10" - }, - { - "name": "0_qg[2]#10" - }, - { - "name": "0_qg[3]#10" - }, - { - "name": "0_qg[1]#10" - }, - { - "name": "0_p[(2, 3, 2)]#10" - }, - { - "name": "0_p[(3, 1, 2)]#10" - }, - { - "name": "0_p[(1, 1, 3)]#10" - }, - { - "name": "0_p[(2, 2, 3)]#10" - }, - { - "name": "0_p[(3, 2, 1)]#10" - }, - { - "name": "0_p[(1, 3, 1)]#10" - }, - { - "name": "0_q[(2, 3, 2)]#10" - }, - { - "name": "0_q[(3, 1, 2)]#10" - }, - { - "name": "0_q[(1, 1, 3)]#10" - }, - { - "name": "0_q[(2, 2, 3)]#10" - }, - { - "name": "0_q[(3, 2, 1)]#10" - }, - { - "name": "0_q[(1, 3, 1)]#10" - }, - { - "name": "min_volume_violation[1]#10" - }, - { - "name": "outflow[1]#10" - }, - { - "name": "spill[1]#10" - }, - { - "name": "min_outflow_violation[1]#10" - }, - { - "name": "deficit[1]#10" - }, - { - "name": "deficit[2]#10" - }, - { - "name": "deficit[3]#10" - }, - { - "name": "reservoir[1]_out#10" - }, - { - "name": "0_vm[2]#11" - }, - { - "name": "0_vm[3]#11" - }, - { - "name": "0_vm[1]#11" - }, - { - "name": "0_pg[2]#11" - }, - { - "name": "0_pg[3]#11" - }, - { - "name": "0_pg[1]#11" - }, - { - "name": "0_qg[2]#11" - }, - { - "name": "0_qg[3]#11" - }, - { - "name": "0_qg[1]#11" - }, - { - "name": "0_p[(2, 3, 2)]#11" - }, - { - "name": "0_p[(3, 1, 2)]#11" - }, - { - "name": "0_p[(1, 1, 3)]#11" - }, - { - "name": "0_p[(2, 2, 3)]#11" - }, - { - "name": "0_p[(3, 2, 1)]#11" - }, - { - "name": "0_p[(1, 3, 1)]#11" - }, - { - "name": "0_q[(2, 3, 2)]#11" - }, - { - "name": "0_q[(3, 1, 2)]#11" - }, - { - "name": "0_q[(1, 1, 3)]#11" - }, - { - "name": "0_q[(2, 2, 3)]#11" - }, - { - "name": "0_q[(3, 2, 1)]#11" - }, - { - "name": "0_q[(1, 3, 1)]#11" - }, - { - "name": "min_volume_violation[1]#11" - }, - { - "name": "outflow[1]#11" - }, - { - "name": "spill[1]#11" - }, - { - "name": "min_outflow_violation[1]#11" - }, - { - "name": "deficit[1]#11" - }, - { - "name": "deficit[2]#11" - }, - { - "name": "deficit[3]#11" - }, - { - "name": "reservoir[1]_out#11" - }, - { - "name": "0_vm[2]#12" - }, - { - "name": "0_vm[3]#12" - }, - { - "name": "0_vm[1]#12" - }, - { - "name": "0_pg[2]#12" - }, - { - "name": "0_pg[3]#12" - }, - { - "name": "0_pg[1]#12" - }, - { - "name": "0_qg[2]#12" - }, - { - "name": "0_qg[3]#12" - }, - { - "name": "0_qg[1]#12" - }, - { - "name": "0_p[(2, 3, 2)]#12" - }, - { - "name": "0_p[(3, 1, 2)]#12" - }, - { - "name": "0_p[(1, 1, 3)]#12" - }, - { - "name": "0_p[(2, 2, 3)]#12" - }, - { - "name": "0_p[(3, 2, 1)]#12" - }, - { - "name": "0_p[(1, 3, 1)]#12" - }, - { - "name": "0_q[(2, 3, 2)]#12" - }, - { - "name": "0_q[(3, 1, 2)]#12" - }, - { - "name": "0_q[(1, 1, 3)]#12" - }, - { - "name": "0_q[(2, 2, 3)]#12" - }, - { - "name": "0_q[(3, 2, 1)]#12" - }, - { - "name": "0_q[(1, 3, 1)]#12" - }, - { - "name": "min_volume_violation[1]#12" - }, - { - "name": "outflow[1]#12" - }, - { - "name": "spill[1]#12" - }, - { - "name": "min_outflow_violation[1]#12" - }, - { - "name": "deficit[1]#12" - }, - { - "name": "deficit[2]#12" - }, - { - "name": "deficit[3]#12" - }, - { - "name": "reservoir[1]_out#12" - }, - { - "name": "0_vm[2]#13" - }, - { - "name": "0_vm[3]#13" - }, - { - "name": "0_vm[1]#13" - }, - { - "name": "0_pg[2]#13" - }, - { - "name": "0_pg[3]#13" - }, - { - "name": "0_pg[1]#13" - }, - { - "name": "0_qg[2]#13" - }, - { - "name": "0_qg[3]#13" - }, - { - "name": "0_qg[1]#13" - }, - { - "name": "0_p[(2, 3, 2)]#13" - }, - { - "name": "0_p[(3, 1, 2)]#13" - }, - { - "name": "0_p[(1, 1, 3)]#13" - }, - { - "name": "0_p[(2, 2, 3)]#13" - }, - { - "name": "0_p[(3, 2, 1)]#13" - }, - { - "name": "0_p[(1, 3, 1)]#13" - }, - { - "name": "0_q[(2, 3, 2)]#13" - }, - { - "name": "0_q[(3, 1, 2)]#13" - }, - { - "name": "0_q[(1, 1, 3)]#13" - }, - { - "name": "0_q[(2, 2, 3)]#13" - }, - { - "name": "0_q[(3, 2, 1)]#13" - }, - { - "name": "0_q[(1, 3, 1)]#13" - }, - { - "name": "min_volume_violation[1]#13" - }, - { - "name": "outflow[1]#13" - }, - { - "name": "spill[1]#13" - }, - { - "name": "min_outflow_violation[1]#13" - }, - { - "name": "deficit[1]#13" - }, - { - "name": "deficit[2]#13" - }, - { - "name": "deficit[3]#13" - }, - { - "name": "reservoir[1]_out#13" - }, - { - "name": "0_vm[2]#14" - }, - { - "name": "0_vm[3]#14" - }, - { - "name": "0_vm[1]#14" - }, - { - "name": "0_pg[2]#14" - }, - { - "name": "0_pg[3]#14" - }, - { - "name": "0_pg[1]#14" - }, - { - "name": "0_qg[2]#14" - }, - { - "name": "0_qg[3]#14" - }, - { - "name": "0_qg[1]#14" - }, - { - "name": "0_p[(2, 3, 2)]#14" - }, - { - "name": "0_p[(3, 1, 2)]#14" - }, - { - "name": "0_p[(1, 1, 3)]#14" - }, - { - "name": "0_p[(2, 2, 3)]#14" - }, - { - "name": "0_p[(3, 2, 1)]#14" - }, - { - "name": "0_p[(1, 3, 1)]#14" - }, - { - "name": "0_q[(2, 3, 2)]#14" - }, - { - "name": "0_q[(3, 1, 2)]#14" - }, - { - "name": "0_q[(1, 1, 3)]#14" - }, - { - "name": "0_q[(2, 2, 3)]#14" - }, - { - "name": "0_q[(3, 2, 1)]#14" - }, - { - "name": "0_q[(1, 3, 1)]#14" - }, - { - "name": "min_volume_violation[1]#14" - }, - { - "name": "outflow[1]#14" - }, - { - "name": "spill[1]#14" - }, - { - "name": "min_outflow_violation[1]#14" - }, - { - "name": "deficit[1]#14" - }, - { - "name": "deficit[2]#14" - }, - { - "name": "deficit[3]#14" - }, - { - "name": "reservoir[1]_out#14" - }, - { - "name": "0_vm[2]#15" - }, - { - "name": "0_vm[3]#15" - }, - { - "name": "0_vm[1]#15" - }, - { - "name": "0_pg[2]#15" - }, - { - "name": "0_pg[3]#15" - }, - { - "name": "0_pg[1]#15" - }, - { - "name": "0_qg[2]#15" - }, - { - "name": "0_qg[3]#15" - }, - { - "name": "0_qg[1]#15" - }, - { - "name": "0_p[(2, 3, 2)]#15" - }, - { - "name": "0_p[(3, 1, 2)]#15" - }, - { - "name": "0_p[(1, 1, 3)]#15" - }, - { - "name": "0_p[(2, 2, 3)]#15" - }, - { - "name": "0_p[(3, 2, 1)]#15" - }, - { - "name": "0_p[(1, 3, 1)]#15" - }, - { - "name": "0_q[(2, 3, 2)]#15" - }, - { - "name": "0_q[(3, 1, 2)]#15" - }, - { - "name": "0_q[(1, 1, 3)]#15" - }, - { - "name": "0_q[(2, 2, 3)]#15" - }, - { - "name": "0_q[(3, 2, 1)]#15" - }, - { - "name": "0_q[(1, 3, 1)]#15" - }, - { - "name": "min_volume_violation[1]#15" - }, - { - "name": "outflow[1]#15" - }, - { - "name": "spill[1]#15" - }, - { - "name": "min_outflow_violation[1]#15" - }, - { - "name": "deficit[1]#15" - }, - { - "name": "deficit[2]#15" - }, - { - "name": "deficit[3]#15" - }, - { - "name": "reservoir[1]_out#15" - }, - { - "name": "0_vm[2]#16" - }, - { - "name": "0_vm[3]#16" - }, - { - "name": "0_vm[1]#16" - }, - { - "name": "0_pg[2]#16" - }, - { - "name": "0_pg[3]#16" - }, - { - "name": "0_pg[1]#16" - }, - { - "name": "0_qg[2]#16" - }, - { - "name": "0_qg[3]#16" - }, - { - "name": "0_qg[1]#16" - }, - { - "name": "0_p[(2, 3, 2)]#16" - }, - { - "name": "0_p[(3, 1, 2)]#16" - }, - { - "name": "0_p[(1, 1, 3)]#16" - }, - { - "name": "0_p[(2, 2, 3)]#16" - }, - { - "name": "0_p[(3, 2, 1)]#16" - }, - { - "name": "0_p[(1, 3, 1)]#16" - }, - { - "name": "0_q[(2, 3, 2)]#16" - }, - { - "name": "0_q[(3, 1, 2)]#16" - }, - { - "name": "0_q[(1, 1, 3)]#16" - }, - { - "name": "0_q[(2, 2, 3)]#16" - }, - { - "name": "0_q[(3, 2, 1)]#16" - }, - { - "name": "0_q[(1, 3, 1)]#16" - }, - { - "name": "min_volume_violation[1]#16" - }, - { - "name": "outflow[1]#16" - }, - { - "name": "spill[1]#16" - }, - { - "name": "min_outflow_violation[1]#16" - }, - { - "name": "deficit[1]#16" - }, - { - "name": "deficit[2]#16" - }, - { - "name": "deficit[3]#16" - }, - { - "name": "reservoir[1]_out#16" - }, - { - "name": "0_vm[2]#17" - }, - { - "name": "0_vm[3]#17" - }, - { - "name": "0_vm[1]#17" - }, - { - "name": "0_pg[2]#17" - }, - { - "name": "0_pg[3]#17" - }, - { - "name": "0_pg[1]#17" - }, - { - "name": "0_qg[2]#17" - }, - { - "name": "0_qg[3]#17" - }, - { - "name": "0_qg[1]#17" - }, - { - "name": "0_p[(2, 3, 2)]#17" - }, - { - "name": "0_p[(3, 1, 2)]#17" - }, - { - "name": "0_p[(1, 1, 3)]#17" - }, - { - "name": "0_p[(2, 2, 3)]#17" - }, - { - "name": "0_p[(3, 2, 1)]#17" - }, - { - "name": "0_p[(1, 3, 1)]#17" - }, - { - "name": "0_q[(2, 3, 2)]#17" - }, - { - "name": "0_q[(3, 1, 2)]#17" - }, - { - "name": "0_q[(1, 1, 3)]#17" - }, - { - "name": "0_q[(2, 2, 3)]#17" - }, - { - "name": "0_q[(3, 2, 1)]#17" - }, - { - "name": "0_q[(1, 3, 1)]#17" - }, - { - "name": "min_volume_violation[1]#17" - }, - { - "name": "outflow[1]#17" - }, - { - "name": "spill[1]#17" - }, - { - "name": "min_outflow_violation[1]#17" - }, - { - "name": "deficit[1]#17" - }, - { - "name": "deficit[2]#17" - }, - { - "name": "deficit[3]#17" - }, - { - "name": "reservoir[1]_out#17" - }, - { - "name": "0_vm[2]#18" - }, - { - "name": "0_vm[3]#18" - }, - { - "name": "0_vm[1]#18" - }, - { - "name": "0_pg[2]#18" - }, - { - "name": "0_pg[3]#18" - }, - { - "name": "0_pg[1]#18" - }, - { - "name": "0_qg[2]#18" - }, - { - "name": "0_qg[3]#18" - }, - { - "name": "0_qg[1]#18" - }, - { - "name": "0_p[(2, 3, 2)]#18" - }, - { - "name": "0_p[(3, 1, 2)]#18" - }, - { - "name": "0_p[(1, 1, 3)]#18" - }, - { - "name": "0_p[(2, 2, 3)]#18" - }, - { - "name": "0_p[(3, 2, 1)]#18" - }, - { - "name": "0_p[(1, 3, 1)]#18" - }, - { - "name": "0_q[(2, 3, 2)]#18" - }, - { - "name": "0_q[(3, 1, 2)]#18" - }, - { - "name": "0_q[(1, 1, 3)]#18" - }, - { - "name": "0_q[(2, 2, 3)]#18" - }, - { - "name": "0_q[(3, 2, 1)]#18" - }, - { - "name": "0_q[(1, 3, 1)]#18" - }, - { - "name": "min_volume_violation[1]#18" - }, - { - "name": "outflow[1]#18" - }, - { - "name": "spill[1]#18" - }, - { - "name": "min_outflow_violation[1]#18" - }, - { - "name": "deficit[1]#18" - }, - { - "name": "deficit[2]#18" - }, - { - "name": "deficit[3]#18" - }, - { - "name": "reservoir[1]_out#18" - }, - { - "name": "0_vm[2]#19" - }, - { - "name": "0_vm[3]#19" - }, - { - "name": "0_vm[1]#19" - }, - { - "name": "0_pg[2]#19" - }, - { - "name": "0_pg[3]#19" - }, - { - "name": "0_pg[1]#19" - }, - { - "name": "0_qg[2]#19" - }, - { - "name": "0_qg[3]#19" - }, - { - "name": "0_qg[1]#19" - }, - { - "name": "0_p[(2, 3, 2)]#19" - }, - { - "name": "0_p[(3, 1, 2)]#19" - }, - { - "name": "0_p[(1, 1, 3)]#19" - }, - { - "name": "0_p[(2, 2, 3)]#19" - }, - { - "name": "0_p[(3, 2, 1)]#19" - }, - { - "name": "0_p[(1, 3, 1)]#19" - }, - { - "name": "0_q[(2, 3, 2)]#19" - }, - { - "name": "0_q[(3, 1, 2)]#19" - }, - { - "name": "0_q[(1, 1, 3)]#19" - }, - { - "name": "0_q[(2, 2, 3)]#19" - }, - { - "name": "0_q[(3, 2, 1)]#19" - }, - { - "name": "0_q[(1, 3, 1)]#19" - }, - { - "name": "min_volume_violation[1]#19" - }, - { - "name": "outflow[1]#19" - }, - { - "name": "spill[1]#19" - }, - { - "name": "min_outflow_violation[1]#19" - }, - { - "name": "deficit[1]#19" - }, - { - "name": "deficit[2]#19" - }, - { - "name": "deficit[3]#19" - }, - { - "name": "reservoir[1]_out#19" - }, - { - "name": "0_vm[2]#20" - }, - { - "name": "0_vm[3]#20" - }, - { - "name": "0_vm[1]#20" - }, - { - "name": "0_pg[2]#20" - }, - { - "name": "0_pg[3]#20" - }, - { - "name": "0_pg[1]#20" - }, - { - "name": "0_qg[2]#20" - }, - { - "name": "0_qg[3]#20" - }, - { - "name": "0_qg[1]#20" - }, - { - "name": "0_p[(2, 3, 2)]#20" - }, - { - "name": "0_p[(3, 1, 2)]#20" - }, - { - "name": "0_p[(1, 1, 3)]#20" - }, - { - "name": "0_p[(2, 2, 3)]#20" - }, - { - "name": "0_p[(3, 2, 1)]#20" - }, - { - "name": "0_p[(1, 3, 1)]#20" - }, - { - "name": "0_q[(2, 3, 2)]#20" - }, - { - "name": "0_q[(3, 1, 2)]#20" - }, - { - "name": "0_q[(1, 1, 3)]#20" - }, - { - "name": "0_q[(2, 2, 3)]#20" - }, - { - "name": "0_q[(3, 2, 1)]#20" - }, - { - "name": "0_q[(1, 3, 1)]#20" - }, - { - "name": "min_volume_violation[1]#20" - }, - { - "name": "outflow[1]#20" - }, - { - "name": "spill[1]#20" - }, - { - "name": "min_outflow_violation[1]#20" - }, - { - "name": "deficit[1]#20" - }, - { - "name": "deficit[2]#20" - }, - { - "name": "deficit[3]#20" - }, - { - "name": "reservoir[1]_out#20" - }, - { - "name": "0_vm[2]#21" - }, - { - "name": "0_vm[3]#21" - }, - { - "name": "0_vm[1]#21" - }, - { - "name": "0_pg[2]#21" - }, - { - "name": "0_pg[3]#21" - }, - { - "name": "0_pg[1]#21" - }, - { - "name": "0_qg[2]#21" - }, - { - "name": "0_qg[3]#21" - }, - { - "name": "0_qg[1]#21" - }, - { - "name": "0_p[(2, 3, 2)]#21" - }, - { - "name": "0_p[(3, 1, 2)]#21" - }, - { - "name": "0_p[(1, 1, 3)]#21" - }, - { - "name": "0_p[(2, 2, 3)]#21" - }, - { - "name": "0_p[(3, 2, 1)]#21" - }, - { - "name": "0_p[(1, 3, 1)]#21" - }, - { - "name": "0_q[(2, 3, 2)]#21" - }, - { - "name": "0_q[(3, 1, 2)]#21" - }, - { - "name": "0_q[(1, 1, 3)]#21" - }, - { - "name": "0_q[(2, 2, 3)]#21" - }, - { - "name": "0_q[(3, 2, 1)]#21" - }, - { - "name": "0_q[(1, 3, 1)]#21" - }, - { - "name": "min_volume_violation[1]#21" - }, - { - "name": "outflow[1]#21" - }, - { - "name": "spill[1]#21" - }, - { - "name": "min_outflow_violation[1]#21" - }, - { - "name": "deficit[1]#21" - }, - { - "name": "deficit[2]#21" - }, - { - "name": "deficit[3]#21" - }, - { - "name": "reservoir[1]_out#21" - }, - { - "name": "0_vm[2]#22" - }, - { - "name": "0_vm[3]#22" - }, - { - "name": "0_vm[1]#22" - }, - { - "name": "0_pg[2]#22" - }, - { - "name": "0_pg[3]#22" - }, - { - "name": "0_pg[1]#22" - }, - { - "name": "0_qg[2]#22" - }, - { - "name": "0_qg[3]#22" - }, - { - "name": "0_qg[1]#22" - }, - { - "name": "0_p[(2, 3, 2)]#22" - }, - { - "name": "0_p[(3, 1, 2)]#22" - }, - { - "name": "0_p[(1, 1, 3)]#22" - }, - { - "name": "0_p[(2, 2, 3)]#22" - }, - { - "name": "0_p[(3, 2, 1)]#22" - }, - { - "name": "0_p[(1, 3, 1)]#22" - }, - { - "name": "0_q[(2, 3, 2)]#22" - }, - { - "name": "0_q[(3, 1, 2)]#22" - }, - { - "name": "0_q[(1, 1, 3)]#22" - }, - { - "name": "0_q[(2, 2, 3)]#22" - }, - { - "name": "0_q[(3, 2, 1)]#22" - }, - { - "name": "0_q[(1, 3, 1)]#22" - }, - { - "name": "min_volume_violation[1]#22" - }, - { - "name": "outflow[1]#22" - }, - { - "name": "spill[1]#22" - }, - { - "name": "min_outflow_violation[1]#22" - }, - { - "name": "deficit[1]#22" - }, - { - "name": "deficit[2]#22" - }, - { - "name": "deficit[3]#22" - }, - { - "name": "reservoir[1]_out#22" - }, - { - "name": "0_vm[2]#23" - }, - { - "name": "0_vm[3]#23" - }, - { - "name": "0_vm[1]#23" - }, - { - "name": "0_pg[2]#23" - }, - { - "name": "0_pg[3]#23" - }, - { - "name": "0_pg[1]#23" - }, - { - "name": "0_qg[2]#23" - }, - { - "name": "0_qg[3]#23" - }, - { - "name": "0_qg[1]#23" - }, - { - "name": "0_p[(2, 3, 2)]#23" - }, - { - "name": "0_p[(3, 1, 2)]#23" - }, - { - "name": "0_p[(1, 1, 3)]#23" - }, - { - "name": "0_p[(2, 2, 3)]#23" - }, - { - "name": "0_p[(3, 2, 1)]#23" - }, - { - "name": "0_p[(1, 3, 1)]#23" - }, - { - "name": "0_q[(2, 3, 2)]#23" - }, - { - "name": "0_q[(3, 1, 2)]#23" - }, - { - "name": "0_q[(1, 1, 3)]#23" - }, - { - "name": "0_q[(2, 2, 3)]#23" - }, - { - "name": "0_q[(3, 2, 1)]#23" - }, - { - "name": "0_q[(1, 3, 1)]#23" - }, - { - "name": "min_volume_violation[1]#23" - }, - { - "name": "outflow[1]#23" - }, - { - "name": "spill[1]#23" - }, - { - "name": "min_outflow_violation[1]#23" - }, - { - "name": "deficit[1]#23" - }, - { - "name": "deficit[2]#23" - }, - { - "name": "deficit[3]#23" - }, - { - "name": "reservoir[1]_out#23" - }, - { - "name": "0_vm[2]#24" - }, - { - "name": "0_vm[3]#24" - }, - { - "name": "0_vm[1]#24" - }, - { - "name": "0_pg[2]#24" - }, - { - "name": "0_pg[3]#24" - }, - { - "name": "0_pg[1]#24" - }, - { - "name": "0_qg[2]#24" - }, - { - "name": "0_qg[3]#24" - }, - { - "name": "0_qg[1]#24" - }, - { - "name": "0_p[(2, 3, 2)]#24" - }, - { - "name": "0_p[(3, 1, 2)]#24" - }, - { - "name": "0_p[(1, 1, 3)]#24" - }, - { - "name": "0_p[(2, 2, 3)]#24" - }, - { - "name": "0_p[(3, 2, 1)]#24" - }, - { - "name": "0_p[(1, 3, 1)]#24" - }, - { - "name": "0_q[(2, 3, 2)]#24" - }, - { - "name": "0_q[(3, 1, 2)]#24" - }, - { - "name": "0_q[(1, 1, 3)]#24" - }, - { - "name": "0_q[(2, 2, 3)]#24" - }, - { - "name": "0_q[(3, 2, 1)]#24" - }, - { - "name": "0_q[(1, 3, 1)]#24" - }, - { - "name": "min_volume_violation[1]#24" - }, - { - "name": "outflow[1]#24" - }, - { - "name": "spill[1]#24" - }, - { - "name": "min_outflow_violation[1]#24" - }, - { - "name": "deficit[1]#24" - }, - { - "name": "deficit[2]#24" - }, - { - "name": "deficit[3]#24" - }, - { - "name": "reservoir[1]_out#24" - }, - { - "name": "0_vm[2]#25" - }, - { - "name": "0_vm[3]#25" - }, - { - "name": "0_vm[1]#25" - }, - { - "name": "0_pg[2]#25" - }, - { - "name": "0_pg[3]#25" - }, - { - "name": "0_pg[1]#25" - }, - { - "name": "0_qg[2]#25" - }, - { - "name": "0_qg[3]#25" - }, - { - "name": "0_qg[1]#25" - }, - { - "name": "0_p[(2, 3, 2)]#25" - }, - { - "name": "0_p[(3, 1, 2)]#25" - }, - { - "name": "0_p[(1, 1, 3)]#25" - }, - { - "name": "0_p[(2, 2, 3)]#25" - }, - { - "name": "0_p[(3, 2, 1)]#25" - }, - { - "name": "0_p[(1, 3, 1)]#25" - }, - { - "name": "0_q[(2, 3, 2)]#25" - }, - { - "name": "0_q[(3, 1, 2)]#25" - }, - { - "name": "0_q[(1, 1, 3)]#25" - }, - { - "name": "0_q[(2, 2, 3)]#25" - }, - { - "name": "0_q[(3, 2, 1)]#25" - }, - { - "name": "0_q[(1, 3, 1)]#25" - }, - { - "name": "min_volume_violation[1]#25" - }, - { - "name": "outflow[1]#25" - }, - { - "name": "spill[1]#25" - }, - { - "name": "min_outflow_violation[1]#25" - }, - { - "name": "deficit[1]#25" - }, - { - "name": "deficit[2]#25" - }, - { - "name": "deficit[3]#25" - }, - { - "name": "reservoir[1]_out#25" - }, - { - "name": "0_vm[2]#26" - }, - { - "name": "0_vm[3]#26" - }, - { - "name": "0_vm[1]#26" - }, - { - "name": "0_pg[2]#26" - }, - { - "name": "0_pg[3]#26" - }, - { - "name": "0_pg[1]#26" - }, - { - "name": "0_qg[2]#26" - }, - { - "name": "0_qg[3]#26" - }, - { - "name": "0_qg[1]#26" - }, - { - "name": "0_p[(2, 3, 2)]#26" - }, - { - "name": "0_p[(3, 1, 2)]#26" - }, - { - "name": "0_p[(1, 1, 3)]#26" - }, - { - "name": "0_p[(2, 2, 3)]#26" - }, - { - "name": "0_p[(3, 2, 1)]#26" - }, - { - "name": "0_p[(1, 3, 1)]#26" - }, - { - "name": "0_q[(2, 3, 2)]#26" - }, - { - "name": "0_q[(3, 1, 2)]#26" - }, - { - "name": "0_q[(1, 1, 3)]#26" - }, - { - "name": "0_q[(2, 2, 3)]#26" - }, - { - "name": "0_q[(3, 2, 1)]#26" - }, - { - "name": "0_q[(1, 3, 1)]#26" - }, - { - "name": "min_volume_violation[1]#26" - }, - { - "name": "outflow[1]#26" - }, - { - "name": "spill[1]#26" - }, - { - "name": "min_outflow_violation[1]#26" - }, - { - "name": "deficit[1]#26" - }, - { - "name": "deficit[2]#26" - }, - { - "name": "deficit[3]#26" - }, - { - "name": "reservoir[1]_out#26" - }, - { - "name": "0_vm[2]#27" - }, - { - "name": "0_vm[3]#27" - }, - { - "name": "0_vm[1]#27" - }, - { - "name": "0_pg[2]#27" - }, - { - "name": "0_pg[3]#27" - }, - { - "name": "0_pg[1]#27" - }, - { - "name": "0_qg[2]#27" - }, - { - "name": "0_qg[3]#27" - }, - { - "name": "0_qg[1]#27" - }, - { - "name": "0_p[(2, 3, 2)]#27" - }, - { - "name": "0_p[(3, 1, 2)]#27" - }, - { - "name": "0_p[(1, 1, 3)]#27" - }, - { - "name": "0_p[(2, 2, 3)]#27" - }, - { - "name": "0_p[(3, 2, 1)]#27" - }, - { - "name": "0_p[(1, 3, 1)]#27" - }, - { - "name": "0_q[(2, 3, 2)]#27" - }, - { - "name": "0_q[(3, 1, 2)]#27" - }, - { - "name": "0_q[(1, 1, 3)]#27" - }, - { - "name": "0_q[(2, 2, 3)]#27" - }, - { - "name": "0_q[(3, 2, 1)]#27" - }, - { - "name": "0_q[(1, 3, 1)]#27" - }, - { - "name": "min_volume_violation[1]#27" - }, - { - "name": "outflow[1]#27" - }, - { - "name": "spill[1]#27" - }, - { - "name": "min_outflow_violation[1]#27" - }, - { - "name": "deficit[1]#27" - }, - { - "name": "deficit[2]#27" - }, - { - "name": "deficit[3]#27" - }, - { - "name": "reservoir[1]_out#27" - }, - { - "name": "0_vm[2]#28" - }, - { - "name": "0_vm[3]#28" - }, - { - "name": "0_vm[1]#28" - }, - { - "name": "0_pg[2]#28" - }, - { - "name": "0_pg[3]#28" - }, - { - "name": "0_pg[1]#28" - }, - { - "name": "0_qg[2]#28" - }, - { - "name": "0_qg[3]#28" - }, - { - "name": "0_qg[1]#28" - }, - { - "name": "0_p[(2, 3, 2)]#28" - }, - { - "name": "0_p[(3, 1, 2)]#28" - }, - { - "name": "0_p[(1, 1, 3)]#28" - }, - { - "name": "0_p[(2, 2, 3)]#28" - }, - { - "name": "0_p[(3, 2, 1)]#28" - }, - { - "name": "0_p[(1, 3, 1)]#28" - }, - { - "name": "0_q[(2, 3, 2)]#28" - }, - { - "name": "0_q[(3, 1, 2)]#28" - }, - { - "name": "0_q[(1, 1, 3)]#28" - }, - { - "name": "0_q[(2, 2, 3)]#28" - }, - { - "name": "0_q[(3, 2, 1)]#28" - }, - { - "name": "0_q[(1, 3, 1)]#28" - }, - { - "name": "min_volume_violation[1]#28" - }, - { - "name": "outflow[1]#28" - }, - { - "name": "spill[1]#28" - }, - { - "name": "min_outflow_violation[1]#28" - }, - { - "name": "deficit[1]#28" - }, - { - "name": "deficit[2]#28" - }, - { - "name": "deficit[3]#28" - }, - { - "name": "reservoir[1]_out#28" - }, - { - "name": "0_vm[2]#29" - }, - { - "name": "0_vm[3]#29" - }, - { - "name": "0_vm[1]#29" - }, - { - "name": "0_pg[2]#29" - }, - { - "name": "0_pg[3]#29" - }, - { - "name": "0_pg[1]#29" - }, - { - "name": "0_qg[2]#29" - }, - { - "name": "0_qg[3]#29" - }, - { - "name": "0_qg[1]#29" - }, - { - "name": "0_p[(2, 3, 2)]#29" - }, - { - "name": "0_p[(3, 1, 2)]#29" - }, - { - "name": "0_p[(1, 1, 3)]#29" - }, - { - "name": "0_p[(2, 2, 3)]#29" - }, - { - "name": "0_p[(3, 2, 1)]#29" - }, - { - "name": "0_p[(1, 3, 1)]#29" - }, - { - "name": "0_q[(2, 3, 2)]#29" - }, - { - "name": "0_q[(3, 1, 2)]#29" - }, - { - "name": "0_q[(1, 1, 3)]#29" - }, - { - "name": "0_q[(2, 2, 3)]#29" - }, - { - "name": "0_q[(3, 2, 1)]#29" - }, - { - "name": "0_q[(1, 3, 1)]#29" - }, - { - "name": "min_volume_violation[1]#29" - }, - { - "name": "outflow[1]#29" - }, - { - "name": "spill[1]#29" - }, - { - "name": "min_outflow_violation[1]#29" - }, - { - "name": "deficit[1]#29" - }, - { - "name": "deficit[2]#29" - }, - { - "name": "deficit[3]#29" - }, - { - "name": "reservoir[1]_out#29" - }, - { - "name": "0_vm[2]#30" - }, - { - "name": "0_vm[3]#30" - }, - { - "name": "0_vm[1]#30" - }, - { - "name": "0_pg[2]#30" - }, - { - "name": "0_pg[3]#30" - }, - { - "name": "0_pg[1]#30" - }, - { - "name": "0_qg[2]#30" - }, - { - "name": "0_qg[3]#30" - }, - { - "name": "0_qg[1]#30" - }, - { - "name": "0_p[(2, 3, 2)]#30" - }, - { - "name": "0_p[(3, 1, 2)]#30" - }, - { - "name": "0_p[(1, 1, 3)]#30" - }, - { - "name": "0_p[(2, 2, 3)]#30" - }, - { - "name": "0_p[(3, 2, 1)]#30" - }, - { - "name": "0_p[(1, 3, 1)]#30" - }, - { - "name": "0_q[(2, 3, 2)]#30" - }, - { - "name": "0_q[(3, 1, 2)]#30" - }, - { - "name": "0_q[(1, 1, 3)]#30" - }, - { - "name": "0_q[(2, 2, 3)]#30" - }, - { - "name": "0_q[(3, 2, 1)]#30" - }, - { - "name": "0_q[(1, 3, 1)]#30" - }, - { - "name": "min_volume_violation[1]#30" - }, - { - "name": "outflow[1]#30" - }, - { - "name": "spill[1]#30" - }, - { - "name": "min_outflow_violation[1]#30" - }, - { - "name": "deficit[1]#30" - }, - { - "name": "deficit[2]#30" - }, - { - "name": "deficit[3]#30" - }, - { - "name": "reservoir[1]_out#30" - }, - { - "name": "0_vm[2]#31" - }, - { - "name": "0_vm[3]#31" - }, - { - "name": "0_vm[1]#31" - }, - { - "name": "0_pg[2]#31" - }, - { - "name": "0_pg[3]#31" - }, - { - "name": "0_pg[1]#31" - }, - { - "name": "0_qg[2]#31" - }, - { - "name": "0_qg[3]#31" - }, - { - "name": "0_qg[1]#31" - }, - { - "name": "0_p[(2, 3, 2)]#31" - }, - { - "name": "0_p[(3, 1, 2)]#31" - }, - { - "name": "0_p[(1, 1, 3)]#31" - }, - { - "name": "0_p[(2, 2, 3)]#31" - }, - { - "name": "0_p[(3, 2, 1)]#31" - }, - { - "name": "0_p[(1, 3, 1)]#31" - }, - { - "name": "0_q[(2, 3, 2)]#31" - }, - { - "name": "0_q[(3, 1, 2)]#31" - }, - { - "name": "0_q[(1, 1, 3)]#31" - }, - { - "name": "0_q[(2, 2, 3)]#31" - }, - { - "name": "0_q[(3, 2, 1)]#31" - }, - { - "name": "0_q[(1, 3, 1)]#31" - }, - { - "name": "min_volume_violation[1]#31" - }, - { - "name": "outflow[1]#31" - }, - { - "name": "spill[1]#31" - }, - { - "name": "min_outflow_violation[1]#31" - }, - { - "name": "deficit[1]#31" - }, - { - "name": "deficit[2]#31" - }, - { - "name": "deficit[3]#31" - }, - { - "name": "reservoir[1]_out#31" - }, - { - "name": "0_vm[2]#32" - }, - { - "name": "0_vm[3]#32" - }, - { - "name": "0_vm[1]#32" - }, - { - "name": "0_pg[2]#32" - }, - { - "name": "0_pg[3]#32" - }, - { - "name": "0_pg[1]#32" - }, - { - "name": "0_qg[2]#32" - }, - { - "name": "0_qg[3]#32" - }, - { - "name": "0_qg[1]#32" - }, - { - "name": "0_p[(2, 3, 2)]#32" - }, - { - "name": "0_p[(3, 1, 2)]#32" - }, - { - "name": "0_p[(1, 1, 3)]#32" - }, - { - "name": "0_p[(2, 2, 3)]#32" - }, - { - "name": "0_p[(3, 2, 1)]#32" - }, - { - "name": "0_p[(1, 3, 1)]#32" - }, - { - "name": "0_q[(2, 3, 2)]#32" - }, - { - "name": "0_q[(3, 1, 2)]#32" - }, - { - "name": "0_q[(1, 1, 3)]#32" - }, - { - "name": "0_q[(2, 2, 3)]#32" - }, - { - "name": "0_q[(3, 2, 1)]#32" - }, - { - "name": "0_q[(1, 3, 1)]#32" - }, - { - "name": "min_volume_violation[1]#32" - }, - { - "name": "outflow[1]#32" - }, - { - "name": "spill[1]#32" - }, - { - "name": "min_outflow_violation[1]#32" - }, - { - "name": "deficit[1]#32" - }, - { - "name": "deficit[2]#32" - }, - { - "name": "deficit[3]#32" - }, - { - "name": "reservoir[1]_out#32" - }, - { - "name": "0_vm[2]#33" - }, - { - "name": "0_vm[3]#33" - }, - { - "name": "0_vm[1]#33" - }, - { - "name": "0_pg[2]#33" - }, - { - "name": "0_pg[3]#33" - }, - { - "name": "0_pg[1]#33" - }, - { - "name": "0_qg[2]#33" - }, - { - "name": "0_qg[3]#33" - }, - { - "name": "0_qg[1]#33" - }, - { - "name": "0_p[(2, 3, 2)]#33" - }, - { - "name": "0_p[(3, 1, 2)]#33" - }, - { - "name": "0_p[(1, 1, 3)]#33" - }, - { - "name": "0_p[(2, 2, 3)]#33" - }, - { - "name": "0_p[(3, 2, 1)]#33" - }, - { - "name": "0_p[(1, 3, 1)]#33" - }, - { - "name": "0_q[(2, 3, 2)]#33" - }, - { - "name": "0_q[(3, 1, 2)]#33" - }, - { - "name": "0_q[(1, 1, 3)]#33" - }, - { - "name": "0_q[(2, 2, 3)]#33" - }, - { - "name": "0_q[(3, 2, 1)]#33" - }, - { - "name": "0_q[(1, 3, 1)]#33" - }, - { - "name": "min_volume_violation[1]#33" - }, - { - "name": "outflow[1]#33" - }, - { - "name": "spill[1]#33" - }, - { - "name": "min_outflow_violation[1]#33" - }, - { - "name": "deficit[1]#33" - }, - { - "name": "deficit[2]#33" - }, - { - "name": "deficit[3]#33" - }, - { - "name": "reservoir[1]_out#33" - }, - { - "name": "0_vm[2]#34" - }, - { - "name": "0_vm[3]#34" - }, - { - "name": "0_vm[1]#34" - }, - { - "name": "0_pg[2]#34" - }, - { - "name": "0_pg[3]#34" - }, - { - "name": "0_pg[1]#34" - }, - { - "name": "0_qg[2]#34" - }, - { - "name": "0_qg[3]#34" - }, - { - "name": "0_qg[1]#34" - }, - { - "name": "0_p[(2, 3, 2)]#34" - }, - { - "name": "0_p[(3, 1, 2)]#34" - }, - { - "name": "0_p[(1, 1, 3)]#34" - }, - { - "name": "0_p[(2, 2, 3)]#34" - }, - { - "name": "0_p[(3, 2, 1)]#34" - }, - { - "name": "0_p[(1, 3, 1)]#34" - }, - { - "name": "0_q[(2, 3, 2)]#34" - }, - { - "name": "0_q[(3, 1, 2)]#34" - }, - { - "name": "0_q[(1, 1, 3)]#34" - }, - { - "name": "0_q[(2, 2, 3)]#34" - }, - { - "name": "0_q[(3, 2, 1)]#34" - }, - { - "name": "0_q[(1, 3, 1)]#34" - }, - { - "name": "min_volume_violation[1]#34" - }, - { - "name": "outflow[1]#34" - }, - { - "name": "spill[1]#34" - }, - { - "name": "min_outflow_violation[1]#34" - }, - { - "name": "deficit[1]#34" - }, - { - "name": "deficit[2]#34" - }, - { - "name": "deficit[3]#34" - }, - { - "name": "reservoir[1]_out#34" - }, - { - "name": "0_vm[2]#35" - }, - { - "name": "0_vm[3]#35" - }, - { - "name": "0_vm[1]#35" - }, - { - "name": "0_pg[2]#35" - }, - { - "name": "0_pg[3]#35" - }, - { - "name": "0_pg[1]#35" - }, - { - "name": "0_qg[2]#35" - }, - { - "name": "0_qg[3]#35" - }, - { - "name": "0_qg[1]#35" - }, - { - "name": "0_p[(2, 3, 2)]#35" - }, - { - "name": "0_p[(3, 1, 2)]#35" - }, - { - "name": "0_p[(1, 1, 3)]#35" - }, - { - "name": "0_p[(2, 2, 3)]#35" - }, - { - "name": "0_p[(3, 2, 1)]#35" - }, - { - "name": "0_p[(1, 3, 1)]#35" - }, - { - "name": "0_q[(2, 3, 2)]#35" - }, - { - "name": "0_q[(3, 1, 2)]#35" - }, - { - "name": "0_q[(1, 1, 3)]#35" - }, - { - "name": "0_q[(2, 2, 3)]#35" - }, - { - "name": "0_q[(3, 2, 1)]#35" - }, - { - "name": "0_q[(1, 3, 1)]#35" - }, - { - "name": "min_volume_violation[1]#35" - }, - { - "name": "outflow[1]#35" - }, - { - "name": "spill[1]#35" - }, - { - "name": "min_outflow_violation[1]#35" - }, - { - "name": "deficit[1]#35" - }, - { - "name": "deficit[2]#35" - }, - { - "name": "deficit[3]#35" - }, - { - "name": "reservoir[1]_out#35" - }, - { - "name": "0_vm[2]#36" - }, - { - "name": "0_vm[3]#36" - }, - { - "name": "0_vm[1]#36" - }, - { - "name": "0_pg[2]#36" - }, - { - "name": "0_pg[3]#36" - }, - { - "name": "0_pg[1]#36" - }, - { - "name": "0_qg[2]#36" - }, - { - "name": "0_qg[3]#36" - }, - { - "name": "0_qg[1]#36" - }, - { - "name": "0_p[(2, 3, 2)]#36" - }, - { - "name": "0_p[(3, 1, 2)]#36" - }, - { - "name": "0_p[(1, 1, 3)]#36" - }, - { - "name": "0_p[(2, 2, 3)]#36" - }, - { - "name": "0_p[(3, 2, 1)]#36" - }, - { - "name": "0_p[(1, 3, 1)]#36" - }, - { - "name": "0_q[(2, 3, 2)]#36" - }, - { - "name": "0_q[(3, 1, 2)]#36" - }, - { - "name": "0_q[(1, 1, 3)]#36" - }, - { - "name": "0_q[(2, 2, 3)]#36" - }, - { - "name": "0_q[(3, 2, 1)]#36" - }, - { - "name": "0_q[(1, 3, 1)]#36" - }, - { - "name": "min_volume_violation[1]#36" - }, - { - "name": "outflow[1]#36" - }, - { - "name": "spill[1]#36" - }, - { - "name": "min_outflow_violation[1]#36" - }, - { - "name": "deficit[1]#36" - }, - { - "name": "deficit[2]#36" - }, - { - "name": "deficit[3]#36" - }, - { - "name": "reservoir[1]_out#36" - }, - { - "name": "0_vm[2]#37" - }, - { - "name": "0_vm[3]#37" - }, - { - "name": "0_vm[1]#37" - }, - { - "name": "0_pg[2]#37" - }, - { - "name": "0_pg[3]#37" - }, - { - "name": "0_pg[1]#37" - }, - { - "name": "0_qg[2]#37" - }, - { - "name": "0_qg[3]#37" - }, - { - "name": "0_qg[1]#37" - }, - { - "name": "0_p[(2, 3, 2)]#37" - }, - { - "name": "0_p[(3, 1, 2)]#37" - }, - { - "name": "0_p[(1, 1, 3)]#37" - }, - { - "name": "0_p[(2, 2, 3)]#37" - }, - { - "name": "0_p[(3, 2, 1)]#37" - }, - { - "name": "0_p[(1, 3, 1)]#37" - }, - { - "name": "0_q[(2, 3, 2)]#37" - }, - { - "name": "0_q[(3, 1, 2)]#37" - }, - { - "name": "0_q[(1, 1, 3)]#37" - }, - { - "name": "0_q[(2, 2, 3)]#37" - }, - { - "name": "0_q[(3, 2, 1)]#37" - }, - { - "name": "0_q[(1, 3, 1)]#37" - }, - { - "name": "min_volume_violation[1]#37" - }, - { - "name": "outflow[1]#37" - }, - { - "name": "spill[1]#37" - }, - { - "name": "min_outflow_violation[1]#37" - }, - { - "name": "deficit[1]#37" - }, - { - "name": "deficit[2]#37" - }, - { - "name": "deficit[3]#37" - }, - { - "name": "reservoir[1]_out#37" - }, - { - "name": "0_vm[2]#38" - }, - { - "name": "0_vm[3]#38" - }, - { - "name": "0_vm[1]#38" - }, - { - "name": "0_pg[2]#38" - }, - { - "name": "0_pg[3]#38" - }, - { - "name": "0_pg[1]#38" - }, - { - "name": "0_qg[2]#38" - }, - { - "name": "0_qg[3]#38" - }, - { - "name": "0_qg[1]#38" - }, - { - "name": "0_p[(2, 3, 2)]#38" - }, - { - "name": "0_p[(3, 1, 2)]#38" - }, - { - "name": "0_p[(1, 1, 3)]#38" - }, - { - "name": "0_p[(2, 2, 3)]#38" - }, - { - "name": "0_p[(3, 2, 1)]#38" - }, - { - "name": "0_p[(1, 3, 1)]#38" - }, - { - "name": "0_q[(2, 3, 2)]#38" - }, - { - "name": "0_q[(3, 1, 2)]#38" - }, - { - "name": "0_q[(1, 1, 3)]#38" - }, - { - "name": "0_q[(2, 2, 3)]#38" - }, - { - "name": "0_q[(3, 2, 1)]#38" - }, - { - "name": "0_q[(1, 3, 1)]#38" - }, - { - "name": "min_volume_violation[1]#38" - }, - { - "name": "outflow[1]#38" - }, - { - "name": "spill[1]#38" - }, - { - "name": "min_outflow_violation[1]#38" - }, - { - "name": "deficit[1]#38" - }, - { - "name": "deficit[2]#38" - }, - { - "name": "deficit[3]#38" - }, - { - "name": "reservoir[1]_out#38" - }, - { - "name": "0_vm[2]#39" - }, - { - "name": "0_vm[3]#39" - }, - { - "name": "0_vm[1]#39" - }, - { - "name": "0_pg[2]#39" - }, - { - "name": "0_pg[3]#39" - }, - { - "name": "0_pg[1]#39" - }, - { - "name": "0_qg[2]#39" - }, - { - "name": "0_qg[3]#39" - }, - { - "name": "0_qg[1]#39" - }, - { - "name": "0_p[(2, 3, 2)]#39" - }, - { - "name": "0_p[(3, 1, 2)]#39" - }, - { - "name": "0_p[(1, 1, 3)]#39" - }, - { - "name": "0_p[(2, 2, 3)]#39" - }, - { - "name": "0_p[(3, 2, 1)]#39" - }, - { - "name": "0_p[(1, 3, 1)]#39" - }, - { - "name": "0_q[(2, 3, 2)]#39" - }, - { - "name": "0_q[(3, 1, 2)]#39" - }, - { - "name": "0_q[(1, 1, 3)]#39" - }, - { - "name": "0_q[(2, 2, 3)]#39" - }, - { - "name": "0_q[(3, 2, 1)]#39" - }, - { - "name": "0_q[(1, 3, 1)]#39" - }, - { - "name": "min_volume_violation[1]#39" - }, - { - "name": "outflow[1]#39" - }, - { - "name": "spill[1]#39" - }, - { - "name": "min_outflow_violation[1]#39" - }, - { - "name": "deficit[1]#39" - }, - { - "name": "deficit[2]#39" - }, - { - "name": "deficit[3]#39" - }, - { - "name": "reservoir[1]_out#39" - }, - { - "name": "0_vm[2]#40" - }, - { - "name": "0_vm[3]#40" - }, - { - "name": "0_vm[1]#40" - }, - { - "name": "0_pg[2]#40" - }, - { - "name": "0_pg[3]#40" - }, - { - "name": "0_pg[1]#40" - }, - { - "name": "0_qg[2]#40" - }, - { - "name": "0_qg[3]#40" - }, - { - "name": "0_qg[1]#40" - }, - { - "name": "0_p[(2, 3, 2)]#40" - }, - { - "name": "0_p[(3, 1, 2)]#40" - }, - { - "name": "0_p[(1, 1, 3)]#40" - }, - { - "name": "0_p[(2, 2, 3)]#40" - }, - { - "name": "0_p[(3, 2, 1)]#40" - }, - { - "name": "0_p[(1, 3, 1)]#40" - }, - { - "name": "0_q[(2, 3, 2)]#40" - }, - { - "name": "0_q[(3, 1, 2)]#40" - }, - { - "name": "0_q[(1, 1, 3)]#40" - }, - { - "name": "0_q[(2, 2, 3)]#40" - }, - { - "name": "0_q[(3, 2, 1)]#40" - }, - { - "name": "0_q[(1, 3, 1)]#40" - }, - { - "name": "min_volume_violation[1]#40" - }, - { - "name": "outflow[1]#40" - }, - { - "name": "spill[1]#40" - }, - { - "name": "min_outflow_violation[1]#40" - }, - { - "name": "deficit[1]#40" - }, - { - "name": "deficit[2]#40" - }, - { - "name": "deficit[3]#40" - }, - { - "name": "reservoir[1]_out#40" - }, - { - "name": "0_vm[2]#41" - }, - { - "name": "0_vm[3]#41" - }, - { - "name": "0_vm[1]#41" - }, - { - "name": "0_pg[2]#41" - }, - { - "name": "0_pg[3]#41" - }, - { - "name": "0_pg[1]#41" - }, - { - "name": "0_qg[2]#41" - }, - { - "name": "0_qg[3]#41" - }, - { - "name": "0_qg[1]#41" - }, - { - "name": "0_p[(2, 3, 2)]#41" - }, - { - "name": "0_p[(3, 1, 2)]#41" - }, - { - "name": "0_p[(1, 1, 3)]#41" - }, - { - "name": "0_p[(2, 2, 3)]#41" - }, - { - "name": "0_p[(3, 2, 1)]#41" - }, - { - "name": "0_p[(1, 3, 1)]#41" - }, - { - "name": "0_q[(2, 3, 2)]#41" - }, - { - "name": "0_q[(3, 1, 2)]#41" - }, - { - "name": "0_q[(1, 1, 3)]#41" - }, - { - "name": "0_q[(2, 2, 3)]#41" - }, - { - "name": "0_q[(3, 2, 1)]#41" - }, - { - "name": "0_q[(1, 3, 1)]#41" - }, - { - "name": "min_volume_violation[1]#41" - }, - { - "name": "outflow[1]#41" - }, - { - "name": "spill[1]#41" - }, - { - "name": "min_outflow_violation[1]#41" - }, - { - "name": "deficit[1]#41" - }, - { - "name": "deficit[2]#41" - }, - { - "name": "deficit[3]#41" - }, - { - "name": "reservoir[1]_out#41" - }, - { - "name": "0_vm[2]#42" - }, - { - "name": "0_vm[3]#42" - }, - { - "name": "0_vm[1]#42" - }, - { - "name": "0_pg[2]#42" - }, - { - "name": "0_pg[3]#42" - }, - { - "name": "0_pg[1]#42" - }, - { - "name": "0_qg[2]#42" - }, - { - "name": "0_qg[3]#42" - }, - { - "name": "0_qg[1]#42" - }, - { - "name": "0_p[(2, 3, 2)]#42" - }, - { - "name": "0_p[(3, 1, 2)]#42" - }, - { - "name": "0_p[(1, 1, 3)]#42" - }, - { - "name": "0_p[(2, 2, 3)]#42" - }, - { - "name": "0_p[(3, 2, 1)]#42" - }, - { - "name": "0_p[(1, 3, 1)]#42" - }, - { - "name": "0_q[(2, 3, 2)]#42" - }, - { - "name": "0_q[(3, 1, 2)]#42" - }, - { - "name": "0_q[(1, 1, 3)]#42" - }, - { - "name": "0_q[(2, 2, 3)]#42" - }, - { - "name": "0_q[(3, 2, 1)]#42" - }, - { - "name": "0_q[(1, 3, 1)]#42" - }, - { - "name": "min_volume_violation[1]#42" - }, - { - "name": "outflow[1]#42" - }, - { - "name": "spill[1]#42" - }, - { - "name": "min_outflow_violation[1]#42" - }, - { - "name": "deficit[1]#42" - }, - { - "name": "deficit[2]#42" - }, - { - "name": "deficit[3]#42" - }, - { - "name": "reservoir[1]_out#42" - }, - { - "name": "0_vm[2]#43" - }, - { - "name": "0_vm[3]#43" - }, - { - "name": "0_vm[1]#43" - }, - { - "name": "0_pg[2]#43" - }, - { - "name": "0_pg[3]#43" - }, - { - "name": "0_pg[1]#43" - }, - { - "name": "0_qg[2]#43" - }, - { - "name": "0_qg[3]#43" - }, - { - "name": "0_qg[1]#43" - }, - { - "name": "0_p[(2, 3, 2)]#43" - }, - { - "name": "0_p[(3, 1, 2)]#43" - }, - { - "name": "0_p[(1, 1, 3)]#43" - }, - { - "name": "0_p[(2, 2, 3)]#43" - }, - { - "name": "0_p[(3, 2, 1)]#43" - }, - { - "name": "0_p[(1, 3, 1)]#43" - }, - { - "name": "0_q[(2, 3, 2)]#43" - }, - { - "name": "0_q[(3, 1, 2)]#43" - }, - { - "name": "0_q[(1, 1, 3)]#43" - }, - { - "name": "0_q[(2, 2, 3)]#43" - }, - { - "name": "0_q[(3, 2, 1)]#43" - }, - { - "name": "0_q[(1, 3, 1)]#43" - }, - { - "name": "min_volume_violation[1]#43" - }, - { - "name": "outflow[1]#43" - }, - { - "name": "spill[1]#43" - }, - { - "name": "min_outflow_violation[1]#43" - }, - { - "name": "deficit[1]#43" - }, - { - "name": "deficit[2]#43" - }, - { - "name": "deficit[3]#43" - }, - { - "name": "reservoir[1]_out#43" - }, - { - "name": "0_vm[2]#44" - }, - { - "name": "0_vm[3]#44" - }, - { - "name": "0_vm[1]#44" - }, - { - "name": "0_pg[2]#44" - }, - { - "name": "0_pg[3]#44" - }, - { - "name": "0_pg[1]#44" - }, - { - "name": "0_qg[2]#44" - }, - { - "name": "0_qg[3]#44" - }, - { - "name": "0_qg[1]#44" - }, - { - "name": "0_p[(2, 3, 2)]#44" - }, - { - "name": "0_p[(3, 1, 2)]#44" - }, - { - "name": "0_p[(1, 1, 3)]#44" - }, - { - "name": "0_p[(2, 2, 3)]#44" - }, - { - "name": "0_p[(3, 2, 1)]#44" - }, - { - "name": "0_p[(1, 3, 1)]#44" - }, - { - "name": "0_q[(2, 3, 2)]#44" - }, - { - "name": "0_q[(3, 1, 2)]#44" - }, - { - "name": "0_q[(1, 1, 3)]#44" - }, - { - "name": "0_q[(2, 2, 3)]#44" - }, - { - "name": "0_q[(3, 2, 1)]#44" - }, - { - "name": "0_q[(1, 3, 1)]#44" - }, - { - "name": "min_volume_violation[1]#44" - }, - { - "name": "outflow[1]#44" - }, - { - "name": "spill[1]#44" - }, - { - "name": "min_outflow_violation[1]#44" - }, - { - "name": "deficit[1]#44" - }, - { - "name": "deficit[2]#44" - }, - { - "name": "deficit[3]#44" - }, - { - "name": "reservoir[1]_out#44" - }, - { - "name": "0_vm[2]#45" - }, - { - "name": "0_vm[3]#45" - }, - { - "name": "0_vm[1]#45" - }, - { - "name": "0_pg[2]#45" - }, - { - "name": "0_pg[3]#45" - }, - { - "name": "0_pg[1]#45" - }, - { - "name": "0_qg[2]#45" - }, - { - "name": "0_qg[3]#45" - }, - { - "name": "0_qg[1]#45" - }, - { - "name": "0_p[(2, 3, 2)]#45" - }, - { - "name": "0_p[(3, 1, 2)]#45" - }, - { - "name": "0_p[(1, 1, 3)]#45" - }, - { - "name": "0_p[(2, 2, 3)]#45" - }, - { - "name": "0_p[(3, 2, 1)]#45" - }, - { - "name": "0_p[(1, 3, 1)]#45" - }, - { - "name": "0_q[(2, 3, 2)]#45" - }, - { - "name": "0_q[(3, 1, 2)]#45" - }, - { - "name": "0_q[(1, 1, 3)]#45" - }, - { - "name": "0_q[(2, 2, 3)]#45" - }, - { - "name": "0_q[(3, 2, 1)]#45" - }, - { - "name": "0_q[(1, 3, 1)]#45" - }, - { - "name": "min_volume_violation[1]#45" - }, - { - "name": "outflow[1]#45" - }, - { - "name": "spill[1]#45" - }, - { - "name": "min_outflow_violation[1]#45" - }, - { - "name": "deficit[1]#45" - }, - { - "name": "deficit[2]#45" - }, - { - "name": "deficit[3]#45" - }, - { - "name": "reservoir[1]_out#45" - }, - { - "name": "0_vm[2]#46" - }, - { - "name": "0_vm[3]#46" - }, - { - "name": "0_vm[1]#46" - }, - { - "name": "0_pg[2]#46" - }, - { - "name": "0_pg[3]#46" - }, - { - "name": "0_pg[1]#46" - }, - { - "name": "0_qg[2]#46" - }, - { - "name": "0_qg[3]#46" - }, - { - "name": "0_qg[1]#46" - }, - { - "name": "0_p[(2, 3, 2)]#46" - }, - { - "name": "0_p[(3, 1, 2)]#46" - }, - { - "name": "0_p[(1, 1, 3)]#46" - }, - { - "name": "0_p[(2, 2, 3)]#46" - }, - { - "name": "0_p[(3, 2, 1)]#46" - }, - { - "name": "0_p[(1, 3, 1)]#46" - }, - { - "name": "0_q[(2, 3, 2)]#46" - }, - { - "name": "0_q[(3, 1, 2)]#46" - }, - { - "name": "0_q[(1, 1, 3)]#46" - }, - { - "name": "0_q[(2, 2, 3)]#46" - }, - { - "name": "0_q[(3, 2, 1)]#46" - }, - { - "name": "0_q[(1, 3, 1)]#46" - }, - { - "name": "min_volume_violation[1]#46" - }, - { - "name": "outflow[1]#46" - }, - { - "name": "spill[1]#46" - }, - { - "name": "min_outflow_violation[1]#46" - }, - { - "name": "deficit[1]#46" - }, - { - "name": "deficit[2]#46" - }, - { - "name": "deficit[3]#46" - }, - { - "name": "reservoir[1]_out#46" - }, - { - "name": "0_vm[2]#47" - }, - { - "name": "0_vm[3]#47" - }, - { - "name": "0_vm[1]#47" - }, - { - "name": "0_pg[2]#47" - }, - { - "name": "0_pg[3]#47" - }, - { - "name": "0_pg[1]#47" - }, - { - "name": "0_qg[2]#47" - }, - { - "name": "0_qg[3]#47" - }, - { - "name": "0_qg[1]#47" - }, - { - "name": "0_p[(2, 3, 2)]#47" - }, - { - "name": "0_p[(3, 1, 2)]#47" - }, - { - "name": "0_p[(1, 1, 3)]#47" - }, - { - "name": "0_p[(2, 2, 3)]#47" - }, - { - "name": "0_p[(3, 2, 1)]#47" - }, - { - "name": "0_p[(1, 3, 1)]#47" - }, - { - "name": "0_q[(2, 3, 2)]#47" - }, - { - "name": "0_q[(3, 1, 2)]#47" - }, - { - "name": "0_q[(1, 1, 3)]#47" - }, - { - "name": "0_q[(2, 2, 3)]#47" - }, - { - "name": "0_q[(3, 2, 1)]#47" - }, - { - "name": "0_q[(1, 3, 1)]#47" - }, - { - "name": "min_volume_violation[1]#47" - }, - { - "name": "outflow[1]#47" - }, - { - "name": "spill[1]#47" - }, - { - "name": "min_outflow_violation[1]#47" - }, - { - "name": "deficit[1]#47" - }, - { - "name": "deficit[2]#47" - }, - { - "name": "deficit[3]#47" - }, - { - "name": "reservoir[1]_out#47" - }, - { - "name": "0_vm[2]#48" - }, - { - "name": "0_vm[3]#48" - }, - { - "name": "0_vm[1]#48" - }, - { - "name": "0_pg[2]#48" - }, - { - "name": "0_pg[3]#48" - }, - { - "name": "0_pg[1]#48" - }, - { - "name": "0_qg[2]#48" - }, - { - "name": "0_qg[3]#48" - }, - { - "name": "0_qg[1]#48" - }, - { - "name": "0_p[(2, 3, 2)]#48" - }, - { - "name": "0_p[(3, 1, 2)]#48" - }, - { - "name": "0_p[(1, 1, 3)]#48" - }, - { - "name": "0_p[(2, 2, 3)]#48" - }, - { - "name": "0_p[(3, 2, 1)]#48" - }, - { - "name": "0_p[(1, 3, 1)]#48" - }, - { - "name": "0_q[(2, 3, 2)]#48" - }, - { - "name": "0_q[(3, 1, 2)]#48" - }, - { - "name": "0_q[(1, 1, 3)]#48" - }, - { - "name": "0_q[(2, 2, 3)]#48" - }, - { - "name": "0_q[(3, 2, 1)]#48" - }, - { - "name": "0_q[(1, 3, 1)]#48" - }, - { - "name": "min_volume_violation[1]#48" - }, - { - "name": "outflow[1]#48" - }, - { - "name": "spill[1]#48" - }, - { - "name": "min_outflow_violation[1]#48" - }, - { - "name": "deficit[1]#48" - }, - { - "name": "deficit[2]#48" - }, - { - "name": "deficit[3]#48" - }, - { - "name": "reservoir[1]_out#48" - }, - { - "name": "_inflow[1]#1" - }, - { - "name": "_reservoir[1]_in#1" - }, - { - "name": "_inflow[1]#2" - }, - { - "name": "_inflow[1]#3" - }, - { - "name": "_inflow[1]#4" - }, - { - "name": "_inflow[1]#5" - }, - { - "name": "_inflow[1]#6" - }, - { - "name": "_inflow[1]#7" - }, - { - "name": "_inflow[1]#8" - }, - { - "name": "_inflow[1]#9" - }, - { - "name": "_inflow[1]#10" - }, - { - "name": "_inflow[1]#11" - }, - { - "name": "_inflow[1]#12" - }, - { - "name": "_inflow[1]#13" - }, - { - "name": "_inflow[1]#14" - }, - { - "name": "_inflow[1]#15" - }, - { - "name": "_inflow[1]#16" - }, - { - "name": "_inflow[1]#17" - }, - { - "name": "_inflow[1]#18" - }, - { - "name": "_inflow[1]#19" - }, - { - "name": "_inflow[1]#20" - }, - { - "name": "_inflow[1]#21" - }, - { - "name": "_inflow[1]#22" - }, - { - "name": "_inflow[1]#23" - }, - { - "name": "_inflow[1]#24" - }, - { - "name": "_inflow[1]#25" - }, - { - "name": "_inflow[1]#26" - }, - { - "name": "_inflow[1]#27" - }, - { - "name": "_inflow[1]#28" - }, - { - "name": "_inflow[1]#29" - }, - { - "name": "_inflow[1]#30" - }, - { - "name": "_inflow[1]#31" - }, - { - "name": "_inflow[1]#32" - }, - { - "name": "_inflow[1]#33" - }, - { - "name": "_inflow[1]#34" - }, - { - "name": "_inflow[1]#35" - }, - { - "name": "_inflow[1]#36" - }, - { - "name": "_inflow[1]#37" - }, - { - "name": "_inflow[1]#38" - }, - { - "name": "_inflow[1]#39" - }, - { - "name": "_inflow[1]#40" - }, - { - "name": "_inflow[1]#41" - }, - { - "name": "_inflow[1]#42" - }, - { - "name": "_inflow[1]#43" - }, - { - "name": "_inflow[1]#44" - }, - { - "name": "_inflow[1]#45" - }, - { - "name": "_inflow[1]#46" - }, - { - "name": "_inflow[1]#47" - }, - { - "name": "_inflow[1]#48" - }, - { - "name": "reservoir[1]_in#1" - }, - { - "name": "inflow[1]#1" - }, - { - "name": "0_va[2]#1" - }, - { - "name": "0_va[3]#1" - }, - { - "name": "0_va[1]#1" - }, - { - "name": "x1447" - }, - { - "name": "x1448" - }, - { - "name": "reservoir[1]_in#2" - }, - { - "name": "inflow[1]#2" - }, - { - "name": "0_va[2]#2" - }, - { - "name": "0_va[3]#2" - }, - { - "name": "0_va[1]#2" - }, - { - "name": "x1454" - }, - { - "name": "x1455" - }, - { - "name": "reservoir[1]_in#3" - }, - { - "name": "inflow[1]#3" - }, - { - "name": "0_va[2]#3" - }, - { - "name": "0_va[3]#3" - }, - { - "name": "0_va[1]#3" - }, - { - "name": "x1461" - }, - { - "name": "x1462" - }, - { - "name": "reservoir[1]_in#4" - }, - { - "name": "inflow[1]#4" - }, - { - "name": "0_va[2]#4" - }, - { - "name": "0_va[3]#4" - }, - { - "name": "0_va[1]#4" - }, - { - "name": "x1468" - }, - { - "name": "x1469" - }, - { - "name": "reservoir[1]_in#5" - }, - { - "name": "inflow[1]#5" - }, - { - "name": "0_va[2]#5" - }, - { - "name": "0_va[3]#5" - }, - { - "name": "0_va[1]#5" - }, - { - "name": "x1475" - }, - { - "name": "x1476" - }, - { - "name": "reservoir[1]_in#6" - }, - { - "name": "inflow[1]#6" - }, - { - "name": "0_va[2]#6" - }, - { - "name": "0_va[3]#6" - }, - { - "name": "0_va[1]#6" - }, - { - "name": "x1482" - }, - { - "name": "x1483" - }, - { - "name": "reservoir[1]_in#7" - }, - { - "name": "inflow[1]#7" - }, - { - "name": "0_va[2]#7" - }, - { - "name": "0_va[3]#7" - }, - { - "name": "0_va[1]#7" - }, - { - "name": "x1489" - }, - { - "name": "x1490" - }, - { - "name": "reservoir[1]_in#8" - }, - { - "name": "inflow[1]#8" - }, - { - "name": "0_va[2]#8" - }, - { - "name": "0_va[3]#8" - }, - { - "name": "0_va[1]#8" - }, - { - "name": "x1496" - }, - { - "name": "x1497" - }, - { - "name": "reservoir[1]_in#9" - }, - { - "name": "inflow[1]#9" - }, - { - "name": "0_va[2]#9" - }, - { - "name": "0_va[3]#9" - }, - { - "name": "0_va[1]#9" - }, - { - "name": "x1503" - }, - { - "name": "x1504" - }, - { - "name": "reservoir[1]_in#10" - }, - { - "name": "inflow[1]#10" - }, - { - "name": "0_va[2]#10" - }, - { - "name": "0_va[3]#10" - }, - { - "name": "0_va[1]#10" - }, - { - "name": "x1510" - }, - { - "name": "x1511" - }, - { - "name": "reservoir[1]_in#11" - }, - { - "name": "inflow[1]#11" - }, - { - "name": "0_va[2]#11" - }, - { - "name": "0_va[3]#11" - }, - { - "name": "0_va[1]#11" - }, - { - "name": "x1517" - }, - { - "name": "x1518" - }, - { - "name": "reservoir[1]_in#12" - }, - { - "name": "inflow[1]#12" - }, - { - "name": "0_va[2]#12" - }, - { - "name": "0_va[3]#12" - }, - { - "name": "0_va[1]#12" - }, - { - "name": "x1524" - }, - { - "name": "x1525" - }, - { - "name": "reservoir[1]_in#13" - }, - { - "name": "inflow[1]#13" - }, - { - "name": "0_va[2]#13" - }, - { - "name": "0_va[3]#13" - }, - { - "name": "0_va[1]#13" - }, - { - "name": "x1531" - }, - { - "name": "x1532" - }, - { - "name": "reservoir[1]_in#14" - }, - { - "name": "inflow[1]#14" - }, - { - "name": "0_va[2]#14" - }, - { - "name": "0_va[3]#14" - }, - { - "name": "0_va[1]#14" - }, - { - "name": "x1538" - }, - { - "name": "x1539" - }, - { - "name": "reservoir[1]_in#15" - }, - { - "name": "inflow[1]#15" - }, - { - "name": "0_va[2]#15" - }, - { - "name": "0_va[3]#15" - }, - { - "name": "0_va[1]#15" - }, - { - "name": "x1545" - }, - { - "name": "x1546" - }, - { - "name": "reservoir[1]_in#16" - }, - { - "name": "inflow[1]#16" - }, - { - "name": "0_va[2]#16" - }, - { - "name": "0_va[3]#16" - }, - { - "name": "0_va[1]#16" - }, - { - "name": "x1552" - }, - { - "name": "x1553" - }, - { - "name": "reservoir[1]_in#17" - }, - { - "name": "inflow[1]#17" - }, - { - "name": "0_va[2]#17" - }, - { - "name": "0_va[3]#17" - }, - { - "name": "0_va[1]#17" - }, - { - "name": "x1559" - }, - { - "name": "x1560" - }, - { - "name": "reservoir[1]_in#18" - }, - { - "name": "inflow[1]#18" - }, - { - "name": "0_va[2]#18" - }, - { - "name": "0_va[3]#18" - }, - { - "name": "0_va[1]#18" - }, - { - "name": "x1566" - }, - { - "name": "x1567" - }, - { - "name": "reservoir[1]_in#19" - }, - { - "name": "inflow[1]#19" - }, - { - "name": "0_va[2]#19" - }, - { - "name": "0_va[3]#19" - }, - { - "name": "0_va[1]#19" - }, - { - "name": "x1573" - }, - { - "name": "x1574" - }, - { - "name": "reservoir[1]_in#20" - }, - { - "name": "inflow[1]#20" - }, - { - "name": "0_va[2]#20" - }, - { - "name": "0_va[3]#20" - }, - { - "name": "0_va[1]#20" - }, - { - "name": "x1580" - }, - { - "name": "x1581" - }, - { - "name": "reservoir[1]_in#21" - }, - { - "name": "inflow[1]#21" - }, - { - "name": "0_va[2]#21" - }, - { - "name": "0_va[3]#21" - }, - { - "name": "0_va[1]#21" - }, - { - "name": "x1587" - }, - { - "name": "x1588" - }, - { - "name": "reservoir[1]_in#22" - }, - { - "name": "inflow[1]#22" - }, - { - "name": "0_va[2]#22" - }, - { - "name": "0_va[3]#22" - }, - { - "name": "0_va[1]#22" - }, - { - "name": "x1594" - }, - { - "name": "x1595" - }, - { - "name": "reservoir[1]_in#23" - }, - { - "name": "inflow[1]#23" - }, - { - "name": "0_va[2]#23" - }, - { - "name": "0_va[3]#23" - }, - { - "name": "0_va[1]#23" - }, - { - "name": "x1601" - }, - { - "name": "x1602" - }, - { - "name": "reservoir[1]_in#24" - }, - { - "name": "inflow[1]#24" - }, - { - "name": "0_va[2]#24" - }, - { - "name": "0_va[3]#24" - }, - { - "name": "0_va[1]#24" - }, - { - "name": "x1608" - }, - { - "name": "x1609" - }, - { - "name": "reservoir[1]_in#25" - }, - { - "name": "inflow[1]#25" - }, - { - "name": "0_va[2]#25" - }, - { - "name": "0_va[3]#25" - }, - { - "name": "0_va[1]#25" - }, - { - "name": "x1615" - }, - { - "name": "x1616" - }, - { - "name": "reservoir[1]_in#26" - }, - { - "name": "inflow[1]#26" - }, - { - "name": "0_va[2]#26" - }, - { - "name": "0_va[3]#26" - }, - { - "name": "0_va[1]#26" - }, - { - "name": "x1622" - }, - { - "name": "x1623" - }, - { - "name": "reservoir[1]_in#27" - }, - { - "name": "inflow[1]#27" - }, - { - "name": "0_va[2]#27" - }, - { - "name": "0_va[3]#27" - }, - { - "name": "0_va[1]#27" - }, - { - "name": "x1629" - }, - { - "name": "x1630" - }, - { - "name": "reservoir[1]_in#28" - }, - { - "name": "inflow[1]#28" - }, - { - "name": "0_va[2]#28" - }, - { - "name": "0_va[3]#28" - }, - { - "name": "0_va[1]#28" - }, - { - "name": "x1636" - }, - { - "name": "x1637" - }, - { - "name": "reservoir[1]_in#29" - }, - { - "name": "inflow[1]#29" - }, - { - "name": "0_va[2]#29" - }, - { - "name": "0_va[3]#29" - }, - { - "name": "0_va[1]#29" - }, - { - "name": "x1643" - }, - { - "name": "x1644" - }, - { - "name": "reservoir[1]_in#30" - }, - { - "name": "inflow[1]#30" - }, - { - "name": "0_va[2]#30" - }, - { - "name": "0_va[3]#30" - }, - { - "name": "0_va[1]#30" - }, - { - "name": "x1650" - }, - { - "name": "x1651" - }, - { - "name": "reservoir[1]_in#31" - }, - { - "name": "inflow[1]#31" - }, - { - "name": "0_va[2]#31" - }, - { - "name": "0_va[3]#31" - }, - { - "name": "0_va[1]#31" - }, - { - "name": "x1657" - }, - { - "name": "x1658" - }, - { - "name": "reservoir[1]_in#32" - }, - { - "name": "inflow[1]#32" - }, - { - "name": "0_va[2]#32" - }, - { - "name": "0_va[3]#32" - }, - { - "name": "0_va[1]#32" - }, - { - "name": "x1664" - }, - { - "name": "x1665" - }, - { - "name": "reservoir[1]_in#33" - }, - { - "name": "inflow[1]#33" - }, - { - "name": "0_va[2]#33" - }, - { - "name": "0_va[3]#33" - }, - { - "name": "0_va[1]#33" - }, - { - "name": "x1671" - }, - { - "name": "x1672" - }, - { - "name": "reservoir[1]_in#34" - }, - { - "name": "inflow[1]#34" - }, - { - "name": "0_va[2]#34" - }, - { - "name": "0_va[3]#34" - }, - { - "name": "0_va[1]#34" - }, - { - "name": "x1678" - }, - { - "name": "x1679" - }, - { - "name": "reservoir[1]_in#35" - }, - { - "name": "inflow[1]#35" - }, - { - "name": "0_va[2]#35" - }, - { - "name": "0_va[3]#35" - }, - { - "name": "0_va[1]#35" - }, - { - "name": "x1685" - }, - { - "name": "x1686" - }, - { - "name": "reservoir[1]_in#36" - }, - { - "name": "inflow[1]#36" - }, - { - "name": "0_va[2]#36" - }, - { - "name": "0_va[3]#36" - }, - { - "name": "0_va[1]#36" - }, - { - "name": "x1692" - }, - { - "name": "x1693" - }, - { - "name": "reservoir[1]_in#37" - }, - { - "name": "inflow[1]#37" - }, - { - "name": "0_va[2]#37" - }, - { - "name": "0_va[3]#37" - }, - { - "name": "0_va[1]#37" - }, - { - "name": "x1699" - }, - { - "name": "x1700" - }, - { - "name": "reservoir[1]_in#38" - }, - { - "name": "inflow[1]#38" - }, - { - "name": "0_va[2]#38" - }, - { - "name": "0_va[3]#38" - }, - { - "name": "0_va[1]#38" - }, - { - "name": "x1706" - }, - { - "name": "x1707" - }, - { - "name": "reservoir[1]_in#39" - }, - { - "name": "inflow[1]#39" - }, - { - "name": "0_va[2]#39" - }, - { - "name": "0_va[3]#39" - }, - { - "name": "0_va[1]#39" - }, - { - "name": "x1713" - }, - { - "name": "x1714" - }, - { - "name": "reservoir[1]_in#40" - }, - { - "name": "inflow[1]#40" - }, - { - "name": "0_va[2]#40" - }, - { - "name": "0_va[3]#40" - }, - { - "name": "0_va[1]#40" - }, - { - "name": "x1720" - }, - { - "name": "x1721" - }, - { - "name": "reservoir[1]_in#41" - }, - { - "name": "inflow[1]#41" - }, - { - "name": "0_va[2]#41" - }, - { - "name": "0_va[3]#41" - }, - { - "name": "0_va[1]#41" - }, - { - "name": "x1727" - }, - { - "name": "x1728" - }, - { - "name": "reservoir[1]_in#42" - }, - { - "name": "inflow[1]#42" - }, - { - "name": "0_va[2]#42" - }, - { - "name": "0_va[3]#42" - }, - { - "name": "0_va[1]#42" - }, - { - "name": "x1734" - }, - { - "name": "x1735" - }, - { - "name": "reservoir[1]_in#43" - }, - { - "name": "inflow[1]#43" - }, - { - "name": "0_va[2]#43" - }, - { - "name": "0_va[3]#43" - }, - { - "name": "0_va[1]#43" - }, - { - "name": "x1741" - }, - { - "name": "x1742" - }, - { - "name": "reservoir[1]_in#44" - }, - { - "name": "inflow[1]#44" - }, - { - "name": "0_va[2]#44" - }, - { - "name": "0_va[3]#44" - }, - { - "name": "0_va[1]#44" - }, - { - "name": "x1748" - }, - { - "name": "x1749" - }, - { - "name": "reservoir[1]_in#45" - }, - { - "name": "inflow[1]#45" - }, - { - "name": "0_va[2]#45" - }, - { - "name": "0_va[3]#45" - }, - { - "name": "0_va[1]#45" - }, - { - "name": "x1755" - }, - { - "name": "x1756" - }, - { - "name": "reservoir[1]_in#46" - }, - { - "name": "inflow[1]#46" - }, - { - "name": "0_va[2]#46" - }, - { - "name": "0_va[3]#46" - }, - { - "name": "0_va[1]#46" - }, - { - "name": "x1762" - }, - { - "name": "x1763" - }, - { - "name": "reservoir[1]_in#47" - }, - { - "name": "inflow[1]#47" - }, - { - "name": "0_va[2]#47" - }, - { - "name": "0_va[3]#47" - }, - { - "name": "0_va[1]#47" - }, - { - "name": "x1769" - }, - { - "name": "x1770" - }, - { - "name": "reservoir[1]_in#48" - }, - { - "name": "inflow[1]#48" - }, - { - "name": "0_va[2]#48" - }, - { - "name": "0_va[3]#48" - }, - { - "name": "0_va[1]#48" - }, - { - "name": "x1776" - }, - { - "name": "x1777" - } - ], - "objective": { - "sense": "min", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 10010.0, - "variable": "deficit[1]#1" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#1" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#1" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#1" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#1" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#2" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#2" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#2" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#2" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#2" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#3" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#3" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#3" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#3" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#3" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#4" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#4" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#4" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#4" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#4" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#5" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#5" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#5" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#5" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#5" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#6" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#6" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#6" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#6" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#6" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#7" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#7" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#7" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#7" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#7" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#8" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#8" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#8" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#8" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#8" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#9" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#9" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#9" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#9" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#9" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#10" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#10" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#10" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#10" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#10" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#11" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#11" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#11" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#11" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#11" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#12" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#12" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#12" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#12" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#12" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#13" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#13" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#13" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#13" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#13" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#14" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#14" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#14" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#14" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#14" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#15" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#15" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#15" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#15" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#15" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#16" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#16" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#16" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#16" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#16" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#17" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#17" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#17" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#17" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#17" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#18" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#18" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#18" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#18" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#18" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#19" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#19" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#19" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#19" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#19" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#20" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#20" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#20" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#20" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#20" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#21" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#21" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#21" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#21" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#21" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#22" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#22" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#22" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#22" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#22" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#23" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#23" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#23" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#23" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#23" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#24" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#24" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#24" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#24" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#24" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#25" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#25" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#25" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#25" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#25" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#26" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#26" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#26" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#26" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#26" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#27" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#27" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#27" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#27" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#27" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#28" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#28" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#28" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#28" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#28" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#29" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#29" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#29" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#29" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#29" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#30" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#30" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#30" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#30" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#30" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#31" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#31" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#31" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#31" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#31" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#32" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#32" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#32" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#32" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#32" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#33" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#33" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#33" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#33" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#33" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#34" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#34" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#34" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#34" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#34" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#35" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#35" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#35" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#35" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#35" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#36" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#36" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#36" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#36" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#36" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#37" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#37" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#37" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#37" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#37" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#38" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#38" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#38" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#38" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#38" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#39" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#39" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#39" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#39" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#39" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#40" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#40" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#40" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#40" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#40" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#41" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#41" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#41" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#41" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#41" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#42" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#42" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#42" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#42" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#42" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#43" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#43" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#43" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#43" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#43" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#44" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#44" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#44" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#44" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#44" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#45" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#45" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#45" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#45" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#45" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#46" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#46" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#46" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#46" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#46" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#47" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#47" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#47" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#47" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#47" - }, - { - "coefficient": 10010.0, - "variable": "deficit[1]#48" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]#48" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]#48" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]#48" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]#48" - } - ], - "constant": 0.0 - } - }, - "constraints": [ - { - "name": "c1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#1" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#1" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#1" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#1" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#1" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c3", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#1" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#1" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#1" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c4", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#1" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#1" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#1" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#1" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c5", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#1" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#1" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#1" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c6", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#1" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#1" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#1" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#1" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c7", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#1" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#1" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#1" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c8", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#1" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#1" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#1" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#1" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#1" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c9", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#1" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#1" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c10", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_reservoir[1]_in#1" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#1" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c11", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#1" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#1" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c12", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#2" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c13", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#2" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#2" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#2" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#2" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c14", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#2" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#2" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#2" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c15", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#2" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#2" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#2" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#2" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c16", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#2" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#2" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#2" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c17", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#2" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#2" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#2" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#2" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c18", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#2" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#2" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#2" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c19", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#2" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#2" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#2" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#2" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#2" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c20", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#2" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#2" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c21", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#1" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#2" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c22", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#2" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#2" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c23", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#3" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c24", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#3" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#3" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#3" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#3" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c25", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#3" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#3" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#3" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c26", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#3" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#3" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#3" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#3" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c27", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#3" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#3" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#3" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c28", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#3" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#3" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#3" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#3" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c29", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#3" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#3" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#3" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c30", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#3" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#3" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#3" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#3" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#3" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c31", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#3" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#3" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c32", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#2" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#3" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c33", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#3" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#3" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c34", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#4" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c35", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#4" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#4" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#4" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#4" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c36", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#4" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#4" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#4" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c37", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#4" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#4" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#4" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#4" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c38", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#4" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#4" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#4" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c39", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#4" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#4" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#4" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#4" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c40", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#4" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#4" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#4" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c41", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#4" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#4" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#4" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#4" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#4" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c42", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#4" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#4" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c43", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#3" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#4" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c44", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#4" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#4" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c45", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#5" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c46", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#5" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#5" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#5" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#5" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c47", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#5" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#5" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#5" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c48", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#5" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#5" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#5" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#5" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c49", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#5" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#5" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#5" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c50", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#5" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#5" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#5" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#5" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c51", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#5" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#5" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#5" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c52", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#5" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#5" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#5" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#5" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#5" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c53", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#5" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#5" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c54", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#4" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#5" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c55", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#5" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#5" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c56", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#6" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c57", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#6" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#6" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#6" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#6" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c58", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#6" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#6" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#6" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c59", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#6" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#6" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#6" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#6" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c60", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#6" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#6" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#6" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c61", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#6" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#6" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#6" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#6" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c62", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#6" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#6" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#6" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c63", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#6" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#6" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#6" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#6" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#6" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c64", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#6" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#6" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c65", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#5" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#6" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c66", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#6" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#6" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c67", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#7" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c68", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#7" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#7" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#7" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#7" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c69", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#7" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#7" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#7" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c70", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#7" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#7" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#7" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#7" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c71", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#7" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#7" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#7" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c72", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#7" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#7" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#7" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#7" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c73", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#7" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#7" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#7" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c74", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#7" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#7" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#7" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#7" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#7" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c75", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#7" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#7" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c76", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#6" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#7" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c77", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#7" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#7" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c78", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#8" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c79", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#8" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#8" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#8" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#8" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c80", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#8" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#8" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#8" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c81", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#8" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#8" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#8" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#8" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c82", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#8" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#8" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#8" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c83", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#8" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#8" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#8" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#8" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c84", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#8" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#8" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#8" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c85", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#8" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#8" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#8" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#8" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#8" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c86", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#8" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#8" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c87", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#7" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#8" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c88", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#8" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#8" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c89", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#9" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c90", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#9" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#9" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#9" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#9" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c91", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#9" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#9" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#9" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c92", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#9" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#9" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#9" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#9" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c93", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#9" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#9" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#9" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c94", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#9" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#9" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#9" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#9" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c95", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#9" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#9" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#9" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c96", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#9" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#9" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#9" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#9" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#9" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c97", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#9" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#9" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c98", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#8" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#9" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c99", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#9" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#9" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c100", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c101", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#10" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#10" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#10" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c102", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#10" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#10" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c103", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#10" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#10" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#10" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c104", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#10" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#10" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c105", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#10" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#10" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#10" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c106", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#10" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#10" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c107", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#10" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#10" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#10" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#10" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c108", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#10" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c109", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#9" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c110", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#10" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c111", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c112", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#11" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#11" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#11" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c113", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#11" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#11" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c114", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#11" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#11" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#11" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c115", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#11" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#11" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c116", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#11" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#11" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#11" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c117", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#11" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#11" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c118", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#11" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#11" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#11" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#11" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c119", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#11" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c120", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#10" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c121", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#11" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c122", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c123", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#12" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#12" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#12" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c124", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#12" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#12" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c125", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#12" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#12" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#12" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c126", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#12" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#12" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c127", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#12" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#12" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#12" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c128", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#12" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#12" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c129", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#12" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#12" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#12" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#12" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c130", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#12" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c131", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#11" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c132", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#12" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c133", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c134", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#13" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#13" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#13" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c135", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#13" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#13" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c136", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#13" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#13" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#13" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c137", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#13" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#13" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c138", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#13" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#13" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#13" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c139", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#13" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#13" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c140", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#13" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#13" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#13" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#13" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c141", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#13" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c142", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#12" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c143", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#13" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c144", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c145", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#14" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#14" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#14" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c146", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#14" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#14" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c147", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#14" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#14" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#14" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c148", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#14" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#14" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c149", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#14" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#14" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#14" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c150", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#14" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#14" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c151", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#14" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#14" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#14" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#14" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c152", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#14" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c153", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#13" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c154", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#14" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c155", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c156", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#15" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#15" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#15" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c157", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#15" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#15" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c158", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#15" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#15" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#15" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c159", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#15" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#15" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c160", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#15" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#15" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#15" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c161", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#15" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#15" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c162", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#15" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#15" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#15" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#15" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c163", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#15" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c164", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#14" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c165", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#15" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c166", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c167", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#16" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#16" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#16" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c168", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#16" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#16" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c169", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#16" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#16" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#16" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c170", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#16" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#16" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c171", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#16" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#16" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#16" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c172", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#16" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#16" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c173", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#16" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#16" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#16" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#16" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c174", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#16" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c175", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#15" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c176", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#16" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c177", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c178", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#17" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#17" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#17" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c179", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#17" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#17" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c180", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#17" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#17" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#17" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c181", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#17" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#17" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c182", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#17" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#17" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#17" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c183", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#17" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#17" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c184", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#17" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#17" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#17" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#17" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c185", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#17" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c186", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#16" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c187", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#17" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c188", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c189", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#18" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#18" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#18" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c190", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#18" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#18" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c191", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#18" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#18" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#18" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c192", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#18" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#18" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c193", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#18" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#18" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#18" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c194", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#18" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#18" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c195", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#18" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#18" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#18" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#18" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c196", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#18" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c197", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#17" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c198", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#18" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c199", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c200", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#19" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#19" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#19" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c201", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#19" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#19" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c202", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#19" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#19" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#19" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c203", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#19" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#19" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c204", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#19" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#19" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#19" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c205", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#19" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#19" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c206", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#19" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#19" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#19" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#19" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c207", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#19" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c208", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#18" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c209", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#19" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c210", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c211", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#20" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#20" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#20" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c212", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#20" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#20" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c213", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#20" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#20" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#20" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c214", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#20" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#20" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c215", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#20" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#20" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#20" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c216", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#20" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#20" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c217", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#20" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#20" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#20" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#20" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c218", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#20" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c219", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#19" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c220", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#20" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c221", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c222", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#21" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#21" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#21" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c223", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#21" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#21" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c224", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#21" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#21" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#21" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c225", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#21" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#21" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c226", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#21" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#21" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#21" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c227", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#21" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#21" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c228", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#21" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#21" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#21" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#21" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c229", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#21" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c230", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#20" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c231", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#21" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c232", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c233", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#22" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#22" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#22" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c234", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#22" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#22" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c235", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#22" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#22" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#22" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c236", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#22" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#22" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c237", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#22" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#22" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#22" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c238", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#22" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#22" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c239", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#22" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#22" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#22" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#22" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c240", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#22" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c241", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#21" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c242", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#22" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c243", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c244", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#23" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#23" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#23" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c245", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#23" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#23" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c246", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#23" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#23" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#23" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c247", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#23" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#23" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c248", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#23" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#23" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#23" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c249", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#23" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#23" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c250", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#23" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#23" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#23" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#23" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c251", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#23" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c252", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#22" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c253", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#23" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c254", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c255", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#24" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#24" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#24" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c256", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#24" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#24" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c257", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#24" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#24" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#24" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c258", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#24" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#24" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c259", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#24" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#24" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#24" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c260", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#24" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#24" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c261", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#24" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#24" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#24" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#24" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c262", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#24" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c263", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#23" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c264", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#24" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c265", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c266", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#25" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#25" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#25" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c267", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#25" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#25" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c268", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#25" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#25" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#25" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c269", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#25" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#25" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c270", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#25" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#25" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#25" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c271", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#25" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#25" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c272", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#25" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#25" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#25" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#25" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c273", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#25" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c274", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#24" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c275", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#25" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c276", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c277", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#26" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#26" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#26" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c278", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#26" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#26" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c279", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#26" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#26" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#26" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c280", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#26" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#26" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c281", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#26" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#26" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#26" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c282", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#26" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#26" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c283", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#26" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#26" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#26" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#26" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c284", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#26" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c285", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#25" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c286", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#26" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c287", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c288", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#27" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#27" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#27" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c289", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#27" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#27" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c290", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#27" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#27" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#27" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c291", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#27" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#27" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c292", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#27" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#27" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#27" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c293", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#27" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#27" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c294", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#27" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#27" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#27" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#27" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c295", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#27" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c296", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#26" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c297", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#27" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c298", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c299", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#28" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#28" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#28" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c300", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#28" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#28" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c301", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#28" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#28" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#28" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c302", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#28" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#28" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c303", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#28" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#28" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#28" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c304", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#28" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#28" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c305", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#28" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#28" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#28" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#28" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c306", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#28" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c307", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#27" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c308", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#28" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c309", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c310", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#29" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#29" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#29" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c311", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#29" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#29" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c312", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#29" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#29" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#29" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c313", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#29" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#29" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c314", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#29" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#29" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#29" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c315", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#29" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#29" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c316", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#29" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#29" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#29" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#29" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c317", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#29" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c318", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#28" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c319", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#29" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c320", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c321", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#30" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#30" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#30" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c322", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#30" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#30" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c323", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#30" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#30" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#30" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c324", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#30" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#30" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c325", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#30" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#30" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#30" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c326", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#30" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#30" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c327", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#30" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#30" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#30" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#30" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c328", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#30" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c329", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#29" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c330", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#30" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c331", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c332", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#31" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#31" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#31" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c333", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#31" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#31" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c334", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#31" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#31" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#31" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c335", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#31" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#31" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c336", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#31" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#31" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#31" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c337", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#31" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#31" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c338", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#31" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#31" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#31" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#31" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c339", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#31" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c340", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#30" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c341", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#31" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c342", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c343", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#32" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#32" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#32" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c344", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#32" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#32" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c345", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#32" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#32" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#32" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c346", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#32" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#32" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c347", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#32" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#32" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#32" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c348", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#32" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#32" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c349", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#32" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#32" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#32" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#32" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c350", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#32" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c351", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#31" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c352", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#32" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c353", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c354", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#33" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#33" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#33" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c355", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#33" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#33" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c356", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#33" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#33" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#33" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c357", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#33" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#33" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c358", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#33" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#33" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#33" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c359", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#33" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#33" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c360", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#33" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#33" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#33" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#33" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c361", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#33" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c362", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#32" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c363", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#33" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c364", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c365", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#34" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#34" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#34" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c366", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#34" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#34" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c367", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#34" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#34" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#34" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c368", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#34" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#34" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c369", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#34" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#34" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#34" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c370", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#34" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#34" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c371", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#34" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#34" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#34" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#34" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c372", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#34" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c373", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#33" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c374", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#34" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c375", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c376", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#35" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#35" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#35" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c377", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#35" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#35" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c378", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#35" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#35" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#35" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c379", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#35" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#35" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c380", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#35" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#35" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#35" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c381", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#35" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#35" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c382", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#35" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#35" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#35" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#35" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c383", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#35" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c384", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#34" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c385", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#35" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c386", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c387", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#36" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#36" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#36" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c388", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#36" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#36" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c389", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#36" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#36" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#36" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c390", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#36" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#36" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c391", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#36" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#36" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#36" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c392", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#36" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#36" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c393", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#36" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#36" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#36" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#36" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c394", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#36" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c395", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#35" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c396", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#36" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c397", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c398", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#37" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#37" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#37" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c399", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#37" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#37" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c400", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#37" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#37" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#37" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c401", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#37" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#37" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c402", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#37" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#37" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#37" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c403", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#37" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#37" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c404", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#37" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#37" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#37" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#37" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c405", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#37" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c406", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#36" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c407", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#37" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c408", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c409", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#38" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#38" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#38" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c410", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#38" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#38" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c411", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#38" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#38" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#38" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c412", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#38" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#38" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c413", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#38" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#38" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#38" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c414", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#38" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#38" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c415", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#38" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#38" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#38" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#38" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c416", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#38" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c417", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#37" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c418", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#38" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c419", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c420", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#39" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#39" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#39" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c421", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#39" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#39" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c422", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#39" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#39" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#39" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c423", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#39" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#39" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c424", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#39" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#39" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#39" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c425", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#39" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#39" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c426", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#39" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#39" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#39" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#39" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c427", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#39" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c428", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#38" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c429", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#39" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c430", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c431", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#40" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#40" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#40" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c432", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#40" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#40" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c433", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#40" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#40" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#40" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c434", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#40" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#40" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c435", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#40" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#40" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#40" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c436", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#40" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#40" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c437", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#40" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#40" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#40" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#40" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c438", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#40" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c439", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#39" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c440", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#40" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c441", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c442", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#41" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#41" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#41" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c443", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#41" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#41" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c444", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#41" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#41" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#41" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c445", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#41" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#41" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c446", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#41" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#41" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#41" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c447", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#41" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#41" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c448", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#41" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#41" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#41" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#41" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c449", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#41" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c450", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#40" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c451", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#41" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c452", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c453", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#42" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#42" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#42" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c454", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#42" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#42" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c455", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#42" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#42" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#42" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c456", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#42" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#42" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c457", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#42" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#42" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#42" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c458", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#42" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#42" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c459", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#42" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#42" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#42" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#42" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c460", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#42" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c461", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#41" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c462", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#42" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c463", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c464", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#43" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#43" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#43" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c465", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#43" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#43" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c466", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#43" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#43" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#43" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c467", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#43" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#43" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c468", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#43" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#43" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#43" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c469", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#43" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#43" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c470", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#43" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#43" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#43" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#43" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c471", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#43" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c472", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#42" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c473", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#43" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c474", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c475", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#44" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#44" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#44" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c476", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#44" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#44" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c477", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#44" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#44" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#44" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c478", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#44" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#44" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c479", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#44" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#44" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#44" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c480", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#44" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#44" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c481", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#44" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#44" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#44" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#44" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c482", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#44" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c483", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#43" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c484", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#44" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c485", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c486", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#45" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#45" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#45" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c487", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#45" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#45" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c488", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#45" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#45" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#45" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c489", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#45" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#45" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c490", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#45" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#45" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#45" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c491", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#45" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#45" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c492", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#45" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#45" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#45" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#45" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c493", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#45" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c494", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#44" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c495", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#45" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c496", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c497", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#46" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#46" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#46" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c498", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#46" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#46" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c499", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#46" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#46" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#46" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c500", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#46" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#46" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c501", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#46" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#46" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#46" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c502", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#46" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#46" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c503", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#46" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#46" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#46" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#46" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c504", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#46" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c505", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#45" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c506", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#46" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c507", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c508", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#47" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#47" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#47" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c509", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#47" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#47" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c510", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#47" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#47" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#47" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c511", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#47" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#47" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c512", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#47" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#47" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#47" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c513", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#47" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#47" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c514", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#47" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#47" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#47" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#47" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c515", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#47" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c516", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#46" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c517", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#47" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c518", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_va[1]#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c519", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]#48" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]#48" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]#48" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c520", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]#48" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]#48" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c521", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]#48" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]#48" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]#48" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c522", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]#48" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]#48" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c523", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]#48" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]#48" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]#48" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c524", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]#48" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]#48" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c525", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 0.0036, - "variable": "outflow[1]#48" - }, - { - "coefficient": 1.0, - "variable": "spill[1]#48" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#48" - }, - { - "coefficient": -1.0, - "variable": "reservoir[1]_in#48" - }, - { - "coefficient": -0.0036, - "variable": "inflow[1]#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c526", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]#48" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c527", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "reservoir[1]_out#47" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_in#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c528", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "_inflow[1]#48" - }, - { - "coefficient": 1.0, - "variable": "inflow[1]#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c1_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#1" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#1" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c2_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#1" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#1" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c3_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#2" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#2" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c4_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#2" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#2" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c5_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#3" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#3" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c6_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#3" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#3" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c7_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#4" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#4" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c8_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#4" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#4" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c9_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#5" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#5" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c10_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#5" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#5" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c11_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#6" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#6" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c12_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#6" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#6" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c13_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#7" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#7" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c14_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#7" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#7" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c15_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#8" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#8" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c16_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#8" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#8" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c17_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#9" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#9" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c18_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#9" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#9" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c19_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#10" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c20_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#10" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c21_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#11" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c22_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#11" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c23_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#12" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c24_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#12" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c25_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#13" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c26_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#13" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c27_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#14" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c28_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#14" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c29_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#15" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c30_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#15" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c31_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#16" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c32_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#16" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c33_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#17" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c34_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#17" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c35_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#18" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c36_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#18" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c37_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#19" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c38_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#19" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c39_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#20" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c40_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#20" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c41_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#21" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c42_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#21" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c43_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#22" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c44_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#22" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c45_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#23" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c46_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#23" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c47_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#24" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c48_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#24" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c49_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#25" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c50_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#25" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c51_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#26" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c52_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#26" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c53_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#27" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c54_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#27" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c55_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#28" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c56_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#28" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c57_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#29" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c58_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#29" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c59_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#30" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c60_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#30" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c61_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#31" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c62_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#31" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c63_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#32" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c64_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#32" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c65_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#33" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c66_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#33" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c67_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#34" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c68_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#34" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c69_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#35" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c70_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#35" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c71_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#36" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c72_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#36" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c73_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#37" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c74_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#37" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c75_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#38" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c76_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#38" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c77_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#39" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c78_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#39" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c79_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#40" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c80_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#40" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c81_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#41" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c82_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#41" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c83_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#42" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c84_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#42" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c85_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#43" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c86_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#43" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c87_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#44" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c88_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#44" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c89_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#45" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c90_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#45" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c91_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#46" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c92_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#46" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c93_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#47" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c94_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#47" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c95_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "min_volume_violation[1]#48" - }, - { - "coefficient": 1.0, - "variable": "reservoir[1]_out#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c96_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "outflow[1]#48" - }, - { - "coefficient": 1.0, - "variable": "min_outflow_violation[1]#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c1_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#1" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#1" - } - ], - "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[2]#1" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#1" - } - ], - "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[3]#1" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#1" - } - ], - "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[2]#2" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#2" - } - ], - "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[2]#2" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#2" - } - ], - "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[3]#2" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#2" - } - ], - "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[2]#3" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#3" - } - ], - "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[2]#3" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#3" - } - ], - "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[3]#3" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#3" - } - ], - "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[2]#4" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#4" - } - ], - "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[2]#4" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#4" - } - ], - "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[3]#4" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#4" - } - ], - "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[2]#5" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#5" - } - ], - "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[2]#5" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#5" - } - ], - "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[3]#5" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#5" - } - ], - "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[2]#6" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#6" - } - ], - "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[2]#6" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#6" - } - ], - "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]#6" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#6" - } - ], - "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[2]#7" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#7" - } - ], - "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[2]#7" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#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[3]#7" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#7" - } - ], - "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[2]#8" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#8" - } - ], - "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[2]#8" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#8" - } - ], - "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[3]#8" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#8" - } - ], - "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[2]#9" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#9" - } - ], - "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[2]#9" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#9" - } - ], - "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[3]#9" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#9" - } - ], - "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[2]#10" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#10" - } - ], - "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[2]#10" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#10" - } - ], - "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[3]#10" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c31_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#11" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c32_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#11" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c33_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#11" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c34_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#12" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c35_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#12" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c36_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#12" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c37_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#13" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c38_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#13" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c39_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#13" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c40_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#14" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c41_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#14" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c42_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#14" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c43_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#15" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c44_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#15" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c45_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#15" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c46_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#16" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c47_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#16" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c48_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#16" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c49_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#17" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c50_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#17" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c51_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#17" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c52_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#18" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c53_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#18" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c54_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#18" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c55_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#19" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c56_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#19" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c57_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#19" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c58_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#20" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c59_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#20" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c60_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#20" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c61_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#21" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c62_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#21" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c63_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#21" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c64_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#22" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c65_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#22" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c66_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#22" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c67_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#23" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c68_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#23" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c69_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#23" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c70_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#24" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c71_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#24" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c72_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#24" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c73_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#25" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c74_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#25" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c75_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#25" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c76_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#26" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c77_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#26" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c78_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#26" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c79_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#27" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c80_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#27" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c81_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#27" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c82_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#28" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c83_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#28" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c84_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#28" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c85_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#29" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c86_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#29" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c87_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#29" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c88_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#30" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c89_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#30" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c90_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#30" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c91_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#31" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c92_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#31" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c93_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#31" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c94_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#32" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c95_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#32" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c96_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#32" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c97_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#33" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c98_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#33" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c99_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#33" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c100_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#34" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c101_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#34" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c102_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#34" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c103_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#35" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c104_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#35" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c105_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#35" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c106_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#36" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c107_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#36" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c108_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#36" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c109_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#37" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c110_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#37" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c111_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#37" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c112_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#38" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c113_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#38" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c114_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#38" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c115_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#39" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c116_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#39" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c117_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#39" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c118_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#40" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c119_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#40" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c120_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#40" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c121_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#41" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c122_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#41" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c123_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#41" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c124_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#42" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c125_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#42" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c126_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#42" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c127_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#43" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c128_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#43" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c129_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#43" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c130_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#44" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c131_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#44" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c132_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#44" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c133_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#45" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c134_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#45" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c135_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#45" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c136_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#46" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c137_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#46" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c138_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#46" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c139_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#47" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c140_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#47" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c141_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#47" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c142_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#48" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c143_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]#48" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "name": "c144_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[3]#48" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]#48" - } - ], - "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[(2, 3, 2)]#1", - "variable_2": "0_p[(2, 3, 2)]#1" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#1", - "variable_2": "0_q[(2, 3, 2)]#1" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c2_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#1", - "variable_2": "0_p[(2, 2, 3)]#1" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#1", - "variable_2": "0_q[(2, 2, 3)]#1" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c3_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#1", - "variable_2": "0_p[(3, 1, 2)]#1" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#1", - "variable_2": "0_q[(3, 1, 2)]#1" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c4_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#1", - "variable_2": "0_p[(3, 2, 1)]#1" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#1", - "variable_2": "0_q[(3, 2, 1)]#1" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c5_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#1", - "variable_2": "0_p[(1, 1, 3)]#1" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#1", - "variable_2": "0_q[(1, 1, 3)]#1" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c6_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#1", - "variable_2": "0_p[(1, 3, 1)]#1" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#1", - "variable_2": "0_q[(1, 3, 1)]#1" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c7_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#2", - "variable_2": "0_p[(2, 3, 2)]#2" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#2", - "variable_2": "0_q[(2, 3, 2)]#2" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c8_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#2", - "variable_2": "0_p[(2, 2, 3)]#2" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#2", - "variable_2": "0_q[(2, 2, 3)]#2" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c9_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#2", - "variable_2": "0_p[(3, 1, 2)]#2" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#2", - "variable_2": "0_q[(3, 1, 2)]#2" - } - ], - "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[(3, 2, 1)]#2", - "variable_2": "0_p[(3, 2, 1)]#2" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#2", - "variable_2": "0_q[(3, 2, 1)]#2" - } - ], - "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[(1, 1, 3)]#2", - "variable_2": "0_p[(1, 1, 3)]#2" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#2", - "variable_2": "0_q[(1, 1, 3)]#2" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c12_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#2", - "variable_2": "0_p[(1, 3, 1)]#2" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#2", - "variable_2": "0_q[(1, 3, 1)]#2" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c13_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#3", - "variable_2": "0_p[(2, 3, 2)]#3" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#3", - "variable_2": "0_q[(2, 3, 2)]#3" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c14_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#3", - "variable_2": "0_p[(2, 2, 3)]#3" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#3", - "variable_2": "0_q[(2, 2, 3)]#3" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c15_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#3", - "variable_2": "0_p[(3, 1, 2)]#3" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#3", - "variable_2": "0_q[(3, 1, 2)]#3" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c16_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#3", - "variable_2": "0_p[(3, 2, 1)]#3" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#3", - "variable_2": "0_q[(3, 2, 1)]#3" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c17_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#3", - "variable_2": "0_p[(1, 1, 3)]#3" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#3", - "variable_2": "0_q[(1, 1, 3)]#3" - } - ], - "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[(1, 3, 1)]#3", - "variable_2": "0_p[(1, 3, 1)]#3" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#3", - "variable_2": "0_q[(1, 3, 1)]#3" - } - ], - "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[(2, 3, 2)]#4", - "variable_2": "0_p[(2, 3, 2)]#4" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#4", - "variable_2": "0_q[(2, 3, 2)]#4" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c20_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#4", - "variable_2": "0_p[(2, 2, 3)]#4" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#4", - "variable_2": "0_q[(2, 2, 3)]#4" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c21_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#4", - "variable_2": "0_p[(3, 1, 2)]#4" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#4", - "variable_2": "0_q[(3, 1, 2)]#4" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c22_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#4", - "variable_2": "0_p[(3, 2, 1)]#4" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#4", - "variable_2": "0_q[(3, 2, 1)]#4" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c23_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#4", - "variable_2": "0_p[(1, 1, 3)]#4" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#4", - "variable_2": "0_q[(1, 1, 3)]#4" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c24_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#4", - "variable_2": "0_p[(1, 3, 1)]#4" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#4", - "variable_2": "0_q[(1, 3, 1)]#4" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c25_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#5", - "variable_2": "0_p[(2, 3, 2)]#5" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#5", - "variable_2": "0_q[(2, 3, 2)]#5" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c26_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#5", - "variable_2": "0_p[(2, 2, 3)]#5" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#5", - "variable_2": "0_q[(2, 2, 3)]#5" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c27_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#5", - "variable_2": "0_p[(3, 1, 2)]#5" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#5", - "variable_2": "0_q[(3, 1, 2)]#5" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c28_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#5", - "variable_2": "0_p[(3, 2, 1)]#5" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#5", - "variable_2": "0_q[(3, 2, 1)]#5" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c29_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#5", - "variable_2": "0_p[(1, 1, 3)]#5" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#5", - "variable_2": "0_q[(1, 1, 3)]#5" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c30_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#5", - "variable_2": "0_p[(1, 3, 1)]#5" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#5", - "variable_2": "0_q[(1, 3, 1)]#5" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c31_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#6", - "variable_2": "0_p[(2, 3, 2)]#6" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#6", - "variable_2": "0_q[(2, 3, 2)]#6" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c32_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#6", - "variable_2": "0_p[(2, 2, 3)]#6" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#6", - "variable_2": "0_q[(2, 2, 3)]#6" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c33_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#6", - "variable_2": "0_p[(3, 1, 2)]#6" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#6", - "variable_2": "0_q[(3, 1, 2)]#6" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c34_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#6", - "variable_2": "0_p[(3, 2, 1)]#6" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#6", - "variable_2": "0_q[(3, 2, 1)]#6" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c35_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#6", - "variable_2": "0_p[(1, 1, 3)]#6" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#6", - "variable_2": "0_q[(1, 1, 3)]#6" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c36_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#6", - "variable_2": "0_p[(1, 3, 1)]#6" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#6", - "variable_2": "0_q[(1, 3, 1)]#6" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c37_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#7", - "variable_2": "0_p[(2, 3, 2)]#7" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#7", - "variable_2": "0_q[(2, 3, 2)]#7" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c38_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#7", - "variable_2": "0_p[(2, 2, 3)]#7" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#7", - "variable_2": "0_q[(2, 2, 3)]#7" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c39_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#7", - "variable_2": "0_p[(3, 1, 2)]#7" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#7", - "variable_2": "0_q[(3, 1, 2)]#7" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c40_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#7", - "variable_2": "0_p[(3, 2, 1)]#7" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#7", - "variable_2": "0_q[(3, 2, 1)]#7" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c41_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#7", - "variable_2": "0_p[(1, 1, 3)]#7" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#7", - "variable_2": "0_q[(1, 1, 3)]#7" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c42_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#7", - "variable_2": "0_p[(1, 3, 1)]#7" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#7", - "variable_2": "0_q[(1, 3, 1)]#7" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c43_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#8", - "variable_2": "0_p[(2, 3, 2)]#8" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#8", - "variable_2": "0_q[(2, 3, 2)]#8" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c44_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#8", - "variable_2": "0_p[(2, 2, 3)]#8" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#8", - "variable_2": "0_q[(2, 2, 3)]#8" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c45_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#8", - "variable_2": "0_p[(3, 1, 2)]#8" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#8", - "variable_2": "0_q[(3, 1, 2)]#8" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c46_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#8", - "variable_2": "0_p[(3, 2, 1)]#8" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#8", - "variable_2": "0_q[(3, 2, 1)]#8" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c47_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#8", - "variable_2": "0_p[(1, 1, 3)]#8" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#8", - "variable_2": "0_q[(1, 1, 3)]#8" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c48_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#8", - "variable_2": "0_p[(1, 3, 1)]#8" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#8", - "variable_2": "0_q[(1, 3, 1)]#8" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c49_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#9", - "variable_2": "0_p[(2, 3, 2)]#9" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#9", - "variable_2": "0_q[(2, 3, 2)]#9" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c50_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#9", - "variable_2": "0_p[(2, 2, 3)]#9" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#9", - "variable_2": "0_q[(2, 2, 3)]#9" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c51_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#9", - "variable_2": "0_p[(3, 1, 2)]#9" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#9", - "variable_2": "0_q[(3, 1, 2)]#9" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c52_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#9", - "variable_2": "0_p[(3, 2, 1)]#9" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#9", - "variable_2": "0_q[(3, 2, 1)]#9" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c53_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#9", - "variable_2": "0_p[(1, 1, 3)]#9" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#9", - "variable_2": "0_q[(1, 1, 3)]#9" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c54_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#9", - "variable_2": "0_p[(1, 3, 1)]#9" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#9", - "variable_2": "0_q[(1, 3, 1)]#9" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c55_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#10", - "variable_2": "0_p[(2, 3, 2)]#10" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#10", - "variable_2": "0_q[(2, 3, 2)]#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c56_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#10", - "variable_2": "0_p[(2, 2, 3)]#10" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#10", - "variable_2": "0_q[(2, 2, 3)]#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c57_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#10", - "variable_2": "0_p[(3, 1, 2)]#10" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#10", - "variable_2": "0_q[(3, 1, 2)]#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c58_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#10", - "variable_2": "0_p[(3, 2, 1)]#10" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#10", - "variable_2": "0_q[(3, 2, 1)]#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c59_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#10", - "variable_2": "0_p[(1, 1, 3)]#10" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#10", - "variable_2": "0_q[(1, 1, 3)]#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c60_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#10", - "variable_2": "0_p[(1, 3, 1)]#10" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#10", - "variable_2": "0_q[(1, 3, 1)]#10" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c61_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#11", - "variable_2": "0_p[(2, 3, 2)]#11" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#11", - "variable_2": "0_q[(2, 3, 2)]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c62_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#11", - "variable_2": "0_p[(2, 2, 3)]#11" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#11", - "variable_2": "0_q[(2, 2, 3)]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c63_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#11", - "variable_2": "0_p[(3, 1, 2)]#11" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#11", - "variable_2": "0_q[(3, 1, 2)]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c64_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#11", - "variable_2": "0_p[(3, 2, 1)]#11" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#11", - "variable_2": "0_q[(3, 2, 1)]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c65_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#11", - "variable_2": "0_p[(1, 1, 3)]#11" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#11", - "variable_2": "0_q[(1, 1, 3)]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c66_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#11", - "variable_2": "0_p[(1, 3, 1)]#11" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#11", - "variable_2": "0_q[(1, 3, 1)]#11" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c67_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#12", - "variable_2": "0_p[(2, 3, 2)]#12" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#12", - "variable_2": "0_q[(2, 3, 2)]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c68_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#12", - "variable_2": "0_p[(2, 2, 3)]#12" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#12", - "variable_2": "0_q[(2, 2, 3)]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c69_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#12", - "variable_2": "0_p[(3, 1, 2)]#12" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#12", - "variable_2": "0_q[(3, 1, 2)]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c70_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#12", - "variable_2": "0_p[(3, 2, 1)]#12" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#12", - "variable_2": "0_q[(3, 2, 1)]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c71_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#12", - "variable_2": "0_p[(1, 1, 3)]#12" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#12", - "variable_2": "0_q[(1, 1, 3)]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c72_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#12", - "variable_2": "0_p[(1, 3, 1)]#12" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#12", - "variable_2": "0_q[(1, 3, 1)]#12" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c73_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#13", - "variable_2": "0_p[(2, 3, 2)]#13" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#13", - "variable_2": "0_q[(2, 3, 2)]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c74_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#13", - "variable_2": "0_p[(2, 2, 3)]#13" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#13", - "variable_2": "0_q[(2, 2, 3)]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c75_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#13", - "variable_2": "0_p[(3, 1, 2)]#13" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#13", - "variable_2": "0_q[(3, 1, 2)]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c76_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#13", - "variable_2": "0_p[(3, 2, 1)]#13" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#13", - "variable_2": "0_q[(3, 2, 1)]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c77_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#13", - "variable_2": "0_p[(1, 1, 3)]#13" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#13", - "variable_2": "0_q[(1, 1, 3)]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c78_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#13", - "variable_2": "0_p[(1, 3, 1)]#13" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#13", - "variable_2": "0_q[(1, 3, 1)]#13" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c79_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#14", - "variable_2": "0_p[(2, 3, 2)]#14" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#14", - "variable_2": "0_q[(2, 3, 2)]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c80_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#14", - "variable_2": "0_p[(2, 2, 3)]#14" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#14", - "variable_2": "0_q[(2, 2, 3)]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c81_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#14", - "variable_2": "0_p[(3, 1, 2)]#14" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#14", - "variable_2": "0_q[(3, 1, 2)]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c82_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#14", - "variable_2": "0_p[(3, 2, 1)]#14" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#14", - "variable_2": "0_q[(3, 2, 1)]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c83_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#14", - "variable_2": "0_p[(1, 1, 3)]#14" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#14", - "variable_2": "0_q[(1, 1, 3)]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c84_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#14", - "variable_2": "0_p[(1, 3, 1)]#14" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#14", - "variable_2": "0_q[(1, 3, 1)]#14" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c85_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#15", - "variable_2": "0_p[(2, 3, 2)]#15" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#15", - "variable_2": "0_q[(2, 3, 2)]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c86_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#15", - "variable_2": "0_p[(2, 2, 3)]#15" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#15", - "variable_2": "0_q[(2, 2, 3)]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c87_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#15", - "variable_2": "0_p[(3, 1, 2)]#15" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#15", - "variable_2": "0_q[(3, 1, 2)]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c88_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#15", - "variable_2": "0_p[(3, 2, 1)]#15" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#15", - "variable_2": "0_q[(3, 2, 1)]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c89_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#15", - "variable_2": "0_p[(1, 1, 3)]#15" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#15", - "variable_2": "0_q[(1, 1, 3)]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c90_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#15", - "variable_2": "0_p[(1, 3, 1)]#15" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#15", - "variable_2": "0_q[(1, 3, 1)]#15" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c91_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#16", - "variable_2": "0_p[(2, 3, 2)]#16" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#16", - "variable_2": "0_q[(2, 3, 2)]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c92_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#16", - "variable_2": "0_p[(2, 2, 3)]#16" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#16", - "variable_2": "0_q[(2, 2, 3)]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c93_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#16", - "variable_2": "0_p[(3, 1, 2)]#16" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#16", - "variable_2": "0_q[(3, 1, 2)]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c94_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#16", - "variable_2": "0_p[(3, 2, 1)]#16" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#16", - "variable_2": "0_q[(3, 2, 1)]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c95_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#16", - "variable_2": "0_p[(1, 1, 3)]#16" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#16", - "variable_2": "0_q[(1, 1, 3)]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c96_3", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#16", - "variable_2": "0_p[(1, 3, 1)]#16" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#16", - "variable_2": "0_q[(1, 3, 1)]#16" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c97_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#17", - "variable_2": "0_p[(2, 3, 2)]#17" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#17", - "variable_2": "0_q[(2, 3, 2)]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c98_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#17", - "variable_2": "0_p[(2, 2, 3)]#17" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#17", - "variable_2": "0_q[(2, 2, 3)]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c99_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#17", - "variable_2": "0_p[(3, 1, 2)]#17" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#17", - "variable_2": "0_q[(3, 1, 2)]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c100_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#17", - "variable_2": "0_p[(3, 2, 1)]#17" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#17", - "variable_2": "0_q[(3, 2, 1)]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c101_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#17", - "variable_2": "0_p[(1, 1, 3)]#17" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#17", - "variable_2": "0_q[(1, 1, 3)]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c102_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#17", - "variable_2": "0_p[(1, 3, 1)]#17" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#17", - "variable_2": "0_q[(1, 3, 1)]#17" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c103_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#18", - "variable_2": "0_p[(2, 3, 2)]#18" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#18", - "variable_2": "0_q[(2, 3, 2)]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c104_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#18", - "variable_2": "0_p[(2, 2, 3)]#18" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#18", - "variable_2": "0_q[(2, 2, 3)]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c105_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#18", - "variable_2": "0_p[(3, 1, 2)]#18" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#18", - "variable_2": "0_q[(3, 1, 2)]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c106_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#18", - "variable_2": "0_p[(3, 2, 1)]#18" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#18", - "variable_2": "0_q[(3, 2, 1)]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c107_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#18", - "variable_2": "0_p[(1, 1, 3)]#18" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#18", - "variable_2": "0_q[(1, 1, 3)]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c108_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#18", - "variable_2": "0_p[(1, 3, 1)]#18" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#18", - "variable_2": "0_q[(1, 3, 1)]#18" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c109_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#19", - "variable_2": "0_p[(2, 3, 2)]#19" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#19", - "variable_2": "0_q[(2, 3, 2)]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c110_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#19", - "variable_2": "0_p[(2, 2, 3)]#19" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#19", - "variable_2": "0_q[(2, 2, 3)]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c111_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#19", - "variable_2": "0_p[(3, 1, 2)]#19" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#19", - "variable_2": "0_q[(3, 1, 2)]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c112_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#19", - "variable_2": "0_p[(3, 2, 1)]#19" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#19", - "variable_2": "0_q[(3, 2, 1)]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c113_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#19", - "variable_2": "0_p[(1, 1, 3)]#19" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#19", - "variable_2": "0_q[(1, 1, 3)]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c114_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#19", - "variable_2": "0_p[(1, 3, 1)]#19" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#19", - "variable_2": "0_q[(1, 3, 1)]#19" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c115_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#20", - "variable_2": "0_p[(2, 3, 2)]#20" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#20", - "variable_2": "0_q[(2, 3, 2)]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c116_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#20", - "variable_2": "0_p[(2, 2, 3)]#20" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#20", - "variable_2": "0_q[(2, 2, 3)]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c117_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#20", - "variable_2": "0_p[(3, 1, 2)]#20" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#20", - "variable_2": "0_q[(3, 1, 2)]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c118_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#20", - "variable_2": "0_p[(3, 2, 1)]#20" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#20", - "variable_2": "0_q[(3, 2, 1)]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c119_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#20", - "variable_2": "0_p[(1, 1, 3)]#20" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#20", - "variable_2": "0_q[(1, 1, 3)]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c120_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#20", - "variable_2": "0_p[(1, 3, 1)]#20" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#20", - "variable_2": "0_q[(1, 3, 1)]#20" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c121_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#21", - "variable_2": "0_p[(2, 3, 2)]#21" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#21", - "variable_2": "0_q[(2, 3, 2)]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c122_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#21", - "variable_2": "0_p[(2, 2, 3)]#21" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#21", - "variable_2": "0_q[(2, 2, 3)]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c123_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#21", - "variable_2": "0_p[(3, 1, 2)]#21" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#21", - "variable_2": "0_q[(3, 1, 2)]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c124_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#21", - "variable_2": "0_p[(3, 2, 1)]#21" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#21", - "variable_2": "0_q[(3, 2, 1)]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c125_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#21", - "variable_2": "0_p[(1, 1, 3)]#21" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#21", - "variable_2": "0_q[(1, 1, 3)]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c126_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#21", - "variable_2": "0_p[(1, 3, 1)]#21" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#21", - "variable_2": "0_q[(1, 3, 1)]#21" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c127_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#22", - "variable_2": "0_p[(2, 3, 2)]#22" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#22", - "variable_2": "0_q[(2, 3, 2)]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c128_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#22", - "variable_2": "0_p[(2, 2, 3)]#22" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#22", - "variable_2": "0_q[(2, 2, 3)]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c129_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#22", - "variable_2": "0_p[(3, 1, 2)]#22" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#22", - "variable_2": "0_q[(3, 1, 2)]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c130_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#22", - "variable_2": "0_p[(3, 2, 1)]#22" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#22", - "variable_2": "0_q[(3, 2, 1)]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c131_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#22", - "variable_2": "0_p[(1, 1, 3)]#22" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#22", - "variable_2": "0_q[(1, 1, 3)]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c132_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#22", - "variable_2": "0_p[(1, 3, 1)]#22" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#22", - "variable_2": "0_q[(1, 3, 1)]#22" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c133_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#23", - "variable_2": "0_p[(2, 3, 2)]#23" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#23", - "variable_2": "0_q[(2, 3, 2)]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c134_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#23", - "variable_2": "0_p[(2, 2, 3)]#23" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#23", - "variable_2": "0_q[(2, 2, 3)]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c135_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#23", - "variable_2": "0_p[(3, 1, 2)]#23" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#23", - "variable_2": "0_q[(3, 1, 2)]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c136_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#23", - "variable_2": "0_p[(3, 2, 1)]#23" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#23", - "variable_2": "0_q[(3, 2, 1)]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c137_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#23", - "variable_2": "0_p[(1, 1, 3)]#23" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#23", - "variable_2": "0_q[(1, 1, 3)]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c138_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#23", - "variable_2": "0_p[(1, 3, 1)]#23" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#23", - "variable_2": "0_q[(1, 3, 1)]#23" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c139_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#24", - "variable_2": "0_p[(2, 3, 2)]#24" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#24", - "variable_2": "0_q[(2, 3, 2)]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c140_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#24", - "variable_2": "0_p[(2, 2, 3)]#24" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#24", - "variable_2": "0_q[(2, 2, 3)]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c141_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#24", - "variable_2": "0_p[(3, 1, 2)]#24" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#24", - "variable_2": "0_q[(3, 1, 2)]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c142_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#24", - "variable_2": "0_p[(3, 2, 1)]#24" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#24", - "variable_2": "0_q[(3, 2, 1)]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c143_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#24", - "variable_2": "0_p[(1, 1, 3)]#24" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#24", - "variable_2": "0_q[(1, 1, 3)]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c144_2", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#24", - "variable_2": "0_p[(1, 3, 1)]#24" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#24", - "variable_2": "0_q[(1, 3, 1)]#24" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c145_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#25", - "variable_2": "0_p[(2, 3, 2)]#25" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#25", - "variable_2": "0_q[(2, 3, 2)]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c146_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#25", - "variable_2": "0_p[(2, 2, 3)]#25" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#25", - "variable_2": "0_q[(2, 2, 3)]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c147_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#25", - "variable_2": "0_p[(3, 1, 2)]#25" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#25", - "variable_2": "0_q[(3, 1, 2)]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c148_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#25", - "variable_2": "0_p[(3, 2, 1)]#25" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#25", - "variable_2": "0_q[(3, 2, 1)]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c149_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#25", - "variable_2": "0_p[(1, 1, 3)]#25" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#25", - "variable_2": "0_q[(1, 1, 3)]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c150_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#25", - "variable_2": "0_p[(1, 3, 1)]#25" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#25", - "variable_2": "0_q[(1, 3, 1)]#25" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c151_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#26", - "variable_2": "0_p[(2, 3, 2)]#26" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#26", - "variable_2": "0_q[(2, 3, 2)]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c152_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#26", - "variable_2": "0_p[(2, 2, 3)]#26" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#26", - "variable_2": "0_q[(2, 2, 3)]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c153_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#26", - "variable_2": "0_p[(3, 1, 2)]#26" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#26", - "variable_2": "0_q[(3, 1, 2)]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c154_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#26", - "variable_2": "0_p[(3, 2, 1)]#26" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#26", - "variable_2": "0_q[(3, 2, 1)]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c155_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#26", - "variable_2": "0_p[(1, 1, 3)]#26" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#26", - "variable_2": "0_q[(1, 1, 3)]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c156_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#26", - "variable_2": "0_p[(1, 3, 1)]#26" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#26", - "variable_2": "0_q[(1, 3, 1)]#26" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c157_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#27", - "variable_2": "0_p[(2, 3, 2)]#27" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#27", - "variable_2": "0_q[(2, 3, 2)]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c158_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#27", - "variable_2": "0_p[(2, 2, 3)]#27" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#27", - "variable_2": "0_q[(2, 2, 3)]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c159_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#27", - "variable_2": "0_p[(3, 1, 2)]#27" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#27", - "variable_2": "0_q[(3, 1, 2)]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c160_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#27", - "variable_2": "0_p[(3, 2, 1)]#27" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#27", - "variable_2": "0_q[(3, 2, 1)]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c161_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#27", - "variable_2": "0_p[(1, 1, 3)]#27" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#27", - "variable_2": "0_q[(1, 1, 3)]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c162_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#27", - "variable_2": "0_p[(1, 3, 1)]#27" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#27", - "variable_2": "0_q[(1, 3, 1)]#27" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c163_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#28", - "variable_2": "0_p[(2, 3, 2)]#28" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#28", - "variable_2": "0_q[(2, 3, 2)]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c164_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#28", - "variable_2": "0_p[(2, 2, 3)]#28" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#28", - "variable_2": "0_q[(2, 2, 3)]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c165_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#28", - "variable_2": "0_p[(3, 1, 2)]#28" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#28", - "variable_2": "0_q[(3, 1, 2)]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c166_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#28", - "variable_2": "0_p[(3, 2, 1)]#28" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#28", - "variable_2": "0_q[(3, 2, 1)]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c167_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#28", - "variable_2": "0_p[(1, 1, 3)]#28" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#28", - "variable_2": "0_q[(1, 1, 3)]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c168_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#28", - "variable_2": "0_p[(1, 3, 1)]#28" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#28", - "variable_2": "0_q[(1, 3, 1)]#28" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c169_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#29", - "variable_2": "0_p[(2, 3, 2)]#29" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#29", - "variable_2": "0_q[(2, 3, 2)]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c170_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#29", - "variable_2": "0_p[(2, 2, 3)]#29" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#29", - "variable_2": "0_q[(2, 2, 3)]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c171_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#29", - "variable_2": "0_p[(3, 1, 2)]#29" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#29", - "variable_2": "0_q[(3, 1, 2)]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c172_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#29", - "variable_2": "0_p[(3, 2, 1)]#29" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#29", - "variable_2": "0_q[(3, 2, 1)]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c173_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#29", - "variable_2": "0_p[(1, 1, 3)]#29" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#29", - "variable_2": "0_q[(1, 1, 3)]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c174_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#29", - "variable_2": "0_p[(1, 3, 1)]#29" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#29", - "variable_2": "0_q[(1, 3, 1)]#29" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c175_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#30", - "variable_2": "0_p[(2, 3, 2)]#30" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#30", - "variable_2": "0_q[(2, 3, 2)]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c176_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#30", - "variable_2": "0_p[(2, 2, 3)]#30" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#30", - "variable_2": "0_q[(2, 2, 3)]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c177_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#30", - "variable_2": "0_p[(3, 1, 2)]#30" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#30", - "variable_2": "0_q[(3, 1, 2)]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c178_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#30", - "variable_2": "0_p[(3, 2, 1)]#30" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#30", - "variable_2": "0_q[(3, 2, 1)]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c179_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#30", - "variable_2": "0_p[(1, 1, 3)]#30" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#30", - "variable_2": "0_q[(1, 1, 3)]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c180_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#30", - "variable_2": "0_p[(1, 3, 1)]#30" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#30", - "variable_2": "0_q[(1, 3, 1)]#30" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c181_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#31", - "variable_2": "0_p[(2, 3, 2)]#31" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#31", - "variable_2": "0_q[(2, 3, 2)]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c182_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#31", - "variable_2": "0_p[(2, 2, 3)]#31" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#31", - "variable_2": "0_q[(2, 2, 3)]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c183_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#31", - "variable_2": "0_p[(3, 1, 2)]#31" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#31", - "variable_2": "0_q[(3, 1, 2)]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c184_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#31", - "variable_2": "0_p[(3, 2, 1)]#31" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#31", - "variable_2": "0_q[(3, 2, 1)]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c185_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#31", - "variable_2": "0_p[(1, 1, 3)]#31" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#31", - "variable_2": "0_q[(1, 1, 3)]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c186_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#31", - "variable_2": "0_p[(1, 3, 1)]#31" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#31", - "variable_2": "0_q[(1, 3, 1)]#31" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c187_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#32", - "variable_2": "0_p[(2, 3, 2)]#32" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#32", - "variable_2": "0_q[(2, 3, 2)]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c188_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#32", - "variable_2": "0_p[(2, 2, 3)]#32" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#32", - "variable_2": "0_q[(2, 2, 3)]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c189_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#32", - "variable_2": "0_p[(3, 1, 2)]#32" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#32", - "variable_2": "0_q[(3, 1, 2)]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c190_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#32", - "variable_2": "0_p[(3, 2, 1)]#32" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#32", - "variable_2": "0_q[(3, 2, 1)]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c191_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#32", - "variable_2": "0_p[(1, 1, 3)]#32" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#32", - "variable_2": "0_q[(1, 1, 3)]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c192_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#32", - "variable_2": "0_p[(1, 3, 1)]#32" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#32", - "variable_2": "0_q[(1, 3, 1)]#32" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c193_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#33", - "variable_2": "0_p[(2, 3, 2)]#33" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#33", - "variable_2": "0_q[(2, 3, 2)]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c194_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#33", - "variable_2": "0_p[(2, 2, 3)]#33" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#33", - "variable_2": "0_q[(2, 2, 3)]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c195_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#33", - "variable_2": "0_p[(3, 1, 2)]#33" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#33", - "variable_2": "0_q[(3, 1, 2)]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c196_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#33", - "variable_2": "0_p[(3, 2, 1)]#33" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#33", - "variable_2": "0_q[(3, 2, 1)]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c197_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#33", - "variable_2": "0_p[(1, 1, 3)]#33" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#33", - "variable_2": "0_q[(1, 1, 3)]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c198_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#33", - "variable_2": "0_p[(1, 3, 1)]#33" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#33", - "variable_2": "0_q[(1, 3, 1)]#33" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c199_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#34", - "variable_2": "0_p[(2, 3, 2)]#34" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#34", - "variable_2": "0_q[(2, 3, 2)]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c200_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#34", - "variable_2": "0_p[(2, 2, 3)]#34" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#34", - "variable_2": "0_q[(2, 2, 3)]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c201_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#34", - "variable_2": "0_p[(3, 1, 2)]#34" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#34", - "variable_2": "0_q[(3, 1, 2)]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c202_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#34", - "variable_2": "0_p[(3, 2, 1)]#34" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#34", - "variable_2": "0_q[(3, 2, 1)]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c203_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#34", - "variable_2": "0_p[(1, 1, 3)]#34" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#34", - "variable_2": "0_q[(1, 1, 3)]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c204_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#34", - "variable_2": "0_p[(1, 3, 1)]#34" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#34", - "variable_2": "0_q[(1, 3, 1)]#34" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c205_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#35", - "variable_2": "0_p[(2, 3, 2)]#35" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#35", - "variable_2": "0_q[(2, 3, 2)]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c206_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#35", - "variable_2": "0_p[(2, 2, 3)]#35" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#35", - "variable_2": "0_q[(2, 2, 3)]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c207_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#35", - "variable_2": "0_p[(3, 1, 2)]#35" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#35", - "variable_2": "0_q[(3, 1, 2)]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c208_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#35", - "variable_2": "0_p[(3, 2, 1)]#35" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#35", - "variable_2": "0_q[(3, 2, 1)]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c209_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#35", - "variable_2": "0_p[(1, 1, 3)]#35" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#35", - "variable_2": "0_q[(1, 1, 3)]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c210_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#35", - "variable_2": "0_p[(1, 3, 1)]#35" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#35", - "variable_2": "0_q[(1, 3, 1)]#35" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c211_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#36", - "variable_2": "0_p[(2, 3, 2)]#36" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#36", - "variable_2": "0_q[(2, 3, 2)]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c212_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#36", - "variable_2": "0_p[(2, 2, 3)]#36" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#36", - "variable_2": "0_q[(2, 2, 3)]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c213_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#36", - "variable_2": "0_p[(3, 1, 2)]#36" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#36", - "variable_2": "0_q[(3, 1, 2)]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c214_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#36", - "variable_2": "0_p[(3, 2, 1)]#36" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#36", - "variable_2": "0_q[(3, 2, 1)]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c215_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#36", - "variable_2": "0_p[(1, 1, 3)]#36" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#36", - "variable_2": "0_q[(1, 1, 3)]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c216_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#36", - "variable_2": "0_p[(1, 3, 1)]#36" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#36", - "variable_2": "0_q[(1, 3, 1)]#36" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c217_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#37", - "variable_2": "0_p[(2, 3, 2)]#37" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#37", - "variable_2": "0_q[(2, 3, 2)]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c218_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#37", - "variable_2": "0_p[(2, 2, 3)]#37" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#37", - "variable_2": "0_q[(2, 2, 3)]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c219_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#37", - "variable_2": "0_p[(3, 1, 2)]#37" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#37", - "variable_2": "0_q[(3, 1, 2)]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c220_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#37", - "variable_2": "0_p[(3, 2, 1)]#37" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#37", - "variable_2": "0_q[(3, 2, 1)]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c221_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#37", - "variable_2": "0_p[(1, 1, 3)]#37" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#37", - "variable_2": "0_q[(1, 1, 3)]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c222_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#37", - "variable_2": "0_p[(1, 3, 1)]#37" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#37", - "variable_2": "0_q[(1, 3, 1)]#37" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c223_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#38", - "variable_2": "0_p[(2, 3, 2)]#38" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#38", - "variable_2": "0_q[(2, 3, 2)]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c224_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#38", - "variable_2": "0_p[(2, 2, 3)]#38" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#38", - "variable_2": "0_q[(2, 2, 3)]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c225_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#38", - "variable_2": "0_p[(3, 1, 2)]#38" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#38", - "variable_2": "0_q[(3, 1, 2)]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c226_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#38", - "variable_2": "0_p[(3, 2, 1)]#38" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#38", - "variable_2": "0_q[(3, 2, 1)]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c227_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#38", - "variable_2": "0_p[(1, 1, 3)]#38" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#38", - "variable_2": "0_q[(1, 1, 3)]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c228_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#38", - "variable_2": "0_p[(1, 3, 1)]#38" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#38", - "variable_2": "0_q[(1, 3, 1)]#38" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c229_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#39", - "variable_2": "0_p[(2, 3, 2)]#39" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#39", - "variable_2": "0_q[(2, 3, 2)]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c230_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#39", - "variable_2": "0_p[(2, 2, 3)]#39" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#39", - "variable_2": "0_q[(2, 2, 3)]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c231_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#39", - "variable_2": "0_p[(3, 1, 2)]#39" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#39", - "variable_2": "0_q[(3, 1, 2)]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c232_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#39", - "variable_2": "0_p[(3, 2, 1)]#39" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#39", - "variable_2": "0_q[(3, 2, 1)]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c233_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#39", - "variable_2": "0_p[(1, 1, 3)]#39" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#39", - "variable_2": "0_q[(1, 1, 3)]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c234_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#39", - "variable_2": "0_p[(1, 3, 1)]#39" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#39", - "variable_2": "0_q[(1, 3, 1)]#39" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c235_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#40", - "variable_2": "0_p[(2, 3, 2)]#40" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#40", - "variable_2": "0_q[(2, 3, 2)]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c236_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#40", - "variable_2": "0_p[(2, 2, 3)]#40" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#40", - "variable_2": "0_q[(2, 2, 3)]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c237_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#40", - "variable_2": "0_p[(3, 1, 2)]#40" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#40", - "variable_2": "0_q[(3, 1, 2)]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c238_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#40", - "variable_2": "0_p[(3, 2, 1)]#40" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#40", - "variable_2": "0_q[(3, 2, 1)]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c239_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#40", - "variable_2": "0_p[(1, 1, 3)]#40" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#40", - "variable_2": "0_q[(1, 1, 3)]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c240_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#40", - "variable_2": "0_p[(1, 3, 1)]#40" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#40", - "variable_2": "0_q[(1, 3, 1)]#40" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c241_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#41", - "variable_2": "0_p[(2, 3, 2)]#41" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#41", - "variable_2": "0_q[(2, 3, 2)]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c242_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#41", - "variable_2": "0_p[(2, 2, 3)]#41" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#41", - "variable_2": "0_q[(2, 2, 3)]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c243_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#41", - "variable_2": "0_p[(3, 1, 2)]#41" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#41", - "variable_2": "0_q[(3, 1, 2)]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c244_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#41", - "variable_2": "0_p[(3, 2, 1)]#41" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#41", - "variable_2": "0_q[(3, 2, 1)]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c245_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#41", - "variable_2": "0_p[(1, 1, 3)]#41" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#41", - "variable_2": "0_q[(1, 1, 3)]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c246_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#41", - "variable_2": "0_p[(1, 3, 1)]#41" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#41", - "variable_2": "0_q[(1, 3, 1)]#41" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c247_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#42", - "variable_2": "0_p[(2, 3, 2)]#42" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#42", - "variable_2": "0_q[(2, 3, 2)]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c248_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#42", - "variable_2": "0_p[(2, 2, 3)]#42" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#42", - "variable_2": "0_q[(2, 2, 3)]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c249_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#42", - "variable_2": "0_p[(3, 1, 2)]#42" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#42", - "variable_2": "0_q[(3, 1, 2)]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c250_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#42", - "variable_2": "0_p[(3, 2, 1)]#42" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#42", - "variable_2": "0_q[(3, 2, 1)]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c251_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#42", - "variable_2": "0_p[(1, 1, 3)]#42" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#42", - "variable_2": "0_q[(1, 1, 3)]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c252_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#42", - "variable_2": "0_p[(1, 3, 1)]#42" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#42", - "variable_2": "0_q[(1, 3, 1)]#42" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c253_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#43", - "variable_2": "0_p[(2, 3, 2)]#43" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#43", - "variable_2": "0_q[(2, 3, 2)]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c254_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#43", - "variable_2": "0_p[(2, 2, 3)]#43" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#43", - "variable_2": "0_q[(2, 2, 3)]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c255_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#43", - "variable_2": "0_p[(3, 1, 2)]#43" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#43", - "variable_2": "0_q[(3, 1, 2)]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c256_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#43", - "variable_2": "0_p[(3, 2, 1)]#43" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#43", - "variable_2": "0_q[(3, 2, 1)]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c257_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#43", - "variable_2": "0_p[(1, 1, 3)]#43" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#43", - "variable_2": "0_q[(1, 1, 3)]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c258_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#43", - "variable_2": "0_p[(1, 3, 1)]#43" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#43", - "variable_2": "0_q[(1, 3, 1)]#43" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c259_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#44", - "variable_2": "0_p[(2, 3, 2)]#44" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#44", - "variable_2": "0_q[(2, 3, 2)]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c260_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#44", - "variable_2": "0_p[(2, 2, 3)]#44" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#44", - "variable_2": "0_q[(2, 2, 3)]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c261_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#44", - "variable_2": "0_p[(3, 1, 2)]#44" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#44", - "variable_2": "0_q[(3, 1, 2)]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c262_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#44", - "variable_2": "0_p[(3, 2, 1)]#44" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#44", - "variable_2": "0_q[(3, 2, 1)]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c263_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#44", - "variable_2": "0_p[(1, 1, 3)]#44" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#44", - "variable_2": "0_q[(1, 1, 3)]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c264_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#44", - "variable_2": "0_p[(1, 3, 1)]#44" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#44", - "variable_2": "0_q[(1, 3, 1)]#44" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c265_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#45", - "variable_2": "0_p[(2, 3, 2)]#45" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#45", - "variable_2": "0_q[(2, 3, 2)]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c266_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#45", - "variable_2": "0_p[(2, 2, 3)]#45" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#45", - "variable_2": "0_q[(2, 2, 3)]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c267_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#45", - "variable_2": "0_p[(3, 1, 2)]#45" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#45", - "variable_2": "0_q[(3, 1, 2)]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c268_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#45", - "variable_2": "0_p[(3, 2, 1)]#45" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#45", - "variable_2": "0_q[(3, 2, 1)]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c269_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#45", - "variable_2": "0_p[(1, 1, 3)]#45" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#45", - "variable_2": "0_q[(1, 1, 3)]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c270_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#45", - "variable_2": "0_p[(1, 3, 1)]#45" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#45", - "variable_2": "0_q[(1, 3, 1)]#45" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c271_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#46", - "variable_2": "0_p[(2, 3, 2)]#46" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#46", - "variable_2": "0_q[(2, 3, 2)]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c272_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#46", - "variable_2": "0_p[(2, 2, 3)]#46" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#46", - "variable_2": "0_q[(2, 2, 3)]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c273_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#46", - "variable_2": "0_p[(3, 1, 2)]#46" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#46", - "variable_2": "0_q[(3, 1, 2)]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c274_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#46", - "variable_2": "0_p[(3, 2, 1)]#46" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#46", - "variable_2": "0_q[(3, 2, 1)]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c275_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#46", - "variable_2": "0_p[(1, 1, 3)]#46" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#46", - "variable_2": "0_q[(1, 1, 3)]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c276_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#46", - "variable_2": "0_p[(1, 3, 1)]#46" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#46", - "variable_2": "0_q[(1, 3, 1)]#46" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c277_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#47", - "variable_2": "0_p[(2, 3, 2)]#47" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#47", - "variable_2": "0_q[(2, 3, 2)]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c278_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#47", - "variable_2": "0_p[(2, 2, 3)]#47" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#47", - "variable_2": "0_q[(2, 2, 3)]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c279_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#47", - "variable_2": "0_p[(3, 1, 2)]#47" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#47", - "variable_2": "0_q[(3, 1, 2)]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c280_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#47", - "variable_2": "0_p[(3, 2, 1)]#47" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#47", - "variable_2": "0_q[(3, 2, 1)]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c281_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#47", - "variable_2": "0_p[(1, 1, 3)]#47" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#47", - "variable_2": "0_q[(1, 1, 3)]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c282_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#47", - "variable_2": "0_p[(1, 3, 1)]#47" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#47", - "variable_2": "0_q[(1, 3, 1)]#47" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c283_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 3, 2)]#48", - "variable_2": "0_p[(2, 3, 2)]#48" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 3, 2)]#48", - "variable_2": "0_q[(2, 3, 2)]#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c284_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(2, 2, 3)]#48", - "variable_2": "0_p[(2, 2, 3)]#48" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(2, 2, 3)]#48", - "variable_2": "0_q[(2, 2, 3)]#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.42250000000000004 - } - }, - { - "name": "c285_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 1, 2)]#48", - "variable_2": "0_p[(3, 1, 2)]#48" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 1, 2)]#48", - "variable_2": "0_q[(3, 1, 2)]#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c286_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(3, 2, 1)]#48", - "variable_2": "0_p[(3, 2, 1)]#48" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(3, 2, 1)]#48", - "variable_2": "0_q[(3, 2, 1)]#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0625 - } - }, - { - "name": "c287_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 1, 3)]#48", - "variable_2": "0_p[(1, 1, 3)]#48" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 1, 3)]#48", - "variable_2": "0_q[(1, 1, 3)]#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "name": "c288_1", - "function": { - "type": "ScalarQuadraticFunction", - "affine_terms": [], - "quadratic_terms": [ - { - "coefficient": 2.0, - "variable_1": "0_p[(1, 3, 1)]#48", - "variable_2": "0_p[(1, 3, 1)]#48" - }, - { - "coefficient": 2.0, - "variable_1": "0_q[(1, 3, 1)]#48", - "variable_2": "0_q[(1, 3, 1)]#48" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#1" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#1" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#1" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#1" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#1" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#1" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#1" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#1" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#1" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#1" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#1" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#1" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#1" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#1" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#1" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#1" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#1" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#1" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#1" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#1" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#1" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#1" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#1" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#1" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#1" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#1" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#1" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#1" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#1" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#2" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#2" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#2" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#2" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#2" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#2" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#2" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#2" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#2" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#2" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#2" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#2" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#2" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#2" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#2" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#2" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#2" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#2" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#2" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#2" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#2" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#2" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#2" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#2" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#2" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#2" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#2" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#2" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#2" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#3" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#3" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#3" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#3" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#3" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#3" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#3" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#3" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#3" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#3" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#3" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#3" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#3" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#3" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#3" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#3" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#3" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#3" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#3" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#3" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#3" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#3" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#3" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#3" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#3" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#3" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#3" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#3" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#3" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#4" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#4" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#4" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#4" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#4" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#4" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#4" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#4" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#4" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#4" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#4" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#4" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#4" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#4" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#4" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#4" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#4" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#4" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#4" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#4" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#4" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#4" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#4" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#4" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#4" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#4" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#4" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#4" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#4" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#5" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#5" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#5" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#5" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#5" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#5" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#5" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#5" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#5" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#5" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#5" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#5" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#5" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#5" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#5" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#5" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#5" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#5" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#5" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#5" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#5" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#5" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#5" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#5" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#5" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#5" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#5" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#5" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#5" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#6" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#6" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#6" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#6" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#6" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#6" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#6" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#6" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#6" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#6" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#6" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#6" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#6" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#6" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#6" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#6" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#6" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#6" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#6" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#6" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#6" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#6" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#6" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#6" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#6" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#6" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#6" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#6" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#6" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#7" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#7" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#7" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#7" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#7" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#7" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#7" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#7" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#7" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#7" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#7" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#7" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#7" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#7" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#7" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#7" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#7" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#7" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#7" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#7" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#7" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#7" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#7" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#7" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#7" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#7" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#7" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#7" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#7" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#8" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#8" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#8" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#8" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#8" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#8" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#8" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#8" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#8" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#8" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#8" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#8" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#8" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#8" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#8" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#8" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#8" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#8" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#8" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#8" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#8" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#8" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#8" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#8" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#8" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#8" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#8" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#8" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#8" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#9" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#9" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#9" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#9" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#9" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#9" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#9" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#9" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#9" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#9" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#9" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#9" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#9" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#9" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#9" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#9" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#9" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#9" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#9" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#9" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#9" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#9" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#9" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#9" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#9" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#9" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#9" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#9" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#9" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#10" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#10" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#10" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#10" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#10" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#10" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#10" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#10" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#10" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#10" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#10" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#10" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#10" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#10" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#10" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#10" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#10" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#10" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#10" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#10" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#10" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#10" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#10" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#10" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#10" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#10" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#10" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#10" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#10" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#11" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#11" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#11" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#11" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#11" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#11" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#11" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#11" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#11" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#11" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#11" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#11" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#11" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#11" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#11" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#11" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#11" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#11" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#11" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#11" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#11" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#11" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#11" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#11" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#11" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#11" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#11" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#11" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#11" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#12" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#12" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#12" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#12" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#12" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#12" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#12" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#12" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#12" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#12" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#12" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#12" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#12" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#12" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#12" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#12" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#12" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#12" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#12" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#12" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#12" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#12" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#12" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#12" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#12" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#12" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#12" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#12" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#12" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#13" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#13" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#13" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#13" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#13" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#13" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#13" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#13" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#13" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#13" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#13" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#13" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#13" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#13" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#13" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#13" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#13" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#13" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#13" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#13" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#13" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#13" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#13" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#13" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#13" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#13" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#13" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#13" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#13" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#14" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#14" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#14" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#14" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#14" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#14" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#14" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#14" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#14" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#14" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#14" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#14" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#14" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#14" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#14" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#14" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#14" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#14" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#14" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#14" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#14" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#14" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#14" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#14" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#14" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#14" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#14" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#14" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#14" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#15" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#15" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#15" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#15" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#15" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#15" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#15" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#15" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#15" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#15" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#15" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#15" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#15" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#15" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#15" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#15" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#15" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#15" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#15" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#15" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#15" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#15" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#15" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#15" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#15" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#15" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#15" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#15" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#15" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#16" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#16" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#16" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#16" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#16" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#16" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#16" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#16" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#16" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#16" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#16" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#16" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#16" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#16" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#16" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#16" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#16" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#16" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#16" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#16" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#16" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#16" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#16" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#16" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#16" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#16" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#16" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#16" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#16" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#17" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#17" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#17" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#17" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#17" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#17" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#17" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#17" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#17" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#17" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#17" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#17" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#17" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#17" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#17" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#17" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#17" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#17" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#17" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#17" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#17" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#17" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#17" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#17" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#17" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#17" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#17" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#17" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#17" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#18" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#18" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#18" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#18" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#18" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#18" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#18" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#18" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#18" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#18" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#18" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#18" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#18" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#18" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#18" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#18" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#18" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#18" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#18" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#18" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#18" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#18" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#18" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#18" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#18" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#18" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#18" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#18" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#18" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#19" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#19" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#19" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#19" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#19" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#19" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#19" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#19" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#19" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#19" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#19" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#19" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#19" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#19" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#19" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#19" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#19" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#19" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#19" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#19" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#19" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#19" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#19" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#19" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#19" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#19" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#19" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#19" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#19" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#20" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#20" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#20" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#20" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#20" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#20" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#20" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#20" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#20" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#20" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#20" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#20" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#20" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#20" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#20" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#20" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#20" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#20" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#20" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#20" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#20" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#20" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#20" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#20" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#20" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#20" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#20" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#20" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#20" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#21" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#21" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#21" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#21" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#21" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#21" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#21" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#21" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#21" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#21" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#21" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#21" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#21" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#21" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#21" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#21" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#21" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#21" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#21" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#21" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#21" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#21" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#21" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#21" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#21" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#21" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#21" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#21" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#21" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#22" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#22" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#22" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#22" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#22" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#22" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#22" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#22" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#22" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#22" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#22" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#22" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#22" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#22" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#22" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#22" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#22" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#22" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#22" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#22" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#22" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#22" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#22" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#22" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#22" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#22" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#22" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#22" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#22" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#23" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#23" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#23" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#23" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#23" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#23" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#23" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#23" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#23" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#23" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#23" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#23" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#23" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#23" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#23" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#23" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#23" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#23" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#23" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#23" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#23" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#23" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#23" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#23" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#23" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#23" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#23" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#23" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#23" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#24" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#24" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#24" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#24" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#24" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#24" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#24" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#24" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#24" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#24" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#24" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#24" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#24" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#24" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#24" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#24" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#24" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#24" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#24" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#24" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#24" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#24" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#24" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#24" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#24" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#24" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#24" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#24" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#24" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#25" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#25" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#25" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#25" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#25" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#25" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#25" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#25" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#25" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#25" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#25" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#25" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#25" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#25" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#25" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#25" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#25" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#25" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#25" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#25" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#25" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#25" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#25" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#25" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#25" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#25" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#25" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#25" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#25" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#26" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#26" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#26" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#26" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#26" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#26" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#26" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#26" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#26" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#26" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#26" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#26" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#26" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#26" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#26" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#26" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#26" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#26" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#26" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#26" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#26" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#26" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#26" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#26" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#26" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#26" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#26" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#26" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#26" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#27" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#27" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#27" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#27" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#27" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#27" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#27" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#27" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#27" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#27" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#27" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#27" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#27" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#27" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#27" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#27" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#27" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#27" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#27" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#27" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#27" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#27" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#27" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#27" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#27" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#27" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#27" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#27" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#27" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#28" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#28" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#28" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#28" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#28" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#28" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#28" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#28" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#28" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#28" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#28" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#28" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#28" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#28" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#28" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#28" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#28" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#28" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#28" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#28" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#28" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#28" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#28" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#28" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#28" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#28" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#28" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#28" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#28" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#29" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#29" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#29" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#29" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#29" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#29" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#29" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#29" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#29" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#29" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#29" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#29" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#29" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#29" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#29" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#29" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#29" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#29" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#29" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#29" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#29" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#29" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#29" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#29" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#29" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#29" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#29" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#29" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#29" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#30" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#30" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#30" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#30" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#30" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#30" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#30" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#30" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#30" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#30" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#30" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#30" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#30" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#30" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#30" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#30" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#30" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#30" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#30" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#30" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#30" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#30" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#30" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#30" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#30" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#30" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#30" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#30" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#30" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#31" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#31" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#31" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#31" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#31" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#31" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#31" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#31" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#31" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#31" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#31" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#31" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#31" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#31" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#31" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#31" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#31" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#31" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#31" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#31" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#31" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#31" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#31" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#31" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#31" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#31" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#31" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#31" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#31" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#32" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#32" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#32" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#32" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#32" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#32" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#32" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#32" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#32" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#32" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#32" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#32" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#32" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#32" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#32" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#32" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#32" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#32" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#32" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#32" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#32" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#32" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#32" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#32" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#32" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#32" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#32" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#32" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#32" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#33" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#33" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#33" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#33" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#33" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#33" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#33" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#33" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#33" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#33" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#33" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#33" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#33" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#33" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#33" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#33" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#33" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#33" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#33" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#33" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#33" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#33" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#33" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#33" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#33" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#33" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#33" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#33" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#33" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#34" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#34" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#34" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#34" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#34" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#34" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#34" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#34" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#34" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#34" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#34" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#34" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#34" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#34" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#34" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#34" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#34" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#34" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#34" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#34" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#34" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#34" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#34" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#34" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#34" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#34" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#34" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#34" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#34" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#35" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#35" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#35" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#35" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#35" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#35" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#35" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#35" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#35" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#35" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#35" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#35" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#35" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#35" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#35" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#35" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#35" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#35" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#35" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#35" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#35" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#35" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#35" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#35" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#35" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#35" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#35" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#35" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#35" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#36" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#36" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#36" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#36" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#36" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#36" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#36" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#36" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#36" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#36" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#36" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#36" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#36" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#36" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#36" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#36" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#36" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#36" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#36" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#36" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#36" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#36" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#36" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#36" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#36" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#36" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#36" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#36" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#36" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#37" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#37" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#37" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#37" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#37" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#37" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#37" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#37" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#37" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#37" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#37" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#37" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#37" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#37" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#37" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#37" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#37" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#37" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#37" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#37" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#37" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#37" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#37" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#37" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#37" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#37" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#37" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#37" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#37" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#38" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#38" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#38" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#38" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#38" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#38" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#38" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#38" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#38" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#38" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#38" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#38" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#38" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#38" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#38" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#38" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#38" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#38" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#38" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#38" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#38" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#38" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#38" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#38" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#38" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#38" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#38" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#38" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#38" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#39" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#39" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#39" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#39" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#39" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#39" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#39" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#39" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#39" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#39" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#39" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#39" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#39" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#39" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#39" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#39" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#39" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#39" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#39" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#39" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#39" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#39" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#39" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#39" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#39" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#39" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#39" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#39" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#39" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#40" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#40" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#40" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#40" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#40" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#40" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#40" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#40" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#40" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#40" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#40" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#40" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#40" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#40" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#40" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#40" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#40" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#40" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#40" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#40" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#40" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#40" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#40" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#40" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#40" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#40" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#40" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#40" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#40" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#41" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#41" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#41" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#41" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#41" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#41" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#41" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#41" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#41" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#41" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#41" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#41" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#41" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#41" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#41" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#41" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#41" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#41" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#41" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#41" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#41" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#41" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#41" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#41" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#41" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#41" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#41" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#41" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#41" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#42" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#42" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#42" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#42" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#42" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#42" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#42" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#42" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#42" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#42" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#42" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#42" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#42" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#42" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#42" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#42" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#42" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#42" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#42" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#42" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#42" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#42" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#42" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#42" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#42" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#42" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#42" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#42" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#42" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#43" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#43" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#43" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#43" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#43" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#43" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#43" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#43" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#43" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#43" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#43" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#43" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#43" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#43" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#43" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#43" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#43" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#43" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#43" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#43" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#43" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#43" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#43" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#43" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#43" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#43" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#43" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#43" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#43" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#44" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#44" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#44" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#44" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#44" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#44" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#44" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#44" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#44" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#44" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#44" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#44" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#44" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#44" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#44" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#44" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#44" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#44" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#44" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#44" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#44" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#44" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#44" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#44" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#44" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#44" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#44" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#44" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#44" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#45" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#45" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#45" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#45" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#45" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#45" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#45" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#45" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#45" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#45" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#45" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#45" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#45" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#45" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#45" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#45" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#45" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#45" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#45" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#45" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#45" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#45" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#45" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#45" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#45" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#45" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#45" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#45" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#45" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#46" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#46" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#46" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#46" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#46" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#46" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#46" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#46" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#46" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#46" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#46" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#46" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#46" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#46" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#46" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#46" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#46" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#46" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#46" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#46" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#46" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#46" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#46" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#46" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#46" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#46" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#46" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#46" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#46" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#47" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#47" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#47" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#47" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#47" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#47" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#47" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#47" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#47" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#47" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#47" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#47" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#47" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#47" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#47" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#47" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#47" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#47" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#47" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#47" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#47" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#47" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#47" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#47" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#47" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#47" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#47" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#47" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#47" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#48" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#48" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#48" - }, - "set": { - "type": "GreaterThan", - "lower": 0.9 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#48" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#48" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#48" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#48" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#48" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#48" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#48" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#48" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#48" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#48" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#48" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#48" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#48" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#48" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#48" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#48" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#48" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#48" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_volume_violation[1]#48" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#48" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]#48" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]#48" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[1]#48" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[2]#48" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "deficit[3]#48" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#48" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#1" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#1" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#1" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#1" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#1" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#1" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#1" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#1" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#1" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#1" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#1" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#1" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#1" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#1" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#1" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#1" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#1" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#1" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#1" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#1" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#1" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#1" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#1" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#2" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#2" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#2" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#2" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#2" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#2" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#2" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#2" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#2" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#2" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#2" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#2" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#2" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#2" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#2" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#2" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#2" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#2" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#2" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#2" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#2" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#2" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#2" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#3" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#3" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#3" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#3" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#3" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#3" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#3" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#3" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#3" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#3" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#3" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#3" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#3" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#3" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#3" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#3" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#3" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#3" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#3" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#3" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#3" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#3" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#3" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#4" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#4" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#4" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#4" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#4" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#4" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#4" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#4" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#4" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#4" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#4" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#4" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#4" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#4" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#4" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#4" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#4" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#4" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#4" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#4" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#4" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#4" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#4" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#5" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#5" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#5" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#5" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#5" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#5" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#5" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#5" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#5" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#5" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#5" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#5" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#5" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#5" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#5" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#5" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#5" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#5" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#5" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#5" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#5" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#5" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#5" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#6" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#6" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#6" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#6" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#6" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#6" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#6" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#6" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#6" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#6" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#6" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#6" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#6" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#6" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#6" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#6" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#6" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#6" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#6" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#6" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#6" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#6" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#6" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#7" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#7" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#7" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#7" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#7" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#7" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#7" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#7" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#7" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#7" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#7" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#7" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#7" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#7" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#7" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#7" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#7" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#7" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#7" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#7" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#7" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#7" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#7" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#8" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#8" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#8" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#8" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#8" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#8" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#8" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#8" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#8" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#8" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#8" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#8" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#8" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#8" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#8" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#8" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#8" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#8" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#8" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#8" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#8" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#8" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#8" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#9" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#9" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#9" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#9" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#9" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#9" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#9" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#9" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#9" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#9" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#9" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#9" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#9" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#9" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#9" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#9" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#9" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#9" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#9" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#9" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#9" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#9" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#9" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#10" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#10" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#10" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#10" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#10" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#10" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#10" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#10" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#10" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#10" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#10" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#10" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#10" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#10" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#10" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#10" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#10" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#10" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#10" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#10" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#10" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#10" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#10" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#11" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#11" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#11" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#11" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#11" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#11" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#11" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#11" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#11" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#11" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#11" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#11" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#11" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#11" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#11" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#11" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#11" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#11" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#11" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#11" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#11" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#11" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#11" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#12" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#12" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#12" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#12" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#12" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#12" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#12" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#12" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#12" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#12" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#12" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#12" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#12" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#12" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#12" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#12" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#12" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#12" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#12" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#12" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#12" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#12" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#12" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#13" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#13" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#13" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#13" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#13" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#13" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#13" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#13" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#13" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#13" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#13" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#13" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#13" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#13" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#13" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#13" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#13" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#13" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#13" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#13" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#13" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#13" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#13" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#14" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#14" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#14" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#14" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#14" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#14" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#14" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#14" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#14" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#14" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#14" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#14" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#14" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#14" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#14" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#14" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#14" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#14" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#14" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#14" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#14" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#14" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#14" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#15" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#15" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#15" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#15" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#15" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#15" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#15" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#15" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#15" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#15" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#15" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#15" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#15" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#15" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#15" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#15" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#15" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#15" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#15" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#15" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#15" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#15" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#15" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#16" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#16" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#16" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#16" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#16" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#16" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#16" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#16" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#16" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#16" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#16" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#16" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#16" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#16" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#16" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#16" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#16" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#16" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#16" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#16" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#16" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#16" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#16" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#17" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#17" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#17" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#17" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#17" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#17" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#17" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#17" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#17" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#17" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#17" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#17" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#17" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#17" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#17" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#17" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#17" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#17" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#17" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#17" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#17" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#17" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#17" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#18" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#18" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#18" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#18" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#18" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#18" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#18" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#18" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#18" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#18" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#18" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#18" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#18" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#18" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#18" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#18" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#18" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#18" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#18" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#18" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#18" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#18" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#18" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#19" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#19" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#19" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#19" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#19" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#19" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#19" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#19" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#19" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#19" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#19" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#19" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#19" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#19" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#19" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#19" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#19" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#19" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#19" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#19" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#19" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#19" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#19" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#20" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#20" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#20" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#20" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#20" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#20" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#20" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#20" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#20" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#20" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#20" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#20" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#20" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#20" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#20" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#20" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#20" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#20" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#20" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#20" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#20" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#20" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#20" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#21" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#21" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#21" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#21" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#21" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#21" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#21" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#21" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#21" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#21" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#21" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#21" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#21" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#21" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#21" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#21" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#21" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#21" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#21" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#21" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#21" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#21" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#21" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#22" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#22" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#22" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#22" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#22" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#22" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#22" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#22" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#22" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#22" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#22" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#22" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#22" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#22" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#22" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#22" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#22" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#22" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#22" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#22" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#22" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#22" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#22" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#23" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#23" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#23" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#23" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#23" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#23" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#23" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#23" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#23" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#23" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#23" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#23" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#23" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#23" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#23" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#23" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#23" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#23" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#23" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#23" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#23" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#23" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#23" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#24" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#24" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#24" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#24" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#24" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#24" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#24" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#24" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#24" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#24" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#24" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#24" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#24" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#24" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#24" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#24" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#24" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#24" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#24" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#24" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#24" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#24" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#24" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#25" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#25" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#25" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#25" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#25" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#25" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#25" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#25" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#25" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#25" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#25" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#25" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#25" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#25" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#25" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#25" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#25" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#25" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#25" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#25" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#25" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#25" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#25" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#26" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#26" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#26" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#26" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#26" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#26" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#26" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#26" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#26" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#26" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#26" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#26" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#26" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#26" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#26" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#26" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#26" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#26" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#26" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#26" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#26" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#26" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#26" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#27" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#27" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#27" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#27" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#27" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#27" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#27" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#27" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#27" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#27" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#27" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#27" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#27" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#27" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#27" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#27" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#27" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#27" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#27" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#27" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#27" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#27" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#27" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#28" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#28" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#28" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#28" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#28" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#28" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#28" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#28" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#28" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#28" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#28" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#28" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#28" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#28" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#28" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#28" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#28" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#28" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#28" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#28" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#28" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#28" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#28" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#29" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#29" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#29" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#29" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#29" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#29" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#29" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#29" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#29" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#29" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#29" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#29" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#29" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#29" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#29" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#29" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#29" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#29" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#29" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#29" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#29" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#29" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#29" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#30" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#30" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#30" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#30" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#30" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#30" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#30" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#30" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#30" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#30" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#30" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#30" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#30" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#30" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#30" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#30" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#30" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#30" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#30" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#30" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#30" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#30" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#30" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#31" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#31" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#31" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#31" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#31" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#31" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#31" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#31" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#31" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#31" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#31" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#31" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#31" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#31" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#31" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#31" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#31" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#31" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#31" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#31" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#31" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#31" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#31" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#32" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#32" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#32" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#32" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#32" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#32" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#32" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#32" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#32" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#32" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#32" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#32" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#32" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#32" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#32" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#32" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#32" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#32" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#32" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#32" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#32" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#32" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#32" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#33" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#33" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#33" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#33" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#33" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#33" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#33" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#33" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#33" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#33" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#33" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#33" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#33" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#33" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#33" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#33" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#33" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#33" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#33" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#33" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#33" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#33" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#33" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#34" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#34" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#34" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#34" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#34" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#34" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#34" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#34" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#34" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#34" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#34" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#34" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#34" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#34" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#34" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#34" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#34" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#34" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#34" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#34" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#34" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#34" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#34" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#35" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#35" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#35" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#35" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#35" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#35" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#35" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#35" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#35" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#35" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#35" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#35" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#35" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#35" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#35" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#35" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#35" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#35" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#35" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#35" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#35" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#35" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#35" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#36" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#36" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#36" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#36" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#36" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#36" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#36" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#36" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#36" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#36" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#36" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#36" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#36" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#36" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#36" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#36" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#36" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#36" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#36" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#36" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#36" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#36" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#36" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#37" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#37" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#37" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#37" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#37" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#37" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#37" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#37" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#37" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#37" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#37" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#37" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#37" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#37" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#37" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#37" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#37" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#37" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#37" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#37" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#37" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#37" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#37" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#38" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#38" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#38" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#38" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#38" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#38" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#38" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#38" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#38" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#38" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#38" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#38" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#38" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#38" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#38" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#38" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#38" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#38" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#38" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#38" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#38" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#38" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#38" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#39" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#39" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#39" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#39" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#39" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#39" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#39" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#39" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#39" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#39" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#39" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#39" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#39" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#39" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#39" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#39" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#39" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#39" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#39" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#39" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#39" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#39" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#39" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#40" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#40" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#40" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#40" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#40" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#40" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#40" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#40" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#40" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#40" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#40" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#40" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#40" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#40" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#40" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#40" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#40" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#40" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#40" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#40" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#40" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#40" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#40" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#41" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#41" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#41" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#41" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#41" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#41" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#41" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#41" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#41" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#41" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#41" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#41" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#41" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#41" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#41" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#41" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#41" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#41" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#41" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#41" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#41" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#41" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#41" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#42" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#42" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#42" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#42" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#42" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#42" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#42" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#42" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#42" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#42" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#42" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#42" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#42" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#42" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#42" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#42" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#42" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#42" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#42" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#42" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#42" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#42" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#42" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#43" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#43" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#43" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#43" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#43" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#43" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#43" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#43" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#43" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#43" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#43" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#43" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#43" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#43" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#43" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#43" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#43" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#43" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#43" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#43" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#43" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#43" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#43" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#44" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#44" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#44" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#44" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#44" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#44" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#44" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#44" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#44" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#44" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#44" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#44" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#44" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#44" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#44" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#44" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#44" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#44" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#44" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#44" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#44" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#44" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#44" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#45" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#45" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#45" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#45" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#45" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#45" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#45" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#45" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#45" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#45" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#45" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#45" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#45" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#45" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#45" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#45" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#45" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#45" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#45" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#45" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#45" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#45" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#45" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#46" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#46" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#46" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#46" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#46" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#46" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#46" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#46" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#46" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#46" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#46" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#46" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#46" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#46" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#46" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#46" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#46" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#46" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#46" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#46" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#46" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#46" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#46" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#47" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#47" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#47" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#47" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#47" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#47" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#47" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#47" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#47" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#47" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#47" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#47" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#47" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#47" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#47" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#47" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#47" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#47" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#47" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#47" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#47" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#47" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#47" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[2]#48" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[3]#48" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_vm[1]#48" - }, - "set": { - "type": "LessThan", - "upper": 1.1 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]#48" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]#48" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]#48" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]#48" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]#48" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]#48" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]#48" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]#48" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]#48" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]#48" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]#48" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]#48" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]#48" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]#48" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]#48" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]#48" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]#48" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]#48" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]#48" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out#48" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#1" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_reservoir[1]_in#1" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#2" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#3" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#4" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#5" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#6" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#7" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#8" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#9" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#10" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#11" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#12" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#13" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#14" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#15" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#16" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#17" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#18" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#19" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#20" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#21" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#22" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#23" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#24" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#25" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#26" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#27" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#28" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#29" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#30" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#31" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#32" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#33" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#34" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#35" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#36" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#37" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#38" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#39" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#40" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#41" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#42" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#43" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#44" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#45" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#46" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#47" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "_inflow[1]#48" - }, - "set": { - "type": "Parameter", - "value": 0.0 - } - } - ] -} diff --git a/examples/HydroPowerModels/case3/DCPPowerModel.mof.json b/examples/HydroPowerModels/case3/DCPPowerModel.mof.json deleted file mode 100644 index 82fca27..0000000 --- a/examples/HydroPowerModels/case3/DCPPowerModel.mof.json +++ /dev/null @@ -1,697 +0,0 @@ -{ - "name": "MathOptFormat Model", - "version": { - "major": 1, - "minor": 7 - }, - "variables": [ - { - "name": "reservoir[1]_in", - "primal_start": 0.0 - }, - { - "name": "inflow[1]", - "primal_start": 0.0 - }, - { - "name": "0_pg[2]", - "primal_start": 0.0 - }, - { - "name": "0_pg[3]", - "primal_start": 0.0 - }, - { - "name": "0_pg[1]", - "primal_start": 0.0 - }, - { - "name": "0_p[(2, 3, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(3, 1, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(1, 1, 3)]", - "primal_start": 0.0 - }, - { - "name": "reservoir[1]_out", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[1]", - "primal_start": 0.0 - }, - { - "name": "outflow[1]", - "primal_start": 0.0 - }, - { - "name": "spill[1]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[1]", - "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": "0_va[2]", - "primal_start": 0.0 - }, - { - "name": "0_va[3]", - "primal_start": 0.0 - }, - { - "name": "0_va[1]", - "primal_start": 0.0 - } - ], - "objective": { - "sense": "min", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 10010.0, - "variable": "deficit[1]" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]" - } - ], - "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_pg[1]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(2, 3, 2)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(3, 1, 2)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c3", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]" - }, - { - "coefficient": -1.0, - "variable": "0_p[(1, 1, 3)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c4", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c5", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]" - }, - { - "coefficient": 1.9950124688279303, - "variable": "0_va[2]" - }, - { - "coefficient": -1.9950124688279303, - "variable": "0_va[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c6", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]" - }, - { - "coefficient": 0.9982391062166338, - "variable": "0_va[2]" - }, - { - "coefficient": -0.9982391062166338, - "variable": "0_va[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c7", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]" - }, - { - "coefficient": 0.9957927755234136, - "variable": "0_va[3]" - }, - { - "coefficient": -0.9957927755234136, - "variable": "0_va[1]" - } - ], - "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": 1.0, - "variable": "spill[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]" - } - ], - "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_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": "c1_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_va[2]" - }, - { - "coefficient": 1.0, - "variable": "0_va[3]" - } - ], - "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[2]" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]" - } - ], - "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[3]" - }, - { - "coefficient": 1.0, - "variable": "0_va[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "Interval", - "lower": -1.0472, - "upper": 1.0472 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_in" - }, - "set": { - "type": "EqualTo", - "value": 0.18 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[1]" - }, - "set": { - "type": "EqualTo", - "value": 80.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]" - }, - "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[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_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": "outflow[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]" - }, - "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": "0_pg[2]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - } - ] -} diff --git a/examples/HydroPowerModels/case3/PowerModels.json b/examples/HydroPowerModels/case3/PowerModels.json deleted file mode 100644 index 4cbc62d..0000000 --- a/examples/HydroPowerModels/case3/PowerModels.json +++ /dev/null @@ -1,210 +0,0 @@ -{ - "bus": { - "1": { - "bus_type": 3, - "zone": 1, - "va": 0, - "area": 1, - "vm": 1, - "vmin": 0.9, - "vmax": 1.1, - "base_kv": 0, - "bus_i": 1, - "index": 1 - }, - "2": { - "bus_type": 2, - "zone": 1, - "va": 0, - "area": 1, - "vm": 1, - "vmin": 0.9, - "vmax": 1.1, - "base_kv": 0, - "bus_i": 2, - "index": 2 - }, - "3": { - "bus_type": 2, - "zone": 1, - "va": 0, - "area": 1, - "vm": 1, - "vmin": 0.9, - "vmax": 1.1, - "base_kv": 0, - "bus_i": 3, - "index": 3 - } - }, - "source_type": "matpower", - "name": "case3", - "dcline": {}, - "source_version": "2", - "cost_deficit": 100.10, - "gen": { - "1": { - "apf": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "qg": 0, - "gen_bus": 2, - "pmax": 1, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 1, - "cost": [ - 2000, - 0 - ], - "qmax": 100, - "gen_status": 1, - "qmin": -100, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "ncost": 2, - "pmin": 0 - }, - "2": { - "apf": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "qg": 0, - "gen_bus": 3, - "pmax": 0.5, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 2, - "cost": [ - 10000, - 0 - ], - "qmax": 100, - "gen_status": 1, - "qmin": -100, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "ncost": 2, - "pmin": 0 - }, - "3": { - "apf": 0, - "qc1max": 0, - "pg": 0, - "model": 2, - "shutdown": 0, - "startup": 0, - "qc2max": 0, - "ramp_agc": 0, - "qg": 0, - "gen_bus": 1, - "pmax": 0.8, - "ramp_10": 0, - "vg": 1, - "mbase": 100, - "pc2": 0, - "index": 3, - "cost": [], - "qmax": 100, - "gen_status": 1, - "qmin": -100, - "qc1min": 0, - "qc2min": 0, - "pc1": 0, - "ramp_q": 0, - "ramp_30": 0, - "ncost": 0, - "pmin": 0 - } - }, - "branch": { - "1": { - "br_r": 0.065, - "rate_a": 1, - "shift": 0, - "br_x": 1, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.225, - "f_bus": 1, - "br_status": 1, - "t_bus": 3, - "b_to": 0.225, - "index": 1, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "2": { - "br_r": 0.025, - "rate_a": 0.65, - "shift": 0, - "br_x": 0.5, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.35, - "f_bus": 3, - "br_status": 1, - "t_bus": 2, - "b_to": 0.35, - "index": 2, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - }, - "3": { - "br_r": 0.042, - "rate_a": 0.25, - "shift": 0, - "br_x": 1, - "g_to": 0, - "g_fr": 0, - "b_fr": 0.15, - "f_bus": 1, - "br_status": 1, - "t_bus": 2, - "b_to": 0.15, - "index": 3, - "angmin": -1.0472, - "angmax": 1.0472, - "transformer": false, - "tap": 1 - } - }, - "storage": {}, - "baseMVA": 100, - "per_unit": true, - "shunt": {}, - "switch": {}, - "load": { - "1": { - "load_bus": 3, - "status": 1, - "qd": 0, - "pd": 1, - "index": 1 - } - } -} \ No newline at end of file diff --git a/examples/HydroPowerModels/case3/SOCWRConicPowerModel.mof.json b/examples/HydroPowerModels/case3/SOCWRConicPowerModel.mof.json deleted file mode 100644 index a467532..0000000 --- a/examples/HydroPowerModels/case3/SOCWRConicPowerModel.mof.json +++ /dev/null @@ -1,2054 +0,0 @@ -{ - "name": "MathOptFormat Model", - "version": { - "major": 1, - "minor": 7 - }, - "variables": [ - { - "name": "reservoir[1]_in", - "primal_start": 0.0 - }, - { - "name": "inflow[1]", - "primal_start": 0.0 - }, - { - "name": "0_w[2]", - "primal_start": 1.001 - }, - { - "name": "0_w[3]", - "primal_start": 1.001 - }, - { - "name": "0_w[1]", - "primal_start": 1.001 - }, - { - "name": "0_wr[(3, 2)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(1, 2)]", - "primal_start": 1.0 - }, - { - "name": "0_wr[(1, 3)]", - "primal_start": 1.0 - }, - { - "name": "0_wi[(3, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(1, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_wi[(1, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_pg[2]", - "primal_start": 0.0 - }, - { - "name": "0_pg[3]", - "primal_start": 0.0 - }, - { - "name": "0_pg[1]", - "primal_start": 0.0 - }, - { - "name": "0_qg[2]", - "primal_start": 0.0 - }, - { - "name": "0_qg[3]", - "primal_start": 0.0 - }, - { - "name": "0_qg[1]", - "primal_start": 0.0 - }, - { - "name": "0_p[(2, 3, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(3, 1, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(1, 1, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(2, 2, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(3, 2, 1)]", - "primal_start": 0.0 - }, - { - "name": "0_p[(1, 3, 1)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(2, 3, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(3, 1, 2)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(1, 1, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(2, 2, 3)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(3, 2, 1)]", - "primal_start": 0.0 - }, - { - "name": "0_q[(1, 3, 1)]", - "primal_start": 0.0 - }, - { - "name": "reservoir[1]_out", - "primal_start": 0.0 - }, - { - "name": "min_volume_violation[1]", - "primal_start": 0.0 - }, - { - "name": "outflow[1]", - "primal_start": 0.0 - }, - { - "name": "spill[1]", - "primal_start": 0.0 - }, - { - "name": "min_outflow_violation[1]", - "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 - } - ], - "objective": { - "sense": "min", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 10010.0, - "variable": "deficit[1]" - }, - { - "coefficient": 10010.0, - "variable": "deficit[2]" - }, - { - "coefficient": 10010.0, - "variable": "deficit[3]" - }, - { - "coefficient": 10000.0, - "variable": "0_pg[2]" - }, - { - "coefficient": 2000.0, - "variable": "0_pg[1]" - } - ], - "constant": 0.0 - } - }, - "constraints": [ - { - "name": "c1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[1]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[2]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[1]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c3", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[2]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[3]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": -1.0 - } - }, - { - "name": "c4", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[2]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c5", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_pg[3]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]" - }, - { - "coefficient": -1.0, - "variable": "deficit[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c6", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0, - "variable": "0_qg[3]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c7", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.09975062344139651, - "variable": "0_w[3]" - }, - { - "coefficient": 0.09975062344139651, - "variable": "0_wr[(3, 2)]" - }, - { - "coefficient": -1.9950124688279303, - "variable": "0_wi[(3, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 3, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c8", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.6450124688279302, - "variable": "0_w[3]" - }, - { - "coefficient": 1.9950124688279303, - "variable": "0_wr[(3, 2)]" - }, - { - "coefficient": 0.09975062344139651, - "variable": "0_wi[(3, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c9", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.09975062344139651, - "variable": "0_w[2]" - }, - { - "coefficient": 0.09975062344139651, - "variable": "0_wr[(3, 2)]" - }, - { - "coefficient": 1.9950124688279303, - "variable": "0_wi[(3, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(2, 2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c10", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.6450124688279302, - "variable": "0_w[2]" - }, - { - "coefficient": 1.9950124688279303, - "variable": "0_wr[(3, 2)]" - }, - { - "coefficient": -0.09975062344139651, - "variable": "0_wi[(3, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c11", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.04192604246109862, - "variable": "0_w[1]" - }, - { - "coefficient": 0.04192604246109862, - "variable": "0_wr[(1, 2)]" - }, - { - "coefficient": -0.9982391062166338, - "variable": "0_wi[(1, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 1, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c12", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8482391062166338, - "variable": "0_w[1]" - }, - { - "coefficient": 0.9982391062166338, - "variable": "0_wr[(1, 2)]" - }, - { - "coefficient": 0.04192604246109862, - "variable": "0_wi[(1, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c13", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.04192604246109862, - "variable": "0_w[2]" - }, - { - "coefficient": 0.04192604246109862, - "variable": "0_wr[(1, 2)]" - }, - { - "coefficient": 0.9982391062166338, - "variable": "0_wi[(1, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c14", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8482391062166338, - "variable": "0_w[2]" - }, - { - "coefficient": 0.9982391062166338, - "variable": "0_wr[(1, 2)]" - }, - { - "coefficient": -0.04192604246109862, - "variable": "0_wi[(1, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c15", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.06472653040902189, - "variable": "0_w[1]" - }, - { - "coefficient": 0.06472653040902189, - "variable": "0_wr[(1, 3)]" - }, - { - "coefficient": -0.9957927755234136, - "variable": "0_wi[(1, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c16", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.7707927755234136, - "variable": "0_w[1]" - }, - { - "coefficient": 0.9957927755234136, - "variable": "0_wr[(1, 3)]" - }, - { - "coefficient": 0.06472653040902189, - "variable": "0_wi[(1, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c17", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.06472653040902189, - "variable": "0_w[3]" - }, - { - "coefficient": 0.06472653040902189, - "variable": "0_wr[(1, 3)]" - }, - { - "coefficient": 0.9957927755234136, - "variable": "0_wi[(1, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c18", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.7707927755234136, - "variable": "0_w[3]" - }, - { - "coefficient": 0.9957927755234136, - "variable": "0_wr[(1, 3)]" - }, - { - "coefficient": -0.06472653040902189, - "variable": "0_wi[(1, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]" - } - ], - "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": 1.0, - "variable": "spill[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "turbine_energy[1]", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 100.0, - "variable": "0_pg[3]" - }, - { - "coefficient": -1.0, - "variable": "outflow[1]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "EqualTo", - "value": 0.0 - } - }, - { - "name": "c1_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(3, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(3, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c2_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[2]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[3]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(3, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c3_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[2]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[3]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(3, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c4_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(1, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(1, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c5_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[2]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[1]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(1, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c6_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[2]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[1]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(1, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.16199931288430486 - } - }, - { - "name": "c7_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": 1.732060602824032, - "variable": "0_wr[(1, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(1, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "name": "c8_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.0999953343996005, - "variable": "0_w[3]" - }, - { - "coefficient": -1.0999953343996005, - "variable": "0_w[1]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(1, 3)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "GreaterThan", - "lower": -0.24199897356791222 - } - }, - { - "name": "c9_1", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -0.8999961826905822, - "variable": "0_w[3]" - }, - { - "coefficient": -0.8999961826905822, - "variable": "0_w[1]" - }, - { - "coefficient": 4.0, - "variable": "0_wr[(1, 3)]" - } - ], - "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_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": "c1_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(3, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(3, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c2_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(1, 2)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(1, 2)]" - } - ], - "constant": 0.0 - }, - "set": { - "type": "LessThan", - "upper": 0.0 - } - }, - { - "name": "c3_2", - "function": { - "type": "ScalarAffineFunction", - "terms": [ - { - "coefficient": -1.732060602824032, - "variable": "0_wr[(1, 3)]" - }, - { - "coefficient": 1.0, - "variable": "0_wi[(1, 3)]" - } - ], - "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[(2, 3, 2)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(2, 3, 2)]" - } - } - ], - "constants": [ - 0.65, - 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[(2, 2, 3)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(2, 2, 3)]" - } - } - ], - "constants": [ - 0.65, - 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[(3, 1, 2)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(3, 1, 2)]" - } - } - ], - "constants": [ - 0.25, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c4_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(3, 2, 1)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(3, 2, 1)]" - } - } - ], - "constants": [ - 0.25, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c5_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(1, 1, 3)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(1, 1, 3)]" - } - } - ], - "constants": [ - 1.0, - 0.0, - 0.0 - ] - }, - "set": { - "type": "SecondOrderCone", - "dimension": 3 - } - }, - { - "name": "c6_2", - "function": { - "type": "VectorAffineFunction", - "terms": [ - { - "output_index": 2, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_p[(1, 3, 1)]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_q[(1, 3, 1)]" - } - } - ], - "constants": [ - 1.0, - 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[3]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[2]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(3, 2)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(3, 2)]" - } - } - ], - "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[1]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[2]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(1, 2)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(1, 2)]" - } - } - ], - "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[1]" - } - }, - { - "output_index": 2, - "scalar_term": { - "coefficient": 0.7071067811865475, - "variable": "0_w[3]" - } - }, - { - "output_index": 3, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wr[(1, 3)]" - } - }, - { - "output_index": 4, - "scalar_term": { - "coefficient": 1.0, - "variable": "0_wi[(1, 3)]" - } - } - ], - "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.18 - } - }, - { - "function": { - "type": "Variable", - "name": "inflow[1]" - }, - "set": { - "type": "EqualTo", - "value": 120.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_w[2]" - }, - "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[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.81 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(3, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(1, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(1, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.404998282210762 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(3, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(1, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(1, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]" - }, - "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[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]" - }, - "set": { - "type": "GreaterThan", - "lower": -100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]" - }, - "set": { - "type": "GreaterThan", - "lower": -1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_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": "outflow[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "spill[1]" - }, - "set": { - "type": "GreaterThan", - "lower": 0.0 - } - }, - { - "function": { - "type": "Variable", - "name": "min_outflow_violation[1]" - }, - "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": "0_w[2]" - }, - "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[1]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(3, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(1, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wr[(1, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.2100000000000002 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(3, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(1, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_wi[(1, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0478922201020873 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[2]" - }, - "set": { - "type": "LessThan", - "upper": 0.5 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[3]" - }, - "set": { - "type": "LessThan", - "upper": 0.8 - } - }, - { - "function": { - "type": "Variable", - "name": "0_pg[1]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[2]" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[3]" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_qg[1]" - }, - "set": { - "type": "LessThan", - "upper": 100.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 3, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 1, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 1, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(2, 2, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(3, 2, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_p[(1, 3, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 3, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 1, 2)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 1, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(2, 2, 3)]" - }, - "set": { - "type": "LessThan", - "upper": 0.65 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(3, 2, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 0.25 - } - }, - { - "function": { - "type": "Variable", - "name": "0_q[(1, 3, 1)]" - }, - "set": { - "type": "LessThan", - "upper": 1.0 - } - }, - { - "function": { - "type": "Variable", - "name": "reservoir[1]_out" - }, - "set": { - "type": "LessThan", - "upper": 0.54 - } - }, - { - "function": { - "type": "Variable", - "name": "outflow[1]" - }, - "set": { - "type": "LessThan", - "upper": 80.0 - } - } - ] -} diff --git a/examples/HydroPowerModels/case3/hydro.json b/examples/HydroPowerModels/case3/hydro.json deleted file mode 100644 index b906b22..0000000 --- a/examples/HydroPowerModels/case3/hydro.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "Hydrogenerators":[ - { - "index": 1, - "index_grid": 3, - "max_volume":0.54, - "min_volume":0, - "max_turn": 80, - "min_turn": 0, - "initial_volume":0.18, - "final_volume":0.0, - "production_factor":1, - "spill_cost":0, - "minimal_outflow_violation_cost":0, - "minimal_volume_violation_cost":0, - "downstream_turn": [], - "downstream_spill": [] - } - ], - "stage_hours": 1 -} diff --git a/examples/HydroPowerModels/case3/inflows.csv b/examples/HydroPowerModels/case3/inflows.csv deleted file mode 100644 index 1d09924..0000000 --- a/examples/HydroPowerModels/case3/inflows.csv +++ /dev/null @@ -1,12 +0,0 @@ -120,80,40 -105,70,35 -90,60,30 -75,50,25 -60,40,20 -45,30,15 -30,20,10 -45,30,15 -60,40,20 -75,50,25 -90,60,30 -105,70,35 diff --git a/examples/HydroPowerModels/case3/scenarioprobability.csv b/examples/HydroPowerModels/case3/scenarioprobability.csv deleted file mode 100644 index 24b1984..0000000 --- a/examples/HydroPowerModels/case3/scenarioprobability.csv +++ /dev/null @@ -1,12 +0,0 @@ -0.3,0.4,0.3 -0.3,0.4,0.3 -0.3,0.4,0.3 -0.3,0.4,0.3 -0.3,0.4,0.3 -0.3,0.4,0.3 -0.3,0.4,0.3 -0.3,0.4,0.3 -0.3,0.4,0.3 -0.3,0.4,0.3 -0.3,0.4,0.3 -0.3,0.4,0.3 diff --git a/examples/HydroPowerModels/check_consistent_state_paths.jl b/examples/HydroPowerModels/check_consistent_state_paths.jl deleted file mode 100644 index 349573a..0000000 --- a/examples/HydroPowerModels/check_consistent_state_paths.jl +++ /dev/null @@ -1,161 +0,0 @@ -using DecisionRules -using Random -using JuMP -using DiffOpt -using Ipopt - -HydroPowerModels_dir = dirname(@__FILE__) -include(joinpath(HydroPowerModels_dir, "load_hydropowermodels.jl")) - -# ---- Configuration ---- -case_name = "bolivia" # case3, bolivia -formulation = "ACPPowerModel" # DCPPowerModel, SOCWRConicPowerModel, ACPPowerModel -num_stages = 96 -window_size = 12 - -ipopt_attrs = optimizer_with_attributes( - Ipopt.Optimizer, - "print_level" => 0, - "linear_solver" => "mumps", -) - -diff_optimizer = () -> DiffOpt.diff_optimizer(ipopt_attrs) -diff_model = () -> DiffOpt.nonlinear_diff_model(ipopt_attrs) - -det_optimizer = optimizer_with_attributes(Ipopt.Optimizer, "print_level" => 0) - -function build_problem() - return build_hydropowermodels( - joinpath(HydroPowerModels_dir, case_name), - formulation * ".mof.json"; - num_stages=num_stages, - optimizer=diff_optimizer, - ) -end - -# ---- Stage-wise simulation ---- -sub_s, state_in_s, state_out_s, uncert_s, initial_state, max_volume = build_problem() -num_uncertainties = length(uncert_s[1]) - -# Constant policy so targets do not depend on state or uncertainty. -const_target = Float32.(max_volume) * 0.6 -policy(_) = const_target - -Random.seed!(1234) -base_sample = DecisionRules.sample(uncert_s) -base_values = [[u[2] for u in stage_u] for stage_u in base_sample] -uncertainties_s = [ - [(stage_u[i][1], base_values[t][i]) for i in eachindex(stage_u)] for - (t, stage_u) in enumerate(uncert_s) -] - -obj_stage = DecisionRules.simulate_multistage( - sub_s, state_in_s, state_out_s, initial_state, uncertainties_s, policy -) - -states_stage = Vector{Vector{Float64}}(undef, num_stages + 1) -states_stage[1] = initial_state -for t in 1:num_stages - states_stage[t + 1] = [value(pair[2]) for pair in state_out_s[t]] -end - -# ---- Deterministic equivalent ---- -sub_d, state_in_d, state_out_d, uncert_d, initial_state_d, _ = build_problem() - -Det_model = JuMP.Model(det_optimizer) -Det_model, uncert_d = DecisionRules.deterministic_equivalent!( - Det_model, sub_d, state_in_d, state_out_d, Float64.(initial_state_d), uncert_d -) -uncertainties_d = [ - [(stage_u[i][1], base_values[t][i]) for i in eachindex(stage_u)] for - (t, stage_u) in enumerate(uncert_d) -] - -states_policy = DecisionRules.simulate_states(initial_state_d, uncertainties_d, policy) -obj_det = DecisionRules.simulate_multistage( - Det_model, state_in_d, state_out_d, uncertainties_d, states_policy -) - -states_det = Vector{Vector{Float64}}(undef, num_stages + 1) -states_det[1] = initial_state_d -for t in 1:num_stages - states_det[t + 1] = [value(pair[2]) for pair in state_out_d[t]] -end - -# ---- Multiple shooting ---- -sub_w, state_in_w, state_out_w, uncert_w, initial_state_w, _ = build_problem() - -windows = DecisionRules.setup_shooting_windows( - sub_w, - state_in_w, - state_out_w, - Float64.(initial_state_w), - uncert_w; - window_size=window_size, - model_factory=diff_model, -) - -uncertainties_w = [ - [(stage_u[i][1], base_values[t][i]) for i in eachindex(stage_u)] for - (t, stage_u) in enumerate(uncert_w) -] -uncertainties_vec = [[Float32(u[2]) for u in stage_u] for stage_u in uncertainties_w] - -obj_shoot = DecisionRules.simulate_multiple_shooting( - windows, policy, Float32.(initial_state_w), uncertainties_w, uncertainties_vec -) - -states_shoot = Vector{Vector{Float64}}() -push!(states_shoot, Float64.(initial_state_w)) -current_state = Float64.(initial_state_w) -for window in windows - global current_state - window_range = window.stage_range - window_uncertainties_vec = uncertainties_vec[window_range] - targets = DecisionRules.predict_window_targets( - policy, current_state, window_uncertainties_vec - ) - DecisionRules.set_window_uncertainties!(window, uncertainties_w) - DecisionRules.solve_window( - window.model, - window.state_in_params, - window.state_out_params, - current_state, - targets, - ) - - for local_t in 1:length(window_range) - push!(states_shoot, [value(pair[2]) for pair in window.state_out_params[local_t]]) - end - current_state = states_shoot[end] -end - -# ---- Diagnostics ---- -function max_state_diff(a, b) - return maximum(abs.(vcat([abs.(a[t] .- b[t]) for t in eachindex(a)]...))) -end - -@assert all( - all( - uncertainties_s[t][i][2] == base_values[t][i] for i in eachindex(uncertainties_s[t]) - ) for t in 1:num_stages -) - -@assert all( - all( - uncertainties_w[t][i][2] == base_values[t][i] for i in eachindex(uncertainties_w[t]) - ) for t in 1:num_stages -) - -@assert all( - all( - uncertainties_d[t][i][2] == base_values[t][i] for i in eachindex(uncertainties_d[t]) - ) for t in 1:num_stages -) - -println("objective(stage): ", obj_stage) -println("objective(det): ", obj_det) -println("objective(shoot): ", obj_shoot) - -println("max |stage - det| state diff: ", max_state_diff(states_stage, states_det)) -println("max |stage - shoot| state diff: ", max_state_diff(states_stage, states_shoot)) diff --git a/examples/HydroPowerModels/compare_hydro_results.jl b/examples/HydroPowerModels/compare_hydro_results.jl deleted file mode 100644 index efbf6a3..0000000 --- a/examples/HydroPowerModels/compare_hydro_results.jl +++ /dev/null @@ -1,143 +0,0 @@ -# compare_hydro_results.jl -# -# Pull training histories from W&B and generate comparison plots for the docs. -# Saves plots to ../../docs/src/assets/ and prints a summary table. -# -# Usage: -# julia --project compare_hydro_results.jl [--run-names name1,name2,name3] -# -# By default, uses the 3 most recent "running" or "finished" runs in the RL project -# that match the three training methods. - -using Plots -using Statistics - -import Wandb -const wb = Wandb.wandb -const PC = parentmodule(typeof(wb)) - -const DOCS_ASSETS = joinpath(@__DIR__, "..", "..", "docs", "src", "assets") -mkpath(DOCS_ASSETS) - -api = wb.Api() -all_runs = api.runs("RL", order="-created_at") - -methods_wanted = ["deterministic_equivalent", "subproblems", "multiple_shooting"] -method_labels = Dict( - "deterministic_equivalent" => "Deterministic Equivalent", - "subproblems" => "Stage-wise Subproblems", - "multiple_shooting" => "Multiple Shooting (w=12)", -) -method_colors = Dict( - "deterministic_equivalent" => :blue, - "subproblems" => :red, - "multiple_shooting" => :green, -) - -runs = Dict{String,Any}() -for i in 0:29 - try - r = all_runs[i] - method = PC.pyconvert(String, get(r.config, "training_method", "?")) - state = PC.pyconvert(String, r.state) - if method in methods_wanted && !haskey(runs, method) && state in ("running", "finished", "crashed") - runs[method] = r - end - catch - break - end - length(runs) == 3 && break -end - -println("Using runs:") -for (m, r) in runs - println(" $(method_labels[m]): $(PC.pyconvert(String, r.name)) ($(PC.pyconvert(String, r.state)))") -end - -function get_history(r, metric) - keys_list = PC.pylist([metric]) - hist = r.scan_history(keys=keys_list) - vals = Float64[] - for row in hist - v = try PC.pyconvert(Float64, get(row, metric, nothing)) catch; nothing end - !isnothing(v) && push!(vals, v) - end - return vals -end - -# ── Plot 1: Training convergence (in-sample loss) ──────────────────────────── - -plt1 = plot(; xlabel="Iteration", ylabel="Operational Cost (no deficit)", - title="Training Convergence", legend=:topright) -for m in methods_wanted - haskey(runs, m) || continue - vals = get_history(runs[m], "metrics/loss") - isempty(vals) && continue - plot!(plt1, 1:length(vals), vals; label=method_labels[m], color=method_colors[m], alpha=0.7) -end -savefig(plt1, joinpath(DOCS_ASSETS, "hydro_training_convergence.png")) -println("Saved hydro_training_convergence.png") - -# ── Plot 2: Out-of-sample rollout ──────────────────────────────────────────── - -plt2 = plot(; xlabel="Iteration", ylabel="Rollout Cost (no deficit)", - title="Out-of-Sample Rollout", legend=:topright) -for m in methods_wanted - haskey(runs, m) || continue - vals = get_history(runs[m], "metrics/rollout_objective_no_deficit") - isempty(vals) && continue - eval_every = try - PC.pyconvert(Int, get(runs[m].config, "eval_every", 25)) - catch - 25 - end - iters = eval_every .* (1:length(vals)) - plot!(plt2, iters, vals; label=method_labels[m], color=method_colors[m], - marker=:circle, markersize=3) -end -savefig(plt2, joinpath(DOCS_ASSETS, "hydro_cost_comparison.png")) -println("Saved hydro_cost_comparison.png") - -# ── Plot 3: Target violation share ─────────────────────────────────────────── - -plt3 = plot(; xlabel="Iteration", ylabel="Violation Share", - title="Target Violation Share", legend=:topright, ylims=(0, 0.3)) -for m in methods_wanted - haskey(runs, m) || continue - vals = get_history(runs[m], "metrics/rollout_target_violation_share") - isempty(vals) && continue - eval_every = try - PC.pyconvert(Int, get(runs[m].config, "eval_every", 25)) - catch - 25 - end - iters = eval_every .* (1:length(vals)) - plot!(plt3, iters, vals; label=method_labels[m], color=method_colors[m], - marker=:circle, markersize=3) -end -savefig(plt3, joinpath(DOCS_ASSETS, "hydro_violation_share.png")) -println("Saved hydro_violation_share.png") - -# ── Summary table ──────────────────────────────────────────────────────────── - -println("\n" * "="^80) -println("Summary Table") -println("="^80) -println(rpad("Method", 30), rpad("Last Loss", 15), rpad("Rollout", 15), - rpad("Violation", 12), rpad("Steps", 8)) -println("-"^80) -for m in methods_wanted - haskey(runs, m) || continue - r = runs[m] - summ = r.summary - loss = try round(PC.pyconvert(Float64, get(summ, "metrics/loss", nothing)); digits=0) catch; nothing end - rollout = try round(PC.pyconvert(Float64, get(summ, "metrics/rollout_objective_no_deficit", nothing)); digits=0) catch; nothing end - violation = try round(PC.pyconvert(Float64, get(summ, "metrics/rollout_target_violation_share", nothing)); digits=4) catch; nothing end - steps = try PC.pyconvert(Int, get(summ, "_step", nothing)) catch; nothing end - println(rpad(method_labels[m], 30), - rpad(isnothing(loss) ? "-" : string(loss), 15), - rpad(isnothing(rollout) ? "-" : string(rollout), 15), - rpad(isnothing(violation) ? "-" : string(violation), 12), - rpad(isnothing(steps) ? "-" : string(steps), 8)) -end -println("="^80) diff --git a/examples/HydroPowerModels/eval_jump_de.jl b/examples/HydroPowerModels/eval_jump_de.jl index 1a72412..f3fa076 100644 --- a/examples/HydroPowerModels/eval_jump_de.jl +++ b/examples/HydroPowerModels/eval_jump_de.jl @@ -21,7 +21,15 @@ using CUDSS_jll const SCRIPT_DIR = dirname(@__FILE__) const CASE_DIR = joinpath(SCRIPT_DIR, "bolivia") -const EXA_CASE_DIR = "/storage/home/hcoda1/9/arosemberg3/scratch/DecisionRulesExaGPU.jl/examples/HydroPowerModels/bolivia" +# Case directory of the ExaModels engine, used only to cross-check that both +# engines read the SAME case bytes. `DR_EXA_CASE_DIR` names it; the default +# assumes the two packages sit side by side. Never an absolute machine path. +const EXA_CASE_DIR = get( + ENV, + "DR_EXA_CASE_DIR", + normpath(joinpath(SCRIPT_DIR, "..", "..", "..", "DecisionRulesExa.jl", + "examples", "HydroPowerModels", "bolivia")), +) include(joinpath(SCRIPT_DIR, "load_hydropowermodels.jl")) @@ -34,7 +42,7 @@ const TARGET_FRAC = 0.6 # constant target = TARGET_FRAC × max_volume @info "Building HydroPowerModels ($FORMULATION, T=$NUM_STAGES)..." -sub, state_in, state_out, uncert, initial_state, max_volume = build_hydropowermodels( +sub, state_in, state_out, uncert, initial_state, max_volume, _ = build_hydropowermodels( CASE_DIR, FORMULATION * ".mof.json"; num_stages=NUM_STAGES, penalty_l2=:auto ) nHyd = length(initial_state) diff --git a/examples/HydroPowerModels/eval_paired_tsddr.jl b/examples/HydroPowerModels/eval_paired_tsddr.jl new file mode 100644 index 0000000..71d5eed --- /dev/null +++ b/examples/HydroPowerModels/eval_paired_tsddr.jl @@ -0,0 +1,471 @@ +# Paired TS-DDR strict rollout evaluation on the seeded paired protocol. +# +# Scenario indices are a pure function of PAIRED_SCENARIO_SEED (see +# paired_scenario_indices in load_hydropowermodels.jl), so this script and the +# SDDP Historical simulation realize the exact same inflows with no shared +# data file. +# +# Usage: +# julia --project -t auto eval_paired_tsddr.jl MODEL_PATH +# +# Environment overrides: +# DR_NUM_EVAL_STAGES=96 +# DR_NUM_SCENARIOS=500 +# DR_ENCODER_LAYERS=128,128 +# DR_HEAD_LAYERS= +# DR_CONTEXT= ""/"none", "phase", or "phase+progress" +# DR_CONTEXT_HORIZON=126 denominator/horizon used for progress context +# DR_SCEN_FIRST / DR_SCEN_LAST contiguous shard of the 500 protocol columns +# DR_SCEN_IDS=2,39,81,... an ARBITRARY list of columns instead (the +# ten-column screening panel is not a range) +# DR_SOLUTION_DUMP=1 also write the full physical solution of every +# stage, including the NODAL PRICES, plus the +# decision trace +# DR_OUTPUT_TAG="" (when set, ALL output filenames are suffixed with +# "_" — paired_costs_.csv, etc. — so evaluating +# a new checkpoint never clobbers the untagged +# ground-truth results; unset → historical filenames) +using DecisionRules +using Flux +using Statistics +using Random +using JuMP, DiffOpt, Ipopt +using JLD2 +using CSV, DataFrames +using JSON +using DelimitedFiles + +HydroPowerModels_dir = dirname(@__FILE__) +include(joinpath(HydroPowerModels_dir, "load_hydropowermodels.jl")) +include(joinpath(HydroPowerModels_dir, "hydro_reachable_policy.jl")) +include(joinpath(HydroPowerModels_dir, "hydro_solution_schema.jl")) +using .HydroSolutionSchema + +# `DR_SOLUTION_DUMP=1` records the FULL physical solution of every stage — every +# named primal variable plus the NODAL PRICES — in the long format of +# `hydro_solution_schema.jl`, together with the decision trace. +# +# The prices are the duals of the per-bus active and reactive balance. They are +# the economic read-out of the policy's dispatch and exist only as duals, so the +# aggregate per-stage CSVs cannot supply them. This evaluator and the SDDP one +# solve the same stage model, so the prices they report are comparable — which is +# what makes a TS-DDR-versus-SDDP price figure meaningful. +const SOLUTION_DUMP = get(ENV, "DR_SOLUTION_DUMP", "0") == "1" + +model_path = ARGS[1] +num_eval_stages = parse(Int, get(ENV, "DR_NUM_EVAL_STAGES", "96")) +num_scenarios = parse(Int, get(ENV, "DR_NUM_SCENARIOS", "500")) +# Optional output tag: suffixes every output filename with "_" so a new +# checkpoint's evaluation cannot overwrite the untagged ground-truth files. +output_tag = strip(get(ENV, "DR_OUTPUT_TAG", "")) +tag_suffix = isempty(output_tag) ? "" : "_" * output_tag + +parse_layers(s::AbstractString) = + isempty(strip(s)) ? Int64[] : [parse(Int64, strip(x)) for x in split(s, ",") if !isempty(strip(x))] + +function canonical_context_mode(raw_mode::AbstractString) + mode = lowercase(strip(raw_mode)) + mode in ("", "none", "off", "false") && return "" + mode in ("phase", "phase+progress") && return mode + error("DR_CONTEXT must be \"\", \"phase\", or \"phase+progress\"; got \"$raw_mode\"") +end + +function build_stage_context(mode::AbstractString, horizon::Int, period::Int) + isempty(mode) && return nothing + include_progress = mode == "phase+progress" + return DecisionRules.stage_phase_context( + horizon; + period=period, + include_progress=include_progress, + ) +end + +layers = parse_layers(get(ENV, "DR_ENCODER_LAYERS", get(ENV, "DR_LAYERS", "128,128"))) +head_layers = parse_layers(get(ENV, "DR_HEAD_LAYERS", "")) +context_mode = canonical_context_mode(get(ENV, "DR_CONTEXT", "")) +context_horizon = parse(Int, get(ENV, "DR_CONTEXT_HORIZON", "126")) +context_period = countlines(joinpath(HydroPowerModels_dir, "bolivia", "inflows.csv")) +context_horizon >= num_eval_stages || + error("DR_CONTEXT_HORIZON=$context_horizon must cover DR_NUM_EVAL_STAGES=$num_eval_stages") +stage_context = build_stage_context(context_mode, context_horizon, context_period) +n_context = isnothing(stage_context) ? 0 : size(stage_context, 1) + +println("=" ^ 60) +println("Paired TS-DDR Strict Rollout Evaluation") +println(" Model: $model_path") +println(" Stages: $num_eval_stages") +println(" Scenarios: $num_scenarios") +println(" Layers: $layers") +println(" Head: $head_layers") +println(" Context: $(isempty(context_mode) ? "none" : context_mode)") +isempty(output_tag) || println(" Output tag: $output_tag") +println("=" ^ 60) + +# ── Build strict subproblems ─────────────────────────────────────────────── +case_name = "bolivia" +formulation = "ACPPowerModel" +formulation_file = formulation * ".mof.json" + +diff_optimizer = + () -> DiffOpt.diff_optimizer( + optimizer_with_attributes( + Ipopt.Optimizer, + "print_level" => 0, + "linear_solver" => "mumps", + ), + ) + +subproblems, state_params_in, state_params_out, uncertainty_samples, + initial_state, max_volume, hydro_meta = build_hydropowermodels( + joinpath(HydroPowerModels_dir, case_name), + formulation_file; + num_stages=num_eval_stages, + optimizer=diff_optimizer, + strict=true, +) + +num_hydro = length(initial_state) +nCen = length(uncertainty_samples[1]) +println("nHyd=$num_hydro, nCen=$nCen") + +# Paired scenario indices: a pure function of the protocol seed (see +# paired_scenario_indices in load_hydropowermodels.jl). Fixed 126-row shape; +# this evaluation uses rows 1:num_eval_stages. +@assert num_eval_stages <= PAIRED_NUM_STAGES +all_indices = paired_scenario_indices(num_scenarios, nCen) +println("Paired protocol: seed=$(PAIRED_SCENARIO_SEED), rows 1:$(num_eval_stages) of $(PAIRED_NUM_STAGES)×$(num_scenarios), nCen=$nCen") + +# ── Identify thermal generators ──────────────────────────────────────────── +hydro_data = JSON.parsefile(joinpath(HydroPowerModels_dir, case_name, "hydro.json")) +power_data = JSON.parsefile(joinpath(HydroPowerModels_dir, case_name, "PowerModels.json")) +baseMVA = power_data["baseMVA"] +hydro_grid_idx = Set(hg["index_grid"] for hg in hydro_data["Hydrogenerators"]) +num_gen = length(power_data["gen"]) +thermal_idx = [i for i in 1:num_gen if !(i in hydro_grid_idx)] + +volume_to_mw(volume; k=0.0036) = volume / k + +pg_vars_per_stage = [DecisionRules.find_variables(subproblems[t], ["pg"]) for t in 1:num_eval_stages] + +# ── Build policy and load weights ────────────────────────────────────────── +base_model = hydro_reachable_policy( + hydro_meta, + layers; + combiner_layers=head_layers, + n_context=n_context, +) +models = isnothing(stage_context) ? base_model : ContextualPolicy(base_model, stage_context) +model_save = JLD2.load(model_path) +model_state = model_save["model_state"] +load_policy_weights!(models, model_state) +println("Loaded model weights from $model_path") + +# ── Construct scenarios from pre-sampled indices ─────────────────────────── +eval_scenarios = Vector{Vector{Vector{Tuple{eltype(uncertainty_samples[1][1][1][1]), eltype(uncertainty_samples[1][1][1][2])}}}}(undef, num_scenarios) +for s in 1:num_scenarios + eval_scenarios[s] = [uncertainty_samples[t][all_indices[t, s]] for t in 1:num_eval_stages] +end + +# Verify: print first scenario's first stage inflows +println("\nFirst scenario, stage 1 inflows:") +for (param, val) in eval_scenarios[1][1] + println(" $(JuMP.name(param)) = $val") +end + +# ── Run rollout evaluation ───────────────────────────────────────────────── +println("\nEvaluating $num_scenarios scenarios on $num_eval_stages stages...") + +# Scenario sharding: build the paired index matrix for ALL `num_scenarios` +# (so the StableRNG pairing is identical across shards) but only roll out the +# requested subset. Rollouts are per-scenario independent, so sharding across +# tasks is exact and embarrassingly parallel. +scen_first = parse(Int, get(ENV, "DR_SCEN_FIRST", "1")) +scen_last = parse(Int, get(ENV, "DR_SCEN_LAST", string(num_scenarios))) +# `DR_SCEN_IDS` selects an ARBITRARY list of global protocol columns, which +# `DR_SCEN_FIRST`/`DR_SCEN_LAST` cannot: the ten-column screening panel is +# 2,39,81,… and is not a contiguous range. Without it this evaluator could not +# address the same scenario set the ExaModels evaluator does, so the two engines' +# per-stage series would not be paired. Sharding a full 500-column run still +# uses the range form, which is what `sbatch --export` can carry (it splits +# values on commas). +scen_ids = let raw = strip(get(ENV, "DR_SCEN_IDS", "")) + ids = isempty(raw) ? + collect(scen_first:min(scen_last, num_scenarios)) : + [parse(Int, strip(c)) for c in split(raw, ",") if !isempty(strip(c))] + all(1 .<= ids .<= num_scenarios) || + error("DR_SCEN_IDS must lie in 1:$num_scenarios; got $ids") + ids +end +nshard = length(scen_ids) +# Output-name suffix. A contiguous shard is named by its range; an explicit id +# list is named by its SIZE, because "_s2_493" would read as the range 2..493 +# and this evaluator would then overwrite a real 492-column shard's files. +const EXPLICIT_IDS = !isempty(strip(get(ENV, "DR_SCEN_IDS", ""))) +const SHARD_SUFFIX = + EXPLICIT_IDS ? "_ids$(nshard)" : + (scen_first == 1 && last(scen_ids) >= num_scenarios) ? "" : + "_s$(first(scen_ids))_$(last(scen_ids))" +println(" Shard: $nshard of $num_scenarios scenarios" * + (length(scen_ids) <= 12 ? " $(collect(scen_ids))" : + " $(first(scen_ids))..$(last(scen_ids))")) + +""" + accepted(model) -> Bool + +Whether a JuMP solve converged to a usable point. + +`LOCALLY_SOLVED` is the normal Ipopt outcome for this nonconvex ACP problem; +`OPTIMAL` and `ALMOST_LOCALLY_SOLVED` are accepted for the same reason MadNLP's +acceptable level is accepted on the ExaModels side. +""" +accepted(model) = JuMP.termination_status(model) in ( + MOI.LOCALLY_SOLVED, MOI.OPTIMAL, MOI.ALMOST_LOCALLY_SOLVED, +) + +""" + solve_stage!(model) -> (ok::Bool, retried::Bool, status) + +Solve one stage subproblem, retrying ONCE from a cold start if the first attempt +does not converge. + +The retry clears every variable's start value, so the second attempt does not +inherit the failed iterate. A stage that fails twice is REPORTED — the scenario +is marked unsolved rather than having a meaningless `objective_value` folded +into the mean. +""" +function solve_stage!(model) + optimize!(model) + accepted(model) && return (true, false, JuMP.termination_status(model)) + for variable in JuMP.all_variables(model) + JuMP.set_start_value(variable, nothing) + end + optimize!(model) + return (accepted(model), true, JuMP.termination_status(model)) +end + +# Per-scenario cost AND per-scenario solve provenance. A scenario is never +# dropped or renumbered: `scen_done` carries the GLOBAL protocol column id for +# every scenario attempted, and `scen_solved` says whether its cost is usable. +# ── Optional full-solution recording ─────────────────────────────────────── +# Set up once, outside the rollout loop: the variable-to-class mapping and the +# balance-constraint references are properties of the stage MODEL, not of a +# scenario, so resolving them per stage would repeat identical work 96 times. +out_dir_dump = joinpath(HydroPowerModels_dir, case_name, formulation) +solution_writer = nothing +trace_rows = Tuple[] +mapped_vars = Vector{Vector{Tuple{VariableRef,Tuple{String,Int}}}}() +balance_cons = Vector{Tuple{Dict{Int,ConstraintRef},Dict{Int,ConstraintRef}}}() +if SOLUTION_DUMP + mkpath(out_dir_dump) + verify_index_convention(joinpath(HydroPowerModels_dir, case_name), JSON.parsefile) + orientation = branch_orientation(joinpath(HydroPowerModels_dir, case_name), + JSON.parsefile) + for t in 1:num_eval_stages + pairs = Tuple{VariableRef,Tuple{String,Int}}[] + for v in JuMP.all_variables(subproblems[t]) + class = solution_class(JuMP.name(v), orientation) + class === nothing || push!(pairs, (v, class)) + end + push!(mapped_vars, pairs) + push!(balance_cons, find_bus_balance_constraints(subproblems[t])) + end + # `w_t` is a vector of (parameter, value) pairs in UNCERTAINTY-SAMPLE order, + # which is not guaranteed to be reservoir order. Resolve each parameter's + # reservoir index from its name once, so the trace cannot silently record + # reservoir 3's inflow against reservoir 1. + global inflow_order = [ + parse(Int, match(r"inflow\[(\d+)\]", JuMP.name(param)).captures[1]) + for (param, _) in uncertainty_samples[1][1] + ] + sort(inflow_order) == collect(1:num_hydro) || + error("inflow parameters do not cover reservoirs 1:$num_hydro: $inflow_order") + solution_writer = SolutionWriter( + joinpath(out_dir_dump, "solution$(tag_suffix)$(SHARD_SUFFIX).csv"), + ) + println("Full-solution dump enabled: $(length(first(mapped_vars))) mapped variables/stage") +end + +costs = Float64[] +scen_done = Int[] +scen_solved = Bool[] +scen_retried = Int[] # stages that needed the cold retry +scen_status = String[] # terminal status of the first failing stage, or "" +vol_trajectories = zeros(num_eval_stages, nshard) +gen_trajectories = zeros(num_eval_stages, nshard) + +for (i, s) in enumerate(scen_ids) + scenario = eval_scenarios[s] + Flux.reset!(models) + + state = Float64.(initial_state) + scenario_cost = 0.0 + scenario_ok = true + scenario_retries = 0 + scenario_status = "" + + for t in 1:num_eval_stages + for (j, param) in enumerate(state_params_in[t]) + set_parameter_value(param, state[j]) + end + + w_t = scenario[t] + for (param, val) in w_t + set_parameter_value(param, val) + end + + w_vals = Float32.([val for (_, val) in w_t]) + x_hat = models(vcat(w_vals, Float32.(state))) + + for j in 1:num_hydro + target_param = state_params_out[t][j][1] + set_parameter_value(target_param, Float64(x_hat[j])) + end + + ok, retried, status = solve_stage!(subproblems[t]) + retried && (scenario_retries += 1) + if !ok + # A non-converged stage makes every later stage of this scenario + # meaningless, so the rollout stops here and the scenario is + # recorded as unsolved. Its cost is retained for inspection but is + # excluded from every statistic below. + scenario_ok = false + scenario_status = string(status) + @warn "Stage solve failed after cold retry" scenario = s stage = t status + break + end + scenario_cost += objective_value(subproblems[t]) + + if SOLUTION_DUMP + for (v, (class, index)) in mapped_vars[t] + record!(solution_writer, s, t, class, index, value(v)) + end + # Nodal prices: the duals of the per-bus active and reactive + # balance. `state` still holds the INCOMING volumes here — it is + # overwritten with the realized outgoing state just below — so the + # trace records the stage's true starting point. + active_cons, reactive_cons = balance_cons[t] + for (bus, con) in active_cons + record!(solution_writer, s, t, "price_active", bus, dual(con)) + end + for (bus, con) in reactive_cons + record!(solution_writer, s, t, "price_reactive", bus, dual(con)) + end + stage_inflow = zeros(Float64, num_hydro) + for (k, (_, val)) in enumerate(w_t) + stage_inflow[inflow_order[k]] = Float64(val) + end + for j in 1:num_hydro + record!(solution_writer, s, t, "target", j, Float64(x_hat[j])) + push!(trace_rows, + (s, t, j, state[j], Float64(x_hat[j]), stage_inflow[j])) + end + record_scalar!(solution_writer, s, t, "stage_objective", + objective_value(subproblems[t])) + record_scalar!(solution_writer, s, t, "cum_objective", scenario_cost) + end + + for j in 1:num_hydro + state[j] = value(state_params_out[t][j][2]) + end + + vol_trajectories[t, i] = sum(volume_to_mw(state[j]) for j in 1:num_hydro) + gen_trajectories[t, i] = sum( + value(pg_vars_per_stage[t][j]) * baseMVA for j in thermal_idx + ) + end + + push!(costs, scenario_cost) + push!(scen_done, s) + push!(scen_solved, scenario_ok) + push!(scen_retried, scenario_retries) + push!(scen_status, scenario_status) + if i % 10 == 0 || i == nshard + solved_costs = costs[scen_solved] + running = isempty(solved_costs) ? NaN : round(mean(solved_costs); digits=1) + println(" [$i/$nshard] (scen $s) cost = $(round(scenario_cost; digits=1))" * + (scenario_ok ? "" : " [UNSOLVED]") * ", running mean = $running") + end +end + +if SOLUTION_DUMP + close(solution_writer) + trace_file = joinpath(out_dir_dump, "trace$(tag_suffix)$(SHARD_SUFFIX).csv") + open(trace_file, "w") do io + println(io, "scenario,stage,reservoir,state_in,target,inflow") + for r in trace_rows + println(io, join((x isa AbstractFloat ? repr(x) : string(x) for x in r), ",")) + end + end + println("Saved full solution + trace to $out_dir_dump") +end + +# ── Report results ───────────────────────────────────────────────────────── +# Statistics are computed over SOLVED scenarios only, and the count is printed +# next to them, so a partial evaluation can never be read as a complete one. +solved_costs = costs[scen_solved] +n_solved = length(solved_costs) +n_retried = count(>(0), scen_retried) +println("\n" * "=" ^ 60) +println("Results: Paired TS-DDR Strict ($num_eval_stages stages, shard $(first(scen_ids)):$(last(scen_ids)))") +println("=" ^ 60) +println(" Solved: $n_solved / $nshard" * + (n_solved == nshard ? " (COMPLETE)" : " ** INCOMPLETE — statistics are over a SUBSET **")) +n_retried == 0 || println(" Retried: $n_retried scenario(s) needed a cold retry") +if n_solved < nshard + println(" Unsolved: $(scen_done[.!scen_solved])") + println(" Statuses: $(scen_status[.!scen_solved])") +end +if n_solved > 0 + println(" Mean cost: $(round(mean(solved_costs); digits=1))") + println(" Std: $(round(std(solved_costs); digits=1))") + println(" Min: $(round(minimum(solved_costs); digits=1))") + println(" Max: $(round(maximum(solved_costs); digits=1))") + println(" Median: $(round(median(solved_costs); digits=1))") +end +println(" Violation: 0.0% (strict mode)") +println("=" ^ 60) + +# ── Save results ─────────────────────────────────────────────────────────── +out_dir = joinpath(HydroPowerModels_dir, case_name, formulation) + +const COL_NAME = "TS-DDR (strict, paired)" +# When sharding, suffix the filename with the scenario range so shards never +# collide; a full (1..num_scenarios) run keeps the historical name. Always write +# a `scenario` column so shard CSVs merge unambiguously by scenario id. +shard_suffix = SHARD_SUFFIX +costs_file = joinpath(out_dir, "paired_costs$(tag_suffix)$(shard_suffix).csv") +# Solve provenance travels WITH the cost: a merge downstream can then reject an +# incomplete set instead of averaging a garbage objective from a failed solve. +df = DataFrame( + :scenario => collect(scen_done), + Symbol(COL_NAME) => costs, + :all_stages_solved => scen_solved, + :stages_retried => scen_retried, + :failure_status => scen_status, +) +CSV.write(costs_file, df) +println("Saved: $costs_file") + +mean_vol = vec(mean(vol_trajectories; dims=2)) +vol_file = joinpath(out_dir, "paired_MeanVolume$(tag_suffix)$(shard_suffix).csv") +df_vol = DataFrame(Symbol(COL_NAME) => mean_vol) +CSV.write(vol_file, df_vol) +println("Saved: $vol_file") + +mean_gen = vec(mean(gen_trajectories; dims=2)) +gen_file = joinpath(out_dir, "paired_MeanGeneration$(tag_suffix)$(shard_suffix).csv") +df_gen = DataFrame(Symbol(COL_NAME) => mean_gen) +CSV.write(gen_file, df_gen) +println("Saved: $gen_file") + +results_dir = joinpath(out_dir, "results") +mkpath(results_dir) +results_file = joinpath(results_dir, "paired_strict_rollout$(tag_suffix)$(shard_suffix).jld2") +jldsave(results_file; + costs=costs, + scenarios=collect(scen_done), + vol_trajectories=vol_trajectories, + gen_trajectories=gen_trajectories, + scenario_indices=all_indices[1:num_eval_stages, scen_ids], +) +println("Saved: $results_file") diff --git a/examples/HydroPowerModels/evaluate_hydro_policies.jl b/examples/HydroPowerModels/evaluate_hydro_policies.jl deleted file mode 100644 index cf59032..0000000 --- a/examples/HydroPowerModels/evaluate_hydro_policies.jl +++ /dev/null @@ -1,234 +0,0 @@ -# Evaluate pre-trained TS-DDR and TS-LDR policies on the Bolivia LTHD problem -# using stage-wise rollout under the ACP formulation with a fixed scenario set. -# -# This produces an apples-to-apples comparison across all methods using the -# same evaluation protocol: -# - stage-wise AC-OPF subproblems (Ipopt) -# - realized-state feedback (closed-loop / deployment semantics) -# - same seed and number of out-of-sample scenarios -# - operational cost excluding target-deficit penalty -# -# The script auto-discovers saved .jld2 checkpoints and reconstructs the -# correct policy architecture (LDR vs DDR) from the filename. -# Results are written to eval_costs.csv. -# -# Usage: -# julia --project=. evaluate_hydro_policies.jl [NUM_SIMULATIONS] -# -# Environment overrides: -# DR_EVAL_SIMULATIONS=100 number of out-of-sample scenarios -# DR_EVAL_SEED=1221 random seed for scenario generation - -using DecisionRules -using Statistics -using Random -using Flux -using Ipopt -using DiffOpt -using JLD2 -using JuMP -using CSV -using DataFrames - -const HYDRO_DIR = dirname(@__FILE__) -include(joinpath(HYDRO_DIR, "load_hydropowermodels.jl")) - -const CASE_NAME = "bolivia" -const FORMULATION = "ACPPowerModel" -const FORMULATION_FILE = FORMULATION * ".mof.json" -const NUM_STAGES = 96 -const NUM_SIMULATIONS = parse(Int, get(ENV, "DR_EVAL_SIMULATIONS", - length(ARGS) >= 1 ? ARGS[1] : "100")) -const SEED = parse(Int, get(ENV, "DR_EVAL_SEED", "1221")) - -const CASE_DIR = joinpath(HYDRO_DIR, CASE_NAME) -const OUT_DIR = joinpath(CASE_DIR, FORMULATION) -const MODEL_DIR = joinpath(OUT_DIR, "models") - -println("="^60) -println("Policy Evaluation (TS-DDR + TS-LDR)") -println("="^60) -println("Case: ", CASE_NAME) -println("Formulation: ", FORMULATION) -println("Stages: ", NUM_STAGES) -println("Simulations: ", NUM_SIMULATIONS) -println("Seed: ", SEED) -println("="^60) - -# ── Build stage-wise subproblems ───────────────────────────────────────────── - -diff_optimizer = () -> DiffOpt.diff_optimizer( - optimizer_with_attributes( - Ipopt.Optimizer, "print_level" => 0, "linear_solver" => "mumps", - ), -) - -subproblems, state_params_in, state_params_out, uncertainty_samples, initial_state, max_volume = - build_hydropowermodels( - CASE_DIR, FORMULATION_FILE; - num_stages=NUM_STAGES, - optimizer=diff_optimizer, - penalty_l1=:auto, penalty_l2=:auto, - ) - -num_hydro = length(initial_state) -num_uncertainties = length(uncertainty_samples[1][1]) -num_inputs = DecisionRules.policy_input_dim(num_uncertainties, num_hydro) - -# ── Generate fixed scenario set ────────────────────────────────────────────── - -Random.seed!(SEED) -eval_scenarios = [DecisionRules.sample(uncertainty_samples) for _ in 1:NUM_SIMULATIONS] - -# ── Discover saved models ──────────────────────────────────────────────────── -# -# Model files encode the training method and policy type in their filename: -# *-deteq-* → DDR trained with deterministic equivalent -# *-subproblems-* → DDR trained with stage-wise decomposition -# *-shooting-* → DDR trained with multiple shooting -# *-ldr-* → LDR (linear decision rule) -# -# DDR models use state_conditioned_policy (LSTM [128,128], sigmoid). -# LDR models use dense_multilayer_nn (identity activation, [64,64]). -# The most recent file (by lexicographic sort on timestamps) is selected -# for each method. - -struct PolicySpec - label::String - model_file::String - is_ldr::Bool -end - -function _method_variant(base) - method = if contains(base, "ldr") - "ldr" - elseif contains(base, "shooting") - "shooting" - elseif contains(base, "subproblems") - "subproblems" - elseif contains(base, "deteq") - "deteq" - else - return nothing - end - clip_tag = contains(base, "clip") ? "-clip" : "" - sched_tag = contains(base, "anneal") ? "-anneal" : - contains(base, "const") ? "-const" : "" - return method * clip_tag * sched_tag -end - -function _variant_label(variant) - labels = Dict( - "subproblems-anneal" => "Subproblems (anneal)", - "subproblems-clip-anneal" => "Subproblems (clip, anneal)", - "subproblems-const" => "Subproblems (const)", - "subproblems-clip-const" => "Subproblems (clip, const)", - "subproblems" => "Subproblems", - "shooting-anneal" => "Shooting w=12 (anneal)", - "shooting-clip-anneal" => "Shooting w=12 (clip, anneal)", - "shooting" => "Shooting w=12", - "deteq-anneal" => "DE (anneal)", - "deteq-clip-anneal" => "DE (clip, anneal)", - "deteq" => "DE", - "ldr" => "TS-LDR", - ) - return get(labels, variant, variant) -end - -function discover_policies(model_dir) - files = sort(filter(f -> endswith(f, ".jld2"), readdir(model_dir; join=true))) - best = Dict{String,Tuple{String,Bool}}() - for f in files - base = basename(f) - variant = _method_variant(base) - isnothing(variant) && continue - is_ldr = contains(base, "ldr") - best[variant] = (f, is_ldr) - end - specs = PolicySpec[] - for (variant, (path, is_ldr)) in sort(collect(best); by=first) - push!(specs, PolicySpec(_variant_label(variant), path, is_ldr)) - end - return specs -end - -function build_policy(spec::PolicySpec, num_inputs, num_hydro, num_uncertainties) - if spec.is_ldr - return dense_multilayer_nn(num_inputs, num_hydro, Int64[64, 64]; activation=identity) - else - return state_conditioned_policy( - num_uncertainties, num_hydro, num_hydro, Int64[128, 128]; - activation=sigmoid, encoder_type=Flux.LSTM, - ) - end -end - -policies = discover_policies(MODEL_DIR) -println("\nDiscovered policies:") -for p in policies - tag = p.is_ldr ? " (LDR)" : " (DDR)" - println(" ", p.label, tag, " → ", basename(p.model_file)) -end - -# ── Evaluate each policy ───────────────────────────────────────────────────── - -results = DataFrame() - -for spec in policies - println("\nEvaluating: ", spec.label) - - models = build_policy(spec, num_inputs, num_hydro, num_uncertainties) - model_state = JLD2.load(spec.model_file, "model_state") - Flux.loadmodel!(models, model_state) - - objectives_no_deficit = Vector{Float64}(undef, NUM_SIMULATIONS) - objectives_total = Vector{Float64}(undef, NUM_SIMULATIONS) - - for i in 1:NUM_SIMULATIONS - Flux.reset!(models) - - objectives_total[i] = simulate_multistage( - subproblems, - state_params_in, - state_params_out, - initial_state, - eval_scenarios[i], - models; - ) - - objectives_no_deficit[i] = DecisionRules.get_objective_no_target_deficit(subproblems) - end - - violation_share = 1.0 - mean(objectives_no_deficit) / mean(objectives_total) - - println(" Mean cost (no deficit): ", round(mean(objectives_no_deficit); digits=1)) - println(" Std: ", round(std(objectives_no_deficit); digits=1)) - println(" Violation share: ", round(violation_share * 100; digits=2), "%") - - results[!, spec.label] = objectives_no_deficit -end - -# ── Write results ──────────────────────────────────────────────────────────── - -costs_file = joinpath(OUT_DIR, "eval_costs.csv") -CSV.write(costs_file, results) -println("\nSaved: ", costs_file) - -# ── Summary table ──────────────────────────────────────────────────────────── - -println("\n", "="^70) -println(rpad("Method", 35), rpad("Mean", 12), rpad("Std", 12), "N") -println("-"^70) -for col in names(results) - vals = results[!, col] - println( - rpad(col, 35), - rpad(string(round(mean(vals); digits=1)), 12), - rpad(string(round(std(vals); digits=1)), 12), - length(vals), - ) -end -println("="^70) -println("\nNote: SDDP results are from sddp/simulate_sddp_policy.jl") -println("SDDP uses 126 stages (96 + 30 margin) to avoid end-of-horizon effects,") -println("while TS-DDR/TS-LDR use 96 stages. This gives SDDP a structural advantage.") diff --git a/examples/HydroPowerModels/export_subproblem_mof.jl b/examples/HydroPowerModels/export_subproblem_mof.jl index a4df07f..5c67098 100644 --- a/examples/HydroPowerModels/export_subproblem_mof.jl +++ b/examples/HydroPowerModels/export_subproblem_mof.jl @@ -1,94 +1,198 @@ -# Export a single-stage OPF subproblem from HydroPowerModels as a .mof.json file. +#!/usr/bin/env julia + +# Official generator of the Bolivia stage subproblems (`bolivia/*.mof.json`). +# +# The JuMP/MAIN workflow does not depend on HydroPowerModels.jl at training or +# evaluation time: `build_hydropowermodels` (load_hydropowermodels.jl) reads one +# serialized stage subproblem per stage and re-parameterizes it. Those serialized +# models are produced HERE, and only here, by building the case through +# HydroPowerModels and letting JuMP's MathOptFormat writer serialize the result. +# +# The pipeline is deliberately narrow: # -# The DecisionRules training pipeline (load_hydropowermodels.jl) reads pre-exported -# .mof.json files rather than depending on HydroPowerModels.jl at training time. -# This script builds the SDDP model, extracts one subproblem from the policy graph, -# removes the unnamed slack variable that HydroPowerModels adds, and writes the -# clean JuMP model to disk. +# 1. verify the three frozen input hashes (`verify_inputs`) — refuse to export +# from anything but the committed case bytes; +# 2. parse the case with `HydroPowerModels.parse_folder`; +# 3. apply the canonical 0.6 active AND reactive load factor at model +# construction (`scale_main_loads!`) — `PowerModels.json` stays byte-exact; +# 4. pass `stage_hours` from `hydro.json` into `create_param`, so +# HydroPowerModels' own `constraint_hydro_balance` builds the water balance +# with K = 0.0036 * stage_hours = 0.6048; +# 5. serialize subproblem 1 with `JuMP.write_to_file`; +# 6. re-read each file and assert its structural invariants +# (`verify_generated_model`), including that K; +# 7. rewrite `bolivia/case_manifest.json` from the generated bytes and mirror +# the whole case, byte for byte, into DecisionRulesExa.jl. # -# The exported files already ship with this repository under: -# bolivia/ACPPowerModel.mof.json -# bolivia/SOCWRConicPowerModel.mof.json -# bolivia/DCPPowerModel.mof.json -# case3/ACPPowerModel.mof.json +# No JSON coefficient is edited, no constraint is post-processed, and no equation +# is recreated by hand. If HydroPowerModels does not itself build the expected +# model, the assertions in step 6 fail and nothing downstream is updated. # -# Re-run this script only if: -# - The HydroPowerModels data (hydro.json, inflows.csv) has changed -# - A new power-flow formulation is needed -# - The HydroPowerModels.jl version changes the subproblem structure +# Usage (from examples/HydroPowerModels, with the pinned SDDP environment that +# carries HydroPowerModels, PowerModels, Clarabel and MadNLP): # -# Requires: HydroPowerModels.jl, a compatible solver (Mosek, Gurobi, or MadNLP) +# julia --project=sddp export_subproblem_mof.jl +# julia --project=sddp export_subproblem_mof.jl --formulations=ACPPowerModel +# julia --project=sddp export_subproblem_mof.jl --exa-root=/path/to/DecisionRulesExa.jl # -# Usage: -# julia export_subproblem_mof.jl [case] [formulation] -# julia export_subproblem_mof.jl bolivia ACPPowerModel -# julia export_subproblem_mof.jl bolivia SOCWRConicPowerModel +# `--exa-root` additionally mirrors the frozen inputs, the three exports and the +# manifest into the other engine and asserts byte-identity. using HydroPowerModels +using PowerModels using JuMP -using MosekTools - -# ── Configuration ───────────────────────────────────────────────────────────── - -case = length(ARGS) >= 1 ? ARGS[1] : "bolivia" -formulation_name = length(ARGS) >= 2 ? ARGS[2] : "ACPPowerModel" - -# Map string names to PowerModels types -FORMULATIONS = Dict( +# The solver only populates the subproblem models during `simulate`; the +# MathOptFormat export serializes model STRUCTURE (variables, constraints, +# objective, names), which is solver independent. Clarabel handles the conic and +# DC formulations, MadNLP the nonconvex polar-AC one — the same two solvers the +# production SDDP baseline uses. +using Clarabel +using MadNLP + +include(joinpath(@__DIR__, "generate_canonical_case_artifacts.jl")) +using .HydroCanonicalCase + +const FORMULATION_TYPES = Dict( "ACPPowerModel" => ACPPowerModel, "SOCWRConicPowerModel" => SOCWRConicPowerModel, "DCPPowerModel" => DCPPowerModel, ) -formulation = FORMULATIONS[formulation_name] - -case_dir = joinpath(dirname(@__FILE__), case) -num_stages = 96 - -@info "Exporting subproblem" case formulation num_stages - -# ── Build the SDDP model ───────────────────────────────────────────────────── +""" + option(prefix) -> Union{Nothing,String} -alldata = HydroPowerModels.parse_folder(case_dir) - -# Scale loads to match the training setup (Bolivia uses 60% load scaling) -for load in values(alldata[1]["powersystem"]["load"]) - load["qd"] = load["qd"] * 0.6 - load["pd"] = load["pd"] * 0.6 +Value of the first `--key=value` command-line argument whose key matches +`prefix`, or `nothing` when the option was not given. +""" +function option(prefix) + index = findfirst(value -> startswith(value, prefix), ARGS) + return isnothing(index) ? nothing : split(ARGS[index], '='; limit = 2)[2] end -params = create_param(; - stages=num_stages, - model_constructor_grid=formulation, - post_method=PowerModels.build_opf, - optimizer=Mosek.Optimizer, -) - -m = hydro_thermal_operation(alldata, params) - -# ── Extract and clean one subproblem ────────────────────────────────────────── - -# Run a minimal simulation to populate the subproblem models -results = HydroPowerModels.simulate(m, 2) - -# The first stage subproblem is representative of all stages (same structure, -# different RHS values for inflows which load_hydropowermodels.jl sets via parameters) -model = m.forward_graph[1].subproblem - -# HydroPowerModels adds an unnamed slack variable — remove it before export -unnamed_idx = findfirst(v -> name(v) == "", all_variables(model)) -if !isnothing(unnamed_idx) - delete(model, all_variables(model)[unnamed_idx]) +""" + parse_canonical_case(case_dir) -> (alldata, stage_hours) + +Parse the frozen case for one export and apply the canonical demand convention. + +Re-parsed per formulation on purpose. `hydro_thermal_operation` and `simulate` +mutate the parsed dictionaries (fixed inflow values, per-subproblem solver +attributes), so sharing one `alldata` across the three builds would make each +export depend on which formulations ran before it — the exports would stop being +a function of the case bytes alone. Parsing is cheap next to building the policy +graph. + +`stage_hours` is read back out of the PARSED case rather than taken from a +constant, then required to be the frozen value: this is the single point at +which the weekly water balance enters the exported model. +""" +function parse_canonical_case(case_dir) + alldata = HydroPowerModels.parse_folder(case_dir; stages = TOTAL_STAGES) + scale_main_loads!(alldata) + stage_hours = Int(alldata[1]["hydro"]["stage_hours"]) + stage_hours == STAGE_HOURS || + error("parsed stage_hours is $stage_hours, expected $STAGE_HOURS") + 0.0036 * stage_hours == HYDRO_CONVERSION_K || + error("0.0036 * $stage_hours != $HYDRO_CONVERSION_K") + return alldata, stage_hours end -# ── Write to disk ───────────────────────────────────────────────────────────── +""" + export_formulation(case_dir, formulation_name) -> String + +Build the case through HydroPowerModels under one power-flow formulation and +serialize its first stage subproblem to `case_dir/.mof.json`. + +Stage 1 is the representative subproblem: every stage shares its structure and +differs only in the inflow right-hand side, which `build_hydropowermodels` turns +into a parameter. HydroPowerModels leaves one unnamed slack variable in the +subproblem; it is deleted before writing, because the loader identifies +variables by name. + +# Returns +- `String`: the path written. +""" +function export_formulation(case_dir, formulation_name) + alldata, stage_hours = parse_canonical_case(case_dir) + formulation = FORMULATION_TYPES[formulation_name] + optimizer = formulation == ACPPowerModel ? + (() -> MadNLP.Optimizer(; print_level = 0)) : + (() -> Clarabel.Optimizer(; verbose = false)) + + params = create_param(; + stages = TOTAL_STAGES, + stage_hours = stage_hours, + model_constructor_grid = formulation, + post_method = PowerModels.build_opf, + optimizer = optimizer, + ) + model = hydro_thermal_operation(alldata, params) + + # `hydro_thermal_operation` has already built the policy graph, so the + # structure exists without solving. The short simulate call is retained only + # because it populates solver attributes on the subproblems; a MadNLP failure + # at a stressed default start does not invalidate the structure, so it is + # tolerated rather than fatal. + try + HydroPowerModels.simulate(model, 2) + catch err + @warn "simulate() failed; exporting model structure regardless" formulation_name err + end + + subproblem = model.forward_graph[1].subproblem + unnamed = findfirst(v -> name(v) == "", all_variables(subproblem)) + isnothing(unnamed) || delete(subproblem, all_variables(subproblem)[unnamed]) + + path = joinpath(case_dir, formulation_name * ".mof.json") + JuMP.write_to_file(subproblem, path) + return path +end -outfile = joinpath(case_dir, formulation_name * ".mof.json") -JuMP.write_to_file(model, outfile) -@info "Exported subproblem to: $outfile" +function main() + case_dir = joinpath(@__DIR__, "bolivia") + + requested = option("--formulations=") + formulations = isnothing(requested) ? collect(FORMULATIONS) : + String.(split(requested, ',')) + for formulation_name in formulations + haskey(FORMULATION_TYPES, formulation_name) || + error("unknown formulation $formulation_name") + end + + counts = verify_inputs(case_dir) + @info "Frozen case verified" case_dir counts + @info "Canonical demand applied at construction" pd_scale = ACTIVE_LOAD_FACTOR qd_scale = + REACTIVE_LOAD_FACTOR deficit_cost = ACTIVE_DEFICIT_COST + @info "Water balance" stage_hours = STAGE_HOURS K = HYDRO_CONVERSION_K stages = TOTAL_STAGES + + for formulation_name in formulations + path = export_formulation(case_dir, formulation_name) + summary = verify_generated_model(path, formulation_name) + @info "Exported and structurally validated" formulation_name path summary + end + + # The manifest is derived from the bytes just written, then re-verified from + # disk, so a manifest can never describe a model that was not exported. + manifest = HydroCanonicalCase.build_manifest(case_dir) + manifest_file = HydroCanonicalCase.write_manifest(case_dir, manifest) + HydroCanonicalCase.verify(case_dir) + + mirrored = String[] + exa_root = option("--exa-root=") + if exa_root !== nothing + mirrored = mirror_case!( + case_dir, + joinpath(exa_root, "examples", "HydroPowerModels", "bolivia"), + ) + end + + for formulation_name in formulations + println( + formulation_name, ".mof.json sha256 ", + sha256_file(joinpath(case_dir, formulation_name * ".mof.json")), + ) + end + println("case_manifest.json sha256 ", sha256_file(manifest_file)) + isempty(mirrored) || println("mirrored to $exa_root: ", join(mirrored, ", ")) +end -# Verify the file is readable -test_model = JuMP.read_from_file(outfile; use_nlp_block=false) -nvars = length(all_variables(test_model)) -ncons = length(all_constraints(test_model; include_variable_in_set_constraints=false)) -@info "Verification" variables = nvars constraints = ncons +(abspath(PROGRAM_FILE) == @__FILE__) && main() diff --git a/examples/HydroPowerModels/gen_inputs_l2O_hydropowermodels.jl b/examples/HydroPowerModels/gen_inputs_l2O_hydropowermodels.jl deleted file mode 100644 index 775fffd..0000000 --- a/examples/HydroPowerModels/gen_inputs_l2O_hydropowermodels.jl +++ /dev/null @@ -1,98 +0,0 @@ -using DecisionRules -using L2O -using JuMP -using UUIDs - -# Parameters -case_name = "case3" # bolivia, case3 -formulation = "ACPPowerModel" # SOCWRConicPowerModel, DCPPowerModel, ACPPowerModel -num_stages = 48 # 96, 48 -save_file = "$(case_name)-$(formulation)-h$(num_stages)" -formulation_file = formulation * ".mof.json" -batch_id = uuid1() - -# Build MSP - -HydroPowerModels_dir = dirname(@__FILE__) -include(joinpath(HydroPowerModels_dir, "load_hydropowermodels.jl")) -case_dir = joinpath(HydroPowerModels_dir, case_name) - -subproblems, state_params_in, state_params_out, uncertainty_samples, initial_state, max_volume = build_hydropowermodels( - joinpath(HydroPowerModels_dir, case_name), formulation_file; num_stages=num_stages -) - -det_equivalent, uncertainty_samples = DecisionRules.deterministic_equivalent!( - JuMP.Model(), - subproblems, - state_params_in, - state_params_out, - initial_state, - uncertainty_samples, -) - -# Remove state imposing constraints - -all_vars = all_variables(det_equivalent) -_deficit = all_vars[findall(x -> occursin("_deficit", name(x)), all_vars)] -state_params = vcat([[param[1] for param in params] for params in state_params_out]...) -state_vars = vcat([[param[2] for param in params] for params in state_params_out]...) -cons = JuMP.all_constraints(det_equivalent; include_variable_in_set_constraints=false) -for con in cons - obj = JuMP.constraint_object(con) - func = obj.func - _vars = if !(func isa Array) - keys(func.terms) - else - func - end - - if all([ - (_var in state_params) || (_var in _deficit) || (_var in state_vars) for - _var in _vars - ]) - delete(det_equivalent, con) - end -end - -for _var in _deficit - delete(det_equivalent, _var) -end - -for _var in state_params - delete(det_equivalent, _var) -end - -# The problem iterator -num_samples = 10000 -pairs = Dict{VariableRef,Vector{Float64}}() - -# initial_state -for (i, hyd_in) in enumerate(state_params_in[1]) - pairs[hyd_in] = fill(initial_state[i], num_samples) -end - -JuMP.write_to_file( - det_equivalent, joinpath(case_dir, formulation) * "_det_equivalent.mof.json" -) - -# inflow -recursive_merge(x::AbstractDict...) = merge(recursive_merge, x...) -inflow = vcat([[_var for _var in keys(dict)] for dict in uncertainty_samples]...) -pairs = merge( - pairs, Dict(inflow .=> [Vector{Float64}(undef, num_samples) for _ in 1:length(inflow)]) -) -for s in 1:num_samples - uncertainty_sample = sample(uncertainty_samples) - uncertainty_sample = recursive_merge(uncertainty_sample...) - for _var in inflow - pairs[_var][s] = uncertainty_sample[_var] - end -end - -problem_iterator = ProblemIterator(pairs) - -save( - problem_iterator, - joinpath(case_dir, case_name * "_" * formulation * "_input_" * string(batch_id)), - ArrowFile, -) diff --git a/examples/HydroPowerModels/generate_canonical_case_artifacts.jl b/examples/HydroPowerModels/generate_canonical_case_artifacts.jl new file mode 100644 index 0000000..58643d1 --- /dev/null +++ b/examples/HydroPowerModels/generate_canonical_case_artifacts.jl @@ -0,0 +1,746 @@ +#!/usr/bin/env julia + +# Frozen case contract for the public Bolivia hydro example. +# +# This file is the single machine-readable description of the case that the +# published TS-DDR-vs-SDDP comparison was actually run on, plus the verifier +# that proves a checkout still matches it. It is byte-identical in +# DecisionRules.jl and DecisionRulesExa.jl so that either engine can assert the +# same contract without depending on the other. +# +# It VERIFIES; it does not repair. The three case inputs are consumed exactly as +# committed — no initial-volume repair, no demand atoms. Every quantity below is +# either read from those bytes or is a constant of the evaluation protocol. The +# serialized stage models are GENERATED from those bytes by +# `export_subproblem_mof.jl`, and this file checks that what was generated +# matches the case. +# +# Usage: +# julia --project generate_canonical_case_artifacts.jl # verify + (re)write bolivia/case_manifest.json +# julia --project generate_canonical_case_artifacts.jl --verify # verify only; fails if the manifest disagrees +# julia --project generate_canonical_case_artifacts.jl --exa-root=/path/to/DecisionRulesExa.jl +# # additionally mirror the frozen bytes to the other engine + +module HydroCanonicalCase + +using JSON +using SHA +using StableRNGs + +# ── Frozen case inputs ──────────────────────────────────────────────────────── +# The three files below are the WHOLE case. They are byte-identical in both +# public packages; `verify_inputs` refuses to proceed on any other bytes. +# +# `hydro.json` is the RAW upstream file. Its `initial_volume` entries are +# denormal doubles near 9e-316 — i.e. zero to ~300 orders of magnitude below the +# smallest reservoir capacity in the case (0.042 pu). Both engines clamp the +# initial state into `[min_volume, max_volume]` and then use it at the engine's +# working precision, which leaves every reservoir empty at stage 1. That empty +# start is the state the published result was produced from; see +# `INITIAL_STATE_NOTE`. +const INPUT_HASHES = Dict( + "PowerModels.json" => "1ff598447957f9fc17ca570415bf5b9b5b14e1292ea3bd3163db0ad79911a782", + "hydro.json" => "b25ce1c7bafcfaf907091dcd1007949c79a79974c9a33020b2587400d756b29a", + "inflows.csv" => "5afb275dff3fc879e3e93b6510b81295834faad0bcd2bd1fc070a8e3e6653c77", +) + +# Files whose PRESENCE would mean a different case. `demand.csv` / +# `demand_scenarios.csv` would introduce demand uncertainty; the `bolivia_*` +# variants are the abandoned grid/demand case-design candidates. The frozen +# experiment uses deterministic demand and inflow uncertainty only, so the +# verifier fails closed if any of these reappear. +const FORBIDDEN_CASE_FILES = ( + "demand.csv", + "demand_scenarios.csv", + "demand_noise.csv", +) + +# ── Load and cost conventions ───────────────────────────────────────────────── +const ACTIVE_LOAD_FACTOR = 0.6 # pd <- 0.6 * PowerModels.json pd, every stage +const REACTIVE_LOAD_FACTOR = 0.6 # qd <- 0.6 * PowerModels.json qd, every stage +const DEMAND_IS_DETERMINISTIC = true +const ACTIVE_DEFICIT_COST = 6000.0 # USD per pu of shed active power per stage +const ACTIVE_DEFICIT_COST_DERIVATION = "cost_deficit 60 USD/MWh * baseMVA 100" +const REACTIVE_BALANCE = "hard" # no reactive slack variable anywhere + +# ── Water balance ───────────────────────────────────────────────────────────── +# The stage water balance converts flow (m^3/s) to stored volume with +# K = 0.0036 * stage_hours. Weekly stages give K = 0.6048; a run that leaves +# stage_hours at its default of 1 silently models a week as an hour, so both +# numbers are asserted against `hydro.json` rather than assumed. +const STAGE_HOURS = 168 +const HYDRO_CONVERSION_K = 0.6048 + +# ── Horizon ─────────────────────────────────────────────────────────────────── +# 126 stages are simulated; costs are reported over the first 96. The 30-stage +# tail is a look-ahead buffer that keeps the reported window free of end-of- +# horizon reservoir dumping. +const REPORTING_STAGES = 96 +const LOOKAHEAD_STAGES = 30 +const TOTAL_STAGES = REPORTING_STAGES + LOOKAHEAD_STAGES + +# ── Evaluation protocol ─────────────────────────────────────────────────────── +# The paired protocol is reproducible by construction rather than stored: entry +# [t, s] of `rand(StableRNG(20260706), 1:nCen, 126, 500)` is the inflow scenario +# realized at stage t of paired column s. Array SHAPE is part of the contract — +# an RNG stream consumed into a differently shaped array yields different draws, +# so every consumer must generate exactly 126 x 500 and slice what it needs. +const INFLOW_PROTOCOL_SEED = 20260706 +const PROTOCOL_STAGES = 126 +const PROTOCOL_SCENARIOS = 500 +const PROTOCOL_SCENARIO_IDS = "1:500 (global column ids; shards must preserve them)" + +# ── Method configuration held fixed across both policies ────────────────────── +const TSDDR_FORMULATION = "ACPPowerModel" # true AC, polar; training AND evaluation +const TSDDR_TARGET_MODE = "strict" # reservoir targets are equalities, no slack +const TSDDR_TARGET_ACTIVATION = "stretchedsigmoid" # maps onto [0, 1 - 1e-3] of the reachable set +const SDDP_BACKWARD_FORMULATION = "SOCWRConicPowerModel" +const SDDP_FORWARD_FORMULATION = "ACPPowerModel" + +# ── Serialized stage subproblems (MathOptFormat) ────────────────────────────── +# `.mof.json` is the one-stage OPF subproblem, serialized by JuMP's +# MathOptFormat writer from the model HydroPowerModels builds out of the three +# frozen inputs above. It is a GENERATED artifact, never hand-edited: +# `export_subproblem_mof.jl` is the only supported producer, and it regenerates +# all three formulations from the unchanged case in one pass. +# +# These files are load-bearing. The JuMP/MAIN workflow — `build_hydropowermodels` +# in `load_hydropowermodels.jl`, and therefore `train_dr_hydropowermodels_strict.jl`, +# `eval_paired_tsddr.jl` and `eval_jump_de.jl` — reads one copy per stage and +# re-derives the water-balance coefficient from it, failing closed unless that +# coefficient equals `0.0036 * stage_hours`. The SDDP baseline instead builds +# through HydroPowerModels directly, and the ExaModels engine builds its own +# `ExaModel`. All three describe the same stage problem, and were verified to do +# so variable by variable — not merely to agree on the objective — before this +# release. +const FORMULATIONS = ("ACPPowerModel", "DCPPowerModel", "SOCWRConicPowerModel") +const GENERATED_MODEL_NOTE = + "One-stage subproblem exports generated by export_subproblem_mof.jl from the " * + "frozen inputs through HydroPowerModels with stage_hours = $(STAGE_HOURS), so " * + "the hydro-balance inflow coefficient is the case's K = $(HYDRO_CONVERSION_K). " * + "The JuMP/MAIN workflow loads these files as its stage subproblems; SDDP builds " * + "through HydroPowerModels and the ExaModels engine builds its own model." + +# A reservoir volume below this is zero for every purpose in this case: the +# smallest nonzero capacity is 0.042 pu, ~314 orders of magnitude larger. +const EMPTY_VOLUME_TOL = 1e-300 + +const INITIAL_STATE_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." + +""" + sha256_file(path) -> String + +Hex-encoded SHA-256 of the file at `path`. +""" +sha256_file(path::AbstractString) = bytes2hex(open(SHA.sha256, path)) + +""" + initial_state(case_dir) -> Vector{Float64} + +Reservoir volumes at stage 1, computed the way both engines compute them: +`clamp(initial_volume, min_volume, max_volume)` per unit. + +# Arguments +- `case_dir::AbstractString`: directory holding `hydro.json`. + +# Returns +- `Vector{Float64}`: one clamped initial volume per hydro unit, in file order. +""" +function initial_state(case_dir::AbstractString) + hydro = JSON.parsefile(joinpath(case_dir, "hydro.json"))["Hydrogenerators"] + return [ + clamp( + Float64(unit["initial_volume"]), + Float64(unit["min_volume"]), + Float64(unit["max_volume"]), + ) + for unit in hydro + ] +end + +""" + scale_main_loads!(alldata) -> typeof(alldata) + +Apply the canonical demand convention to a parsed HydroPowerModels case, in +place: every load's `pd` is multiplied by `ACTIVE_LOAD_FACTOR` and every load's +`qd` by `REACTIVE_LOAD_FACTOR`, in every stage's power-system dictionary. + +`PowerModels.json` is kept byte-exact on disk, so the 0.6 factor exists only as +this runtime step. Applying it symmetrically to active AND reactive demand is +part of the frozen contract: an asymmetric scaling changes the reactive balance +and therefore the AC feasible set. Every consumer of the case — the MOF +exporter, the SDDP baseline, and the ExaModels builder — must call this or +reproduce it exactly. + +The per-stage active load-shedding price is re-asserted at the same time: +`cost_deficit` is stored per MVA, so `ACTIVE_DEFICIT_COST / baseMVA` is the +value that makes the objective coefficient of `deficit[b]` equal +`ACTIVE_DEFICIT_COST`. `verify_inputs` has already checked that the committed +bytes imply exactly that, so this is a no-op assertion in normal operation and a +loud one otherwise. + +# Arguments +- `alldata`: the vector of per-stage dictionaries returned by + `HydroPowerModels.parse_folder`. + +# Returns +- `alldata`, mutated in place. +""" +function scale_main_loads!(alldata) + for data in alldata + for load in values(data["powersystem"]["load"]) + load["pd"] *= ACTIVE_LOAD_FACTOR + load["qd"] *= REACTIVE_LOAD_FACTOR + end + data["powersystem"]["cost_deficit"] = + ACTIVE_DEFICIT_COST / Float64(data["powersystem"]["baseMVA"]) + end + return alldata +end + +""" + verify_inputs(case_dir) -> Dict + +Assert every property of the frozen case that can be checked from the committed +bytes, and return the topology counts. + +Checks, in order: the three input hashes; the absence of any file that would +introduce demand uncertainty; `stage_hours` and the derived water-balance `K`; +`baseMVA`; the active load-shedding coefficient; and that the clamped initial +state is empty in both Float64 and Float32. + +# Arguments +- `case_dir::AbstractString`: directory holding the three frozen inputs. + +# Returns +- `Dict{String,Int}`: bus / branch / generator / load / hydro-unit counts. + +# Throws +- `ErrorException` on the first violated invariant, naming the expected and the + observed value. +""" +function verify_inputs(case_dir::AbstractString) + for (name, expected) in INPUT_HASHES + path = joinpath(case_dir, name) + isfile(path) || error("missing frozen case input: $path") + actual = sha256_file(path) + actual == expected || + error("frozen input hash mismatch for $path: expected $expected, got $actual") + end + + for name in FORBIDDEN_CASE_FILES + path = joinpath(case_dir, name) + isfile(path) && error( + "$path is present. The frozen case has DETERMINISTIC demand and " * + "inflow uncertainty only; a demand file means a different experiment.", + ) + end + + hydro = JSON.parsefile(joinpath(case_dir, "hydro.json")) + Int(hydro["stage_hours"]) == STAGE_HOURS || + error("stage_hours must be $STAGE_HOURS, got $(hydro["stage_hours"])") + k = 0.0036 * Int(hydro["stage_hours"]) + k == HYDRO_CONVERSION_K || + error("water-balance K must be $HYDRO_CONVERSION_K, got $k") + + power = JSON.parsefile(joinpath(case_dir, "PowerModels.json")) + Float64(power["baseMVA"]) == 100.0 || + error("frozen baseMVA must be 100, got $(power["baseMVA"])") + coefficient = Float64(power["cost_deficit"]) * Float64(power["baseMVA"]) + coefficient == ACTIVE_DEFICIT_COST || + error("active load-shedding coefficient must be $ACTIVE_DEFICIT_COST, got $coefficient") + + # Empty start. Checking BOTH precisions matters: MAIN runs the state in + # Float64 (where the denormal survives as ~9e-316, i.e. zero to within + # EMPTY_VOLUME_TOL) while the ExaModels engine runs it in Float32 (where the + # same denormal underflows to an exact zero). Either way stage 1 starts dry. + x0 = initial_state(case_dir) + bad = findall(v -> !(v <= EMPTY_VOLUME_TOL), x0) + isempty(bad) || error( + "frozen case must start from empty reservoirs (<= $EMPTY_VOLUME_TOL); " * + "units $bad hold $(x0[bad]). A 70%-of-capacity initial-volume repair is " * + "NOT part of this case.", + ) + all(Float32.(x0) .== 0.0f0) || + error("clamped initial state must be exactly zero in Float32; got $(Float32.(x0))") + + return Dict( + "buses" => length(power["bus"]), + "branches" => length(power["branch"]), + "generators" => length(power["gen"]), + "loads" => length(power["load"]), + "hydro_units" => length(hydro["Hydrogenerators"]), + ) +end + +""" + protocol_indices(ncen) -> Matrix{Int} + +The frozen paired protocol: `[t, s]` is the inflow scenario realized at stage +`t` of paired column `s`. + +# Arguments +- `ncen::Integer`: number of inflow scenarios available in `inflows.csv`. + +# Returns +- `Matrix{Int}`: a `PROTOCOL_STAGES` x `PROTOCOL_SCENARIOS` index matrix. + +# Notes +Generated with `StableRNGs.StableRNG(INFLOW_PROTOCOL_SEED)`. The shape is part +of the contract: a differently shaped `rand` call consumes the same stream +differently and yields a different protocol. +""" +function protocol_indices(ncen::Integer) + return rand( + StableRNG(INFLOW_PROTOCOL_SEED), + 1:ncen, + PROTOCOL_STAGES, + PROTOCOL_SCENARIOS, + ) +end + +""" + inflow_scenario_count(case_dir) -> Int + +Number of inflow scenarios in `inflows.csv`, derived as columns / hydro units. +""" +function inflow_scenario_count(case_dir::AbstractString) + header = split(first(eachline(joinpath(case_dir, "inflows.csv"))), ',') + nhyd = length(JSON.parsefile(joinpath(case_dir, "hydro.json"))["Hydrogenerators"]) + length(header) % nhyd == 0 || + error("inflows.csv has $(length(header)) columns, not a multiple of $nhyd units") + return length(header) ÷ nhyd +end + +""" + protocol_digest(case_dir) -> (ncen, sha256) + +SHA-256 of the frozen protocol index matrix, serialized column-major as +comma-separated decimal integers. + +This is the reproducibility artifact for the protocol: it is small, it is +independent of any stored CSV, and it fails if either the seed, the shape, or +the inflow-scenario count changes. +""" +function protocol_digest(case_dir::AbstractString) + ncen = inflow_scenario_count(case_dir) + indices = protocol_indices(ncen) + context = SHA.SHA256_CTX() + for (i, v) in enumerate(indices) + SHA.update!(context, codeunits(i == 1 ? string(v) : "," * string(v))) + end + return (ncen = ncen, sha256 = bytes2hex(SHA.digest!(context))) +end + +""" + verify_generated_model(path, formulation) -> Dict + +Check the structural invariants of a generated MathOptFormat stage export and +return its summary. + +Asserted: minimization sense; 28 active-deficit objective terms all priced at +`ACTIVE_DEFICIT_COST`; 11 hydro balances each with exactly one inflow term, all +agreeing on that term's coefficient, whose magnitude must be the case's +`HYDRO_CONVERSION_K`; no mixing of operational active deficit with +reservoir-target slack; and, for `ACPPowerModel`, 28 hard reactive-balance +equations plus both-ended apparent-power limits. + +The water-balance assertion is the one that catches the failure this case has +already suffered once: an export taken with `stage_hours` left at its default of +1 carries K = 0.0036 and silently models a week as an hour. Such a file is +rejected here, and again by `build_hydropowermodels` when it loads a stage. +""" +function verify_generated_model(path::AbstractString, formulation::AbstractString) + isfile(path) || error("missing reference model export: $path") + model = JSON.parsefile(path) + + model["objective"]["sense"] == "min" || + error("$formulation objective is not a minimization") + + terms = get(model["objective"]["function"], "terms", Any[]) + deficit_terms = [t for t in terms if startswith(get(t, "variable", ""), "deficit[")] + length(deficit_terms) == 28 || + error("$formulation must price 28 active-deficit terms, found $(length(deficit_terms))") + all(Float64(t["coefficient"]) == ACTIVE_DEFICIT_COST for t in deficit_terms) || + error("$formulation active-deficit coefficient is not $ACTIVE_DEFICIT_COST") + + balances = [ + c for c in model["constraints"] + if startswith(get(c, "name", ""), "hydro_balance[") + ] + length(balances) == 11 || + error("$formulation must have 11 hydro balances, found $(length(balances))") + coefficients = Float64[] + for constraint in balances + inflow_terms = [ + t for t in constraint["function"]["terms"] + if startswith(get(t, "variable", ""), "inflow[") + ] + length(inflow_terms) == 1 || + error("$formulation hydro balance does not have exactly one inflow term") + push!(coefficients, abs(Float64(only(inflow_terms)["coefficient"]))) + end + length(unique(coefficients)) == 1 || + error("$formulation hydro balances disagree on the inflow coefficient: $(unique(coefficients))") + only(unique(coefficients)) == HYDRO_CONVERSION_K || error( + "$formulation hydro-balance inflow coefficient is " * + "$(only(unique(coefficients))), not the case's K = $HYDRO_CONVERSION_K. " * + "Regenerate with export_subproblem_mof.jl, which passes " * + "stage_hours = $STAGE_HOURS into HydroPowerModels.", + ) + + any(startswith(get(v, "name", ""), "target_deficit") for v in model["variables"]) && + error("$formulation export mixes operational active deficit with target slack") + + if formulation == "ACPPowerModel" + reactive = [ + c for c in model["constraints"] + if get(c["set"], "type", "") == "EqualTo" && any( + startswith(get(t, "variable", ""), "0_q[") + for t in get(c["function"], "terms", Any[]) + ) + ] + length(reactive) >= 28 || + error("ACP export is missing hard reactive-balance equations (found $(length(reactive)))") + quadratic = [ + c for c in model["constraints"] + if get(c["function"], "type", "") == "ScalarQuadraticFunction" && + get(c["set"], "type", "") == "LessThan" + ] + length(quadratic) >= 62 || + error("ACP export is missing both-ended apparent-power limits (found $(length(quadratic)))") + end + + return Dict( + "sha256" => sha256_file(path), + "variables" => length(model["variables"]), + "constraints" => length(model["constraints"]), + "objective_sense" => model["objective"]["sense"], + "active_deficit_terms" => length(deficit_terms), + "hydro_balances" => length(balances), + "hydro_balance_inflow_coefficient" => only(unique(coefficients)), + "matches_case_K" => true, + ) +end + +""" + build_manifest(case_dir) -> Dict + +Verify the case and assemble the full frozen-contract manifest. +""" +function build_manifest(case_dir::AbstractString) + counts = verify_inputs(case_dir) + digest = protocol_digest(case_dir) + x0 = initial_state(case_dir) + + return Dict( + "schema_version" => 2, + "case" => "Bolivia (upstream case, unmodified)", + "frozen_on" => "2026-08-02", + "input_hashes" => INPUT_HASHES, + "forbidden_case_files" => collect(FORBIDDEN_CASE_FILES), + "topology_counts" => counts, + + "initial_state" => Dict( + "effective" => "empty (all reservoirs at zero)", + "mechanism" => "clamp(initial_volume, min_volume, max_volume) at engine precision", + "raw_initial_volume_max" => maximum(x0), + "empty_volume_tolerance" => EMPTY_VOLUME_TOL, + "float32_is_exactly_zero" => all(Float32.(x0) .== 0.0f0), + "note" => INITIAL_STATE_NOTE, + ), + + "water_balance" => Dict( + "stage_hours" => STAGE_HOURS, + "K" => HYDRO_CONVERSION_K, + "K_derivation" => "0.0036 * stage_hours", + ), + + "demand" => Dict( + "active_load_factor" => ACTIVE_LOAD_FACTOR, + "reactive_load_factor" => REACTIVE_LOAD_FACTOR, + "deterministic" => DEMAND_IS_DETERMINISTIC, + "uncertainty" => "none; inflow uncertainty only", + ), + + "costs" => Dict( + "active_deficit_cost_usd_per_pu_stage" => ACTIVE_DEFICIT_COST, + "active_deficit_cost_derivation" => ACTIVE_DEFICIT_COST_DERIVATION, + "reactive_balance" => REACTIVE_BALANCE, + ), + + "horizon" => Dict( + "reporting_stages" => REPORTING_STAGES, + "lookahead_stages" => LOOKAHEAD_STAGES, + "total_stages" => TOTAL_STAGES, + ), + + "protocol" => Dict( + "seed" => INFLOW_PROTOCOL_SEED, + "rng" => "StableRNG(seed); rand(1:nCen, $(PROTOCOL_STAGES), $(PROTOCOL_SCENARIOS))", + "stages" => PROTOCOL_STAGES, + "scenarios" => PROTOCOL_SCENARIOS, + "scenario_ids" => PROTOCOL_SCENARIO_IDS, + "inflow_scenarios" => digest.ncen, + "indices_sha256" => digest.sha256, + "uncertainty" => "inflow only", + ), + + "method" => Dict( + "tsddr_formulation" => TSDDR_FORMULATION, + "tsddr_target_mode" => TSDDR_TARGET_MODE, + "tsddr_target_activation" => TSDDR_TARGET_ACTIVATION, + "sddp_backward_formulation" => SDDP_BACKWARD_FORMULATION, + "sddp_forward_formulation" => SDDP_FORWARD_FORMULATION, + ), + + "stage_models" => Dict{String,Any}( + "note" => GENERATED_MODEL_NOTE, + "generator" => "export_subproblem_mof.jl", + "consumed_by" => "build_hydropowermodels (JuMP/MAIN stage subproblems)", + "exports" => Dict( + formulation => verify_generated_model( + joinpath(case_dir, formulation * ".mof.json"), + formulation, + ) + for formulation in FORMULATIONS + ), + ), + ) +end + +""" + manifest_path(case_dir) -> String + +Location of the frozen-contract manifest inside `case_dir`. +""" +manifest_path(case_dir::AbstractString) = joinpath(case_dir, "case_manifest.json") + +""" + manifest_json(manifest) -> String + +Serialize `manifest` as JSON with every object's keys in sorted order. + +Written out rather than delegated to `JSON.print` because the manifest is a +CHECKED artifact: two runs, and the two packages, must produce byte-identical +files, and dictionary iteration order is not a stable contract. Sorting the keys +here makes the bytes a function of the content alone. +""" +manifest_json(manifest) = sprint(io -> _write_json(io, manifest, 0)) + +""" + _write_json(io, value, level) -> Nothing + +Recursive pretty-printer with two-space indentation and sorted object keys. +Scalars are delegated to `JSON.json` so escaping and number formatting stay +consistent with the parser. +""" +function _write_json(io::IO, value, level::Int) + pad = " " ^ (2 * level) + inner = " " ^ (2 * (level + 1)) + if value isa AbstractDict + isempty(value) && return print(io, "{}") + ks = sort(collect(keys(value)); by = string) + print(io, "{\n") + for (i, k) in enumerate(ks) + print(io, inner, JSON.json(string(k)), ": ") + _write_json(io, value[k], level + 1) + print(io, i == length(ks) ? "\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, inner) + _write_json(io, v, level + 1) + print(io, i == length(value) ? "\n" : ",\n") + end + print(io, pad, "]") + else + print(io, JSON.json(value)) + end + return nothing +end + +""" + write_manifest(case_dir, manifest) -> String + +Write `manifest` as sorted, indented JSON so the file is byte-reproducible +across runs and across the two packages. Returns the path written. +""" +function write_manifest(case_dir::AbstractString, manifest) + path = manifest_path(case_dir) + open(path, "w") do io + print(io, manifest_json(manifest)) + write(io, '\n') + end + return path +end + +""" + verify(case_dir) -> Dict + +Full verification: rebuild the contract from the committed bytes and require the +stored manifest to be identical to it. + +# Throws +- `ErrorException` if the manifest is missing or if any field differs, naming + the differing key path. +""" +function verify(case_dir::AbstractString) + expected = build_manifest(case_dir) + path = manifest_path(case_dir) + isfile(path) || error("missing frozen-contract manifest: $path (run this script with no arguments to write it)") + + # Primary check is on BYTES: the serializer is deterministic, so the stored + # file must equal what the committed inputs serialize to. Anything else is a + # difference, including formatting drift. + rendered = manifest_json(expected) * "\n" + read(path, String) == rendered && return expected + + # Bytes differ: parse both and report every differing key path, so the + # failure names WHAT changed rather than only that something did. + differences = String[] + compare_manifest!(differences, "", JSON.parsefile(path), JSON.parse(rendered)) + isempty(differences) && push!(differences, "(values agree; only formatting differs)") + return error( + "case manifest does not describe the committed bytes:\n " * + join(differences, "\n "), + ) +end + +""" + _is_json_object(value) -> Bool + +Whether `value` behaves like a JSON object: keyed, and not a string or array. +Duck-typed because a JSON parser may return its own dictionary-like type rather +than an `AbstractDict`. +""" +_is_json_object(value) = + !(value isa AbstractString) && !(value isa AbstractVector) && + applicable(keys, value) && applicable(getindex, value, "") + +""" + compare_manifest!(differences, prefix, stored, expected) -> Nothing + +Depth-first structural comparison that appends a human-readable `key: stored vs +expected` line to `differences` for every mismatch instead of stopping at the +first one. +""" +function compare_manifest!(differences, prefix, stored, expected) + if _is_json_object(expected) && _is_json_object(stored) + for key in union(keys(expected), keys(stored)) + path = isempty(prefix) ? String(key) : "$prefix.$key" + if !haskey(stored, key) + push!(differences, "$path: missing from manifest") + elseif !haskey(expected, key) + push!(differences, "$path: unexpected key in manifest") + else + compare_manifest!(differences, path, stored[key], expected[key]) + end + end + elseif expected isa AbstractVector && stored isa AbstractVector && !(expected isa AbstractString) + length(expected) == length(stored) || + return push!(differences, "$prefix: length $(length(stored)) vs $(length(expected))") + for i in eachindex(expected) + compare_manifest!(differences, "$prefix[$i]", stored[i], expected[i]) + end + elseif stored != expected + push!(differences, "$prefix: $(repr(stored)) vs expected $(repr(expected))") + end + return nothing +end + +""" + mirror_case!(case_dir, other_case_dir) -> Vector{String} + +Copy the frozen inputs, the generated stage models and the manifest from `case_dir` +into `other_case_dir`, then assert byte-identity. Returns the file names copied. + +This is the only supported way to synchronize the two engines' copies of the +case; it never regenerates anything. +""" +function mirror_case!(case_dir::AbstractString, other_case_dir::AbstractString) + mkpath(other_case_dir) + names = vcat( + collect(keys(INPUT_HASHES)), + [formulation * ".mof.json" for formulation in FORMULATIONS], + ["case_manifest.json"], + ) + for name in names + source = joinpath(case_dir, name) + isfile(source) || error("cannot mirror missing file: $source") + cp(source, joinpath(other_case_dir, name); force = true) + sha256_file(source) == sha256_file(joinpath(other_case_dir, name)) || + error("mirrored copy of $name is not byte-identical") + end + return names +end + +export INPUT_HASHES, FORBIDDEN_CASE_FILES, ACTIVE_LOAD_FACTOR, REACTIVE_LOAD_FACTOR, + DEMAND_IS_DETERMINISTIC, ACTIVE_DEFICIT_COST, REACTIVE_BALANCE, + STAGE_HOURS, HYDRO_CONVERSION_K, REPORTING_STAGES, LOOKAHEAD_STAGES, + TOTAL_STAGES, INFLOW_PROTOCOL_SEED, PROTOCOL_STAGES, PROTOCOL_SCENARIOS, + TSDDR_FORMULATION, TSDDR_TARGET_MODE, TSDDR_TARGET_ACTIVATION, + SDDP_BACKWARD_FORMULATION, SDDP_FORWARD_FORMULATION, FORMULATIONS, + GENERATED_MODEL_NOTE, + EMPTY_VOLUME_TOL, sha256_file, initial_state, scale_main_loads!, + verify_inputs, + inflow_scenario_count, protocol_indices, protocol_digest, + verify_generated_model, build_manifest, manifest_path, manifest_json, + write_manifest, + verify, mirror_case! + +end # module + +using .HydroCanonicalCase +using JSON + +function argument_value(prefix) + index = findfirst(value -> startswith(value, prefix), ARGS) + return isnothing(index) ? nothing : split(ARGS[index], '='; limit = 2)[2] +end + +function main() + case_dir = joinpath(@__DIR__, "bolivia") + + if "--verify" in ARGS + manifest = HydroCanonicalCase.verify(case_dir) + println(JSON.json(Dict( + "status" => "verified", + "case_dir" => case_dir, + "manifest_sha256" => sha256_file(HydroCanonicalCase.manifest_path(case_dir)), + "protocol_indices_sha256" => manifest["protocol"]["indices_sha256"], + ))) + return + end + + manifest = HydroCanonicalCase.build_manifest(case_dir) + path = HydroCanonicalCase.write_manifest(case_dir, manifest) + HydroCanonicalCase.verify(case_dir) + + mirrored = String[] + exa_root = argument_value("--exa-root=") + if exa_root !== nothing + mirrored = HydroCanonicalCase.mirror_case!( + case_dir, + joinpath(exa_root, "examples", "HydroPowerModels", "bolivia"), + ) + end + + println(JSON.json(Dict( + "status" => "written", + "manifest" => path, + "manifest_sha256" => sha256_file(path), + "protocol_indices_sha256" => manifest["protocol"]["indices_sha256"], + "mirrored" => mirrored, + ))) +end + +(abspath(PROGRAM_FILE) == @__FILE__) && main() diff --git a/examples/HydroPowerModels/hydro_reachable_policy.jl b/examples/HydroPowerModels/hydro_reachable_policy.jl new file mode 100644 index 0000000..f0db770 --- /dev/null +++ b/examples/HydroPowerModels/hydro_reachable_policy.jl @@ -0,0 +1,633 @@ +# Hydro Reachable Policy — feasibility-guaranteeing target policy for strict subproblems +# +# This file defines HydroReachablePolicy, a policy architecture that guarantees +# one-stage reachability for hydro reservoir targets. It wraps an LSTM encoder + +# feed-forward combiner (same architecture family as StateConditionedPolicy) but +# bounds the output to the one-stage reachable set via sigmoid activation. +# +# Depends on: DecisionRules (for _step_encoder, _init_recurrent_state, _state_eltype) +# Must be included AFTER `using DecisionRules`. + +using Functors +using ChainRulesCore + +""" + stretchedsigmoid(x) -> y ∈ [0, 1 - 1e-3] + +Mature strict-target activation. It reaches the lower endpoint at finite +pre-activation while retaining a safe interior margin at the upper endpoint, +which avoids forcing minimum turbine release and zero spill simultaneously in +an interior-point solve. +""" +function stretchedsigmoid(x::Real) + T = float(typeof(x)) + return clamp((sigmoid(x) - T(0.03)) / T(0.94), zero(T), one(T) - T(1e-3)) +end + +function hardsigmoidsafe(x::Real) + T = float(typeof(x)) + return min(Flux.hardsigmoid(x), one(T) - T(1e-3)) +end + +# ── Cascade link: upstream→downstream water-balance coupling ────────────────── + +struct CascadeLink + downstream::Int # array position of downstream unit + upstream::Int # array position of upstream unit + turn_only::Bool # true if only turbine outflow (not spill) reaches downstream + K_max_turn::Float32 # K × max_turn of the upstream unit +end + +""" + HydroReachablePolicy{E,C,S,V,SM} + +A policy that guarantees one-stage reachability for hydro reservoir targets. + +The policy architecture mirrors [`StateConditionedPolicy`](@ref): an LSTM +encoder processes only the uncertainty (inflow) sequence, then a feed-forward +combiner maps `[encoded_inflow; current_reservoir_state]` to normalized targets +in `[0, 1]` via sigmoid activation. These normalized targets are scaled to the +one-stage **reachable set** `[lower, upper]` for each reservoir: + +```math +target_r = lower_r + (upper_r - lower_r) \\cdot \\sigma(z_r) +``` + +where `lower_r` and `upper_r` are the minimum and maximum reservoir volumes achievable +in one stage from the current state `x_r` given inflow `w_r`, turbine bounds +`[min\\_turn_r, max\\_turn_r]`, and upstream cascade inflows. + +# Reachable bounds (per reservoir r) + +The upper reachable bound assumes minimum outflow (no turbine, no spill) plus maximum +upstream inflow from cascade connections: + +```math +upper_r = \\min(max\\_vol_r,\\; x_r + K \\cdot w_r - K \\cdot min\\_turn_r + upstream\\_max_r) +``` + +The lower reachable bound assumes maximum outflow (full turbine + max spill): + +```math +lower_r = \\max(min\\_vol_r,\\; x_r + K \\cdot w_r - K \\cdot max\\_turn_r - spill\\_max_r) +``` + +When `spill_max === nothing` (unlimited spillage), `lower_r = min_vol_r` since the +reservoir can always be emptied to its physical minimum. + +The bounds are DIFFERENTIABLE: gradient flows both through the sigmoid path +`σ(z_r)` and through the endpoints' affine dependence on `x_prev`, which is what +carries the adjoint recursion across stages. + +# Cascade-aware target clamping + +For downstream units receiving water from upstream cascade connections, the initial +upper bound uses `upstream_max_r = Σ K × max_turn_u`, which can overestimate the +actual upstream contribution when the upstream unit stores water (target increases). + +After computing initial targets for all units, a **cascade clamping** step adjusts +downstream targets using the actual upstream release implied by the upstream target: + +```math +R_u = K \\cdot w_u + x_u - \\hat{x}_u +``` + +- **Turn + spill connection**: max upstream contribution = ``\\max(0, R_u)`` +- **Turn-only connection**: max contribution = ``\\min(K \\cdot max\\_turn_u, \\max(0, R_u))`` + +The downstream target is clamped: ``\\hat{x}_r ← \\min(\\hat{x}_r, true\\_upper_r)``. +This clamping is DIFFERENTIABLE — when the clamp binds, the downstream target +inherits the upstream target's influence through ``R_u``. + +# Strict-mode guarantee + +If `x₀` is a feasible initial reservoir state and each policy call returns +``\\hat{x}_t ∈ R(x_{t-1}, w_t)`` (including cascade-consistent bounds), then the +strict equality ``x_t = \\hat{x}_t`` is feasible for every stage solved in sequence. +The proof is by induction: stage 1 is feasible because ``\\hat{x}_1`` is reachable from +``x_0``; if stage ``t`` is feasible and realizes ``x_t = \\hat{x}_t``, then the +policy computes ``\\hat{x}_{t+1}`` from a feasible previous state with cascade-clamped +bounds, so stage ``t+1`` is feasible. + +# Fields +- `encoder::E`: Recurrent cell or Chain of cells (processes inflow only) +- `combiner::C`: Feed-forward head combining encoder output with previous state +- `state::S`: Recurrent state (threaded across stages) +- `n_context::Int`: Number of context dimensions prepended before inflow +- `n_uncertainty::Int`: Number of inflow dimensions (= nHyd) +- `n_state::Int`: Number of state dimensions (= nHyd) +- `min_vol::V`: Per-unit minimum reservoir volume +- `max_vol::V`: Per-unit maximum reservoir volume +- `min_turn::V`: Per-unit minimum turbine outflow +- `max_turn::V`: Per-unit maximum turbine outflow +- `upstream_max::V`: Pre-computed maximum upstream inflow contribution per unit +- `spill_max::SM`: Per-unit max spillage (`nothing` = unlimited) +- `K::Float64`: Water-balance conversion factor from flow to volume + +See also: [`hydro_reachable_policy`](@ref), [`StateConditionedPolicy`](@ref) +""" +mutable struct HydroReachablePolicy{E,C,S,V,SM} + encoder::E # Recurrent encoder (LSTM/GRU chain) processing inflow + combiner::C # Feed-forward [encoder_out; state] => normalized target + state::S # Carried recurrent state, threaded across stages + n_context::Int # Number of context dimensions prepended before inflow + n_uncertainty::Int # Number of uncertainty (inflow) dimensions + n_state::Int # Number of state (reservoir) dimensions + min_vol::V # Per-unit minimum reservoir volume [nHyd] + max_vol::V # Per-unit maximum reservoir volume [nHyd] + min_turn::V # Per-unit minimum turbine outflow [nHyd] + max_turn::V # Per-unit maximum turbine outflow [nHyd] + upstream_max::V # Pre-computed K × Σ(upstream max_turn) per unit [nHyd] + spill_max::SM # Per-unit max spill, or nothing for unlimited + K::Float64 # Water-balance conversion factor from flow to volume + cascade::Vector{CascadeLink} # Upstream→downstream connections for target clamping +end + +# Only encoder and combiner are trainable. Bounds, state, dimensions are frozen. +Functors.@functor HydroReachablePolicy (encoder, combiner) + +""" + _hydro_reachable_bounds(policy::HydroReachablePolicy, inflow, x_prev) + +Compute the one-stage reachable reservoir bounds given current state `x_prev` +and per-unit inflow `inflow`. Returns `(lower, upper)` vectors. + +The upper bound is the maximum volume achievable in one stage: current volume +plus inflow minus minimum turbine outflow plus maximum upstream cascade inflow, +clamped to `max_vol`. The lower bound is the minimum volume achievable: current +volume plus inflow minus maximum turbine outflow minus maximum spill, clamped +to `min_vol`. + +# Differentiability + +This function is DIFFERENTIABLE in `x_prev`, and that term is load-bearing. The +emitted target is ``\\hat{x}_t = l_t + (u_t - l_t) \\odot y_t`` with both endpoints +affine in the previous state, so + +```math +\\frac{\\partial \\hat{x}_t}{\\partial x_{t-1}} = \\operatorname{diag}(y_t) +``` + +wherever the upper bound is off its `max_vol` ceiling (plus +``\\operatorname{diag}(1 - y_t)`` on coordinates whose lower bound is the +spill-limited `lower_raw`). Since the TS-DDR actor loss ``\\langle \\lambda, +\\hat{x}(\\theta) \\rangle`` feeds ``\\hat{x}_{t-1}`` back as the next stage's state +input, suppressing this term truncates the adjoint recursion at EVERY stage, not +only where a constraint binds, and the error compounds with the horizon. + +A `ChainRulesCore.@non_differentiable` declaration used to sit here. Measured on +the shared production operating point (Bolivia, ``T = 126``, `min_turn` ≡ 0) it +dropped the term on 34.6% of (stage, reservoir) pairs and left the applied update +at cosine 0.673 / norm ratio 0.059 against the true gradient — ~48° off-direction +at 6% magnitude — while the differentiable form matches finite differences to six +digits. It is therefore removed here and in DecisionRulesExa.jl's copy. + +# Arguments +- `policy::HydroReachablePolicy`: policy containing hydro bounds and parameters +- `inflow`: per-unit inflow vector for this stage +- `x_prev`: current reservoir volumes (state from previous stage) + +# Returns +- `(lower, upper)`: tuple of vectors, each of length `n_state` +""" +function _hydro_reachable_bounds(policy::HydroReachablePolicy, inflow, x_prev) + # Cast all bound vectors to match the element type of x_prev for type stability + T = eltype(x_prev) + K = T(policy.K) + min_vol = T.(policy.min_vol) + max_vol = T.(policy.max_vol) + min_turn = T.(policy.min_turn) + max_turn = T.(policy.max_turn) + upstream = T.(policy.upstream_max) + + # Upper reachable: minimum outflow (min turbine, no spill) + max upstream + upper_raw = x_prev .+ K .* inflow .- K .* min_turn .+ upstream + # Clamp to physical maximum volume + upper = min.(max_vol, upper_raw) + + # Lower reachable: maximum outflow (max turbine + max spill) + lower = if policy.spill_max === nothing + # Unlimited spill → can always dump down to min_vol + min_vol + else + spill_max = T.(policy.spill_max) + # Volume after maximum discharge and maximum spill + lower_raw = x_prev .+ K .* inflow .- K .* max_turn .- spill_max + # Clamp to physical minimum volume + max.(min_vol, lower_raw) + end + + # Ensure lower ≤ upper (numerical safety for edge cases like CHJ with max_vol=0) + upper = max.(upper, lower) + + return lower, upper +end + +""" + _cascade_upper_bounds(policy, target, inflow, x_prev) + +Compute the true reachable upper bound for downstream units given the actual +upstream targets. Returns a vector of upper bounds (Inf for units with no +upstream connections). + +# Documented assumptions +- **Single-level cascades**: the implied upstream release + ``R_u = K w_u + x_u - \\hat{x}_u`` omits the upstream unit's own incoming + cascade contribution, which is conservative (underestimates the release) + for multi-level chains. +- **Gradient through binding clamps**: this function is DIFFERENTIABLE, so a + binding clamp propagates ``\\partial / \\partial \\hat{x}_u = -1`` from the + implied release into the downstream target (turbine-only links additionally + pass through `min`, whose pullback selects the active branch). Units with no + incoming link take the constant `Inf` branch and carry no gradient, which is + exact because `min(raw_target, Inf) == raw_target`. +""" +function _cascade_upper_bounds(policy::HydroReachablePolicy, target, inflow, x_prev) + cascade = policy.cascade + T = eltype(target) + K = T(policy.K) + n = length(target) + isempty(cascade) && return fill(T(Inf), n) + + # Constant link metadata, gathered once. `_cascade_link_meta` is + # `@non_differentiable` so this gather never enters the pullback. + up, dn, turn_only, k_max_turn = _cascade_link_meta(policy, T) + min_turn = T.(policy.min_turn) + max_vol = T.(policy.max_vol) + + # Release implied by asking each upstream reservoir to end at its target. + release = K .* inflow[up] .+ x_prev[up] .- target[up] + positive_release = max.(zero(T), release) + # Turbine-only links cannot pass more than K·max_turn downstream. + max_contrib = ifelse.(turn_only, min.(k_max_turn, positive_release), positive_release) + + # One upper bound per LINK, expressed for its downstream reservoir. + link_upper = min.( + max_vol[dn], + x_prev[dn] .+ K .* inflow[dn] .- K .* min_turn[dn] .+ max_contrib, + ) + + # Reduce link-wise bounds to one bound per reservoir WITHOUT mutation (the + # previous `upper[d] = min(...)` loop is unreachable for reverse-mode AD): + # build a links × reservoirs matrix that holds `link_upper` in the column of + # the link's downstream reservoir and `Inf` elsewhere, then take a column + # minimum. Reservoirs with no incoming link get an all-`Inf` column and are + # left unchanged by the caller's `min.(raw_target, cascade_upper)`. + link_by_reservoir = ifelse.( + reshape(dn, :, 1) .== reshape(1:n, 1, :), + reshape(link_upper, :, 1), + T(Inf), + ) + return vec(minimum(link_by_reservoir; dims = 1)) +end + +""" + _cascade_link_meta(policy, T) -> (upstream, downstream, turn_only, k_max_turn) + +Flatten `policy.cascade` into per-link index and constant vectors. + +# Arguments +- `policy::HydroReachablePolicy`: policy carrying the cascade link list. +- `T::Type`: element type to which the float constants are converted. + +# Returns +- `(upstream, downstream, turn_only, k_max_turn)`: four length-`nlinks` + vectors — upstream/downstream reservoir positions, a turbine-only flag, and + the turbine-only contribution cap ``K \\cdot max\\_turn_u``. + +# Notes +Frozen topology metadata, constant in every differentiated quantity, so it is +declared `@non_differentiable` and never appears in the pullback of +[`_cascade_upper_bounds`](@ref). +""" +function _cascade_link_meta(policy::HydroReachablePolicy, ::Type{T}) where {T} + return ( + Int[c.upstream for c in policy.cascade], + Int[c.downstream for c in policy.cascade], + Bool[c.turn_only for c in policy.cascade], + T[c.K_max_turn for c in policy.cascade], + ) +end +ChainRulesCore.@non_differentiable _cascade_link_meta(::Any, ::Any) + +""" + (m::HydroReachablePolicy)(x) + +Forward pass: given input `x = [context; inflow₁..nHyd; x_prev₁..nHyd]`, produce +one-stage reachable reservoir targets. + +1. Split input into context, inflow, and previous state +2. Encode `[context; inflow]` through recurrent encoder, carrying state across stages +3. Combine encoder output with previous state via a sigmoid head → y_norm ∈ [0,1] +4. Compute reachable bounds [lower, upper] from physics (differentiable in `x_prev`) +5. Scale: target = lower + (upper - lower) × y_norm +6. Clamp downstream targets to cascade-aware upper bounds (differentiable) + +# Documented assumptions +- **Single-level cascades**: the cascade clamp uses the implied upstream release + ``R_u = K w_u + x_u - \\hat{x}_u``, which omits the upstream unit's own + incoming cascade contribution — conservative for multi-level chains. +- **Gradient through binding clamps**: reachable bounds and cascade clamps are + DIFFERENTIABLE; the reachable interval's dependence on `x_prev` and a binding + clamp's dependence on the upstream target both carry gradient. +- **Physically-infeasible edge case**: if the cascade upper bound falls below + the reachable lower bound, the clamped target may fall below `lower`. No + policy-level remedy exists in that case — the underlying problem is + infeasible. + +# Arguments +- `x`: concatenated input vector `[context..., inflow..., previous_state...]` + +# Returns +- `Vector`: target reservoir volumes, guaranteed within one-stage reachable set +""" +function (m::HydroReachablePolicy)(x) + # Split input: optional context first, then true inflow, then previous state. + # Physics bounds must use only the true inflow slice. + c_end = m.n_context + w_start = c_end + 1 + w_end = c_end + m.n_uncertainty + context = c_end == 0 ? x[1:0] : x[1:c_end] + inflow = x[w_start:w_end] + x_prev = x[w_end+1:end] + encoder_input = c_end == 0 ? inflow : vcat(context, inflow) + + # Encode inflow through the recurrent encoder, carrying state across calls. + # Cast to encoder precision for type stability (avoids Zygote codegen bugs). + T = DecisionRules._state_eltype(m.state) + encoded, new_state = DecisionRules._step_encoder(m.encoder, T.(encoder_input), m.state) + # Thread recurrent state to the next call + m.state = new_state + + # Raw output from combiner (sigmoid activation → values in [0, 1]) + y_norm = m.combiner(vcat(encoded, x_prev)) + + # Reachable interval from the current state and inflow. Both endpoints are + # affine in `x_prev`, and that dependence CARRIES GRADIENT — it is the term + # that propagates the adjoint from stage t back to stage t-1. + lower, upper = _hydro_reachable_bounds(m, inflow, x_prev) + + # Scale normalized output to the reachable interval [lower, upper] + raw_target = lower .+ (upper .- lower) .* y_norm + + # Clamp downstream targets to cascade-aware reachable bounds + if !isempty(m.cascade) + cascade_upper = _cascade_upper_bounds(m, raw_target, inflow, x_prev) + return min.(raw_target, cascade_upper) + end + return raw_target +end + +""" + Flux.reset!(m::HydroReachablePolicy) + +Reset the encoder's recurrent state to `Flux.initialstates`, e.g. before starting +a new rollout. The hydro bounds (min_vol, max_vol, etc.) are unchanged. +""" +function Flux.reset!(m::HydroReachablePolicy) + # Reinitialize recurrent state from the encoder's initial states + m.state = DecisionRules._init_recurrent_state(m.encoder) + return nothing +end + +""" + hydro_reachable_policy(hydro_meta, layers; encoder_type=Flux.LSTM, + spill_max=nothing, combiner_layers=Int[]) + +Create a [`HydroReachablePolicy`](@ref) from hydro metadata (as returned by +the 7th return value of `build_hydropowermodels`). + +The architecture mirrors [`state_conditioned_policy`](@ref): an LSTM encoder +processes inflows, then a feed-forward combiner produces normalized targets in +`[0, 1]`. These are scaled to the one-stage reachable interval. The combiner +uses sigmoid activation — this is mandatory and cannot be overridden. Set +`combiner_layers` to add hidden layers to the nonrecurrent state-conditioned +target map. This is the preferred way to depart from linear decision rules +without adding recurrence over the reservoir-state input. + +# Arguments +- `hydro_meta::NamedTuple`: hydro system metadata with fields `nHyd`, `min_vol`, + `max_vol`, `min_turn`, `max_turn`, `K`, `upstream_turn` +- `layers::Vector{Int}`: hidden layer sizes for the LSTM encoder + (e.g. `[128, 128]` for a 2-layer LSTM) +- `encoder_type`: recurrent layer/cell type (default: `Flux.LSTM`). Must support + `Flux.initialstates` and the stateful `(x, state) -> (output, new_state)` call +- `spill_max`: per-unit maximum spillage vector (`nothing` = unlimited spillage, + meaning `lower = min_vol` always) +- `combiner_layers::Vector{Int}`: hidden widths for the nonrecurrent target head + +# Returns +- `HydroReachablePolicy`: ready-to-train policy with sigmoid-bounded outputs + +# Examples +```julia +subproblems, _, _, _, _, _, hydro_meta = build_hydropowermodels( + case_dir, formulation_file; strict=true, optimizer=diff_opt +) +policy = hydro_reachable_policy(hydro_meta, [128, 128]) +policy_with_deep_state_head = hydro_reachable_policy( + hydro_meta, + [128, 128]; + combiner_layers=[256, 256], +) +``` + +See also: [`HydroReachablePolicy`](@ref), [`state_conditioned_policy`](@ref), +[`load_policy_weights!`](@ref) +""" +function hydro_reachable_policy( + hydro_meta::NamedTuple, + layers::Vector{Int}; + encoder_type=Flux.LSTM, + activation=stretchedsigmoid, + spill_max=nothing, + combiner_layers=Int[], + n_context::Int=0, +) + nHyd = hydro_meta.nHyd + # Validate layer sizes + isempty(layers) && throw(ArgumentError("layers must be non-empty")) + n_context >= 0 || throw(ArgumentError("n_context must be nonnegative")) + + # Build encoder: stack of recurrent cells processing [context; inflow]. + encoder_input_dim = nHyd + n_context + if length(layers) == 1 + # Single-layer encoder + encoder = DecisionRules._as_cell(encoder_type(encoder_input_dim => layers[1])) + else + # Multi-layer encoder: chain of recurrent cells + encoder_layers = [DecisionRules._as_cell(encoder_type(encoder_input_dim => layers[1]))] + for i in 1:(length(layers) - 1) + push!( + encoder_layers, + DecisionRules._as_cell(encoder_type(layers[i] => layers[i + 1])), + ) + end + encoder = Chain(encoder_layers...) + end + + activation in (sigmoid, stretchedsigmoid, hardsigmoidsafe) || + throw(ArgumentError("activation must map into [0, 1]")) + # The bounded output is scaled to [lower, upper] in the forward pass. + combiner = DecisionRules.dense_policy_head( + layers[end] + nHyd, + nHyd, + collect(Int, combiner_layers); + activation=activation, + ) + + # Pre-compute maximum upstream inflow contribution per unit: + # upstream_max[r] = Σ_{u ∈ upstream(r)} K × max_turn_u + K = hydro_meta.K + upstream_max = zeros(Float32, nHyd) + for (r, upstream_list) in enumerate(hydro_meta.upstream_turn) + for (u_pos, u_max_turn) in upstream_list + upstream_max[r] += Float32(K * u_max_turn) + end + end + + # Build cascade connections for target clamping + spill_dests = Dict{Int,Set{Int}}() + for (r, upstream_list) in enumerate(hydro_meta.upstream_spill) + for (u_pos, _) in upstream_list + push!(get!(spill_dests, u_pos, Set{Int}()), r) + end + end + cascade = CascadeLink[] + for (r, upstream_list) in enumerate(hydro_meta.upstream_turn) + for (u_pos, u_max_turn) in upstream_list + has_spill = haskey(spill_dests, u_pos) && r in spill_dests[u_pos] + push!(cascade, CascadeLink(r, u_pos, !has_spill, Float32(K * u_max_turn))) + end + end + for (r, upstream_list) in enumerate(hydro_meta.upstream_spill) + for (u_pos, _) in upstream_list + already = any(c -> c.downstream == r && c.upstream == u_pos, cascade) + already || push!(cascade, CascadeLink(r, u_pos, false, Float32(K * hydro_meta.max_turn[u_pos]))) + end + end + + # Validate spill_max dimensions if provided + if spill_max !== nothing && length(spill_max) != nHyd + throw(ArgumentError("spill_max length must be nHyd=$nHyd; got $(length(spill_max))")) + end + + return HydroReachablePolicy( + encoder, + combiner, + DecisionRules._init_recurrent_state(encoder), # initial recurrent state + n_context, # context dimensions prepended before inflow + nHyd, # n_uncertainty = nHyd (one inflow per unit) + nHyd, # n_state = nHyd (one reservoir per unit) + Float32.(hydro_meta.min_vol), # per-unit min volume + Float32.(hydro_meta.max_vol), # per-unit max volume + Float32.(hydro_meta.min_turn), # per-unit min turbine outflow + Float32.(hydro_meta.max_turn), # per-unit max turbine outflow + upstream_max, # pre-computed upstream contribution + spill_max === nothing ? nothing : Float32.(collect(spill_max)), # spill bounds + K, # water-balance conversion factor + cascade, # cascade connections for target clamping + ) +end + +""" + load_policy_weights!(policy::HydroReachablePolicy, state) + +Load encoder/combiner weights from a saved model state (e.g., from a +[`StateConditionedPolicy`](@ref) checkpoint). Hydro bounds are preserved. + +This enables warmstarting: train a `StateConditionedPolicy` with non-strict +subproblems, then load its encoder/combiner weights into a `HydroReachablePolicy` +for strict fine-tuning. + +# Arguments +- `policy::HydroReachablePolicy`: target policy (bounds are preserved) +- `state`: saved model state (from `Flux.state(model)` or JLD2 checkpoint) + +# Returns +- `policy`: the modified policy (mutated in place) + +See also: [`hydro_reachable_policy`](@ref) +""" +# Strip a `Recurrence`/`Flux.LSTM` wrapper from a saved encoder-state tree so it +# loads into DecisionRules.jl's BARE `LSTMCell` encoder (built via `_as_cell`, +# which rolls out with `_step_encoder`). Checkpoints trained by the ExaModels +# strict trainer save each encoder layer as `Flux.LSTM` -> layer state +# `(cell = (Wi, Wh, bias),)`; DR.jl's encoder layers are the inner cells, state +# `(Wi, Wh, bias)`. This is the state-tree mirror of `_as_cell`: unwrap the +# `cell` field of every layer so `Flux.loadmodel!` sees matching structures. The +# weights are identical; only the wrapper level differs. +_unwrap_encoder_cells(enc_state) = + hasproperty(enc_state, :layers) ? + (; layers = map(L -> (L isa NamedTuple && hasproperty(L, :cell)) ? L.cell : L, + enc_state.layers)) : + enc_state + +function load_policy_weights!(policy::HydroReachablePolicy, state) + # Load only the encoder and combiner weights, keeping hydro bounds unchanged. + # First try the structures as-saved; if the encoder is `Flux.LSTM`-wrapped + # (ExaModels-trained checkpoint) fall back to unwrapping the cell wrapper. + try + Flux.loadmodel!(policy.encoder, state.encoder) + Flux.loadmodel!(policy.combiner, state.combiner) + catch err + try + Flux.loadmodel!(policy.encoder, _unwrap_encoder_cells(state.encoder)) + Flux.loadmodel!(policy.combiner, state.combiner) + catch _ + throw(ArgumentError( + "Could not load HydroReachablePolicy weights. The checkpoint architecture " * + "must match encoder/head widths and n_context=$(policy.n_context); " * + "contextual policies require newly trained checkpoints. Original error: $err", + )) + end + end + return policy +end + +function load_policy_weights!(policy::DecisionRules.ContextualPolicy, state) + inner_state = hasproperty(state, :policy) ? getproperty(state, :policy) : state + load_policy_weights!(policy.policy, inner_state) + return policy +end + +""" + load_hydro_reachable_policy(checkpoint_path, hydro_meta, layers; + encoder_type=Flux.LSTM, spill_max=nothing, + combiner_layers=Int[]) + +Load a [`HydroReachablePolicy`](@ref) from a JLD2 checkpoint, reconstructing +the hydro bounds from `hydro_meta` (since JLD2 may not preserve exact types). + +# Arguments +- `checkpoint_path::String`: path to JLD2 file with `"model_state"` key +- `hydro_meta::NamedTuple`: hydro metadata from `build_hydropowermodels` +- `layers::Vector{Int}`: encoder hidden layer sizes (must match checkpoint) +- `encoder_type`: recurrent layer type (default: `Flux.LSTM`) +- `spill_max`: per-unit max spillage, or `nothing` for unlimited +- `combiner_layers::Vector{Int}`: hidden widths for the nonrecurrent target head + +# Returns +- `HydroReachablePolicy`: policy with loaded weights and fresh hydro bounds + +See also: [`hydro_reachable_policy`](@ref), [`load_policy_weights!`](@ref) +""" +function load_hydro_reachable_policy( + checkpoint_path::String, + hydro_meta::NamedTuple, + layers::Vector{Int}; + encoder_type=Flux.LSTM, + spill_max=nothing, + combiner_layers=Int[], + n_context::Int=0, +) + # Build fresh policy with correct bounds from hydro_meta + policy = hydro_reachable_policy(hydro_meta, layers; encoder_type=encoder_type, + spill_max=spill_max, + combiner_layers=combiner_layers, + n_context=n_context) + # Load saved weights into the fresh policy + model_state = JLD2.load(checkpoint_path, "model_state") + load_policy_weights!(policy, model_state) + return policy +end diff --git a/examples/HydroPowerModels/hydro_solution_schema.jl b/examples/HydroPowerModels/hydro_solution_schema.jl new file mode 100644 index 0000000..4a1e87b --- /dev/null +++ b/examples/HydroPowerModels/hydro_solution_schema.jl @@ -0,0 +1,512 @@ +#!/usr/bin/env julia + +# One schema for a full physical solution of the Bolivia stage problem, shared +# by every engine so their solutions can be differenced variable by variable. +# +# This file is byte-identical in DecisionRules.jl and DecisionRulesExa.jl. It +# depends on nothing but `Printf` and the standard library, so either package can +# include it without pulling in the other's environment. +# +# ── Why a schema at all ─────────────────────────────────────────────────────── +# +# Three different pieces of code build the same stage problem: HydroPowerModels +# (which the SDDP baseline drives, and from which `export_subproblem_mof.jl` +# serializes the JuMP/MAIN stage subproblems), the JuMP path that re-reads those +# serialized models, and the ExaModels builder used for GPU training. Agreement +# on the objective is not evidence that they agree as models — two different +# feasible sets can price the same operating point identically. The only +# sufficient check is that, given the SAME incoming state, the SAME inflow and +# the SAME reservoir target, every engine returns the SAME value for EVERY +# physical variable. That requires a common name for every variable, which is +# what this file fixes. +# +# ── Long format ─────────────────────────────────────────────────────────────── +# +# scenario,stage,class,index,value +# +# One row per scalar. Long rather than wide because the classes have different +# lengths (11 hydro units, 28 buses, 34 generators, 31 branches) and because a +# missing row is then an explicit absence rather than a silently empty column. +# +# ── Index conventions ───────────────────────────────────────────────────────── +# +# `index` is ALWAYS the case's own 1-based index, never a solver-internal +# position: +# +# * hydro classes are indexed 1..11 in `hydro.json` `Hydrogenerators` order; +# * bus, generator and branch classes use the `PowerModels.json` `index` field. +# For this case those run 1..28, 1..34 and 1..31 with no gaps, and the +# ExaModels builder sorts by the same index, so position and index coincide — +# `verify_index_convention` asserts that rather than assuming it; +# * scalar, per-stage quantities use index 0. +# +# Branch flows are split by ORIENTATION, not by the tuple JuMP happens to print: +# `p_fr` is the flow measured at the branch's `f_bus` end and `p_to` at its +# `t_bus` end. The serialized JuMP model names both ends `0_p[(l, i, j)]`, so +# the reader has to resolve `(i, j)` against the branch's own endpoints; getting +# this backwards would compare a branch's two ends to each other and could hide +# a real disagreement behind an apparent one, or vice versa. + +module HydroSolutionSchema + +using Printf + +# ── Classes ─────────────────────────────────────────────────────────────────── + +""" +Hydro-indexed classes, 1..nHyd in `hydro.json` order. + +`reservoir_in` is the incoming state of the stage and `reservoir_out` the +outgoing one; in strict mode `reservoir_out` is pinned to `target` by an +equality whose dual is `target_multiplier` — the quantity TS-DDR differentiates +through, so it is compared like any physical variable rather than treated as +diagnostics. +""" +const HYDRO_CLASSES = ( + "reservoir_in", "reservoir_out", "target", "inflow", "outflow", "spill", + "min_volume_violation", "min_outflow_violation", "target_multiplier", +) + +""" +Bus-indexed classes: voltage polar coordinates, the active-power slack, and the +NODAL generation aggregates. + +`pg_bus` / `qg_bus` are derived, not read from a solver: they are the sums of +`pg` / `qg` over the generators sitting at a bus (`augment_nodal!`). They are +carried because they, and not the per-generator dispatch, are what the AC nodal +balance determines. Six of this case's buses host several generators — bus 1 +hosts ten — and the balance constrains only their sum, so per-unit `qg` has a +null space that two solvers can land in differently while describing the same +operating point. Comparing the aggregates separates "the engines disagree about +the network" from "the engines split an indeterminate quantity differently". +""" +const BUS_CLASSES = ( + "vm", "va", "deficit", "pg_bus", "qg_bus", "price_active", "price_reactive", +) + +""" +Bus-indexed DUAL quantities: the locational marginal prices. + +`price_active` is the dual of a bus's active-power balance — the marginal cost +of serving one more per-unit of load there for one stage — and `price_reactive` +the dual of its reactive balance. They are the economic read-out of the +dispatch: what the policy's water decisions are actually worth on the network, +and where scarcity is binding. + +They exist ONLY as duals, so no primal recording substitutes for them, and they +come from the JuMP engine, which evaluates both policies against the same stage +model. + +UNITS AND SIGN, because both are easy to get wrong. The value is the dual of the +balance constraint AS STORED, whose normalized form is +`sum(p_arcs) - sum(pg) + gs*vm^2 == -sum(pd)`; the dual of that is the NEGATIVE +of the conventional locational marginal price, so a more negative number means +energy is more expensive. Its unit is objective units per per-unit injection per +stage — the case's own cost units, not USD/MWh. The meaningful reference on the +same scale is `ACTIVE_DEFICIT_COST = 6000`, the price of shedding a per-unit of +load for one stage: on this case the marginal energy price runs around 1600, so +shedding is roughly four times the cost of serving, which is why the deficit +variables sit at their bound. +""" +const PRICE_CLASSES = ("price_active", "price_reactive") + +"""Generator-indexed classes: active and reactive dispatch, per unit.""" +const GEN_CLASSES = ("pg", "qg") + +""" +Classes whose value is NOT determined by the model. + +`min_volume_violation` and `min_outflow_violation` are HydroPowerModels' free +relaxation slacks on the minimum-volume and minimum-outflow bounds. They carry +no objective coefficient and appear in no constraint other than their own +one-sided bound, so any sufficiently large value is optimal and two solvers can +return wildly different ones for the identical model. For this case both +minimums are zero, which makes the slacks inert as well as unpriced. + +They are still recorded and still compared — silently dropping a variable is +what this schema exists to prevent — but a difference in them is not evidence of +a model difference, and the parity report says so rather than letting a 1e12 +entry sit unexplained in a table of 1e-4 residuals. +""" +const UNPRICED_SLACK_CLASSES = ("min_volume_violation", "min_outflow_violation") + +"""Branch-indexed classes: active and reactive flow at each of the two ends.""" +const BRANCH_CLASSES = ("p_fr", "p_to", "q_fr", "q_to") + +"""Per-stage scalars, written with index 0.""" +const SCALAR_CLASSES = ("stage_objective", "cum_objective") + +"""Every class this schema knows about, in report order.""" +const ALL_CLASSES = ( + HYDRO_CLASSES..., BUS_CLASSES..., GEN_CLASSES..., BRANCH_CLASSES..., + SCALAR_CLASSES..., +) + +""" + class_group(class) -> String + +Which index convention a class uses: `"hydro"`, `"bus"`, `"gen"`, `"branch"` or +`"scalar"`. Used to label the parity report and to check that an index is in +range for its class. +""" +function class_group(class::AbstractString) + class in HYDRO_CLASSES && return "hydro" + class in BUS_CLASSES && return "bus" + class in GEN_CLASSES && return "gen" + class in BRANCH_CLASSES && return "branch" + class in SCALAR_CLASSES && return "scalar" + return error("unknown solution class: $class") +end + +# ── Writing ─────────────────────────────────────────────────────────────────── + +""" + SolutionWriter(path) + +Append-only writer for the long-format solution CSV at `path`. + +Floats are written with `repr`, i.e. the shortest decimal string that round-trips +to the same `Float64`. A parity gate that compares two engines at 1e-9 cannot +afford a printf-rounded value: the printed difference would be an artifact of +the formatting rather than of the models. + +Close it with `close(writer)`. +""" +mutable struct SolutionWriter + io::IOStream + rows::Int +end + +function SolutionWriter(path::AbstractString) + io = open(path, "w") + println(io, "scenario,stage,class,index,value") + return SolutionWriter(io, 0) +end + +Base.close(writer::SolutionWriter) = close(writer.io) + +""" + record!(writer, scenario, stage, class, index, value) -> Nothing + +Write one scalar. `class` must be a known class and `index` its case index +(0 for per-stage scalars). +""" +function record!( + writer::SolutionWriter, + scenario::Integer, + stage::Integer, + class::AbstractString, + index::Integer, + value::Real, +) + class_group(class) # validates + println(writer.io, scenario, ",", stage, ",", class, ",", index, ",", repr(Float64(value))) + writer.rows += 1 + return nothing +end + +""" + record_vector!(writer, scenario, stage, class, values) -> Nothing + +Write a whole class at once, taking `index` from the position in `values`. This +is correct exactly because the case's PowerModels indices are contiguous from 1 +(see `verify_index_convention`). +""" +function record_vector!( + writer::SolutionWriter, + scenario::Integer, + stage::Integer, + class::AbstractString, + values, +) + for (i, v) in enumerate(values) + record!(writer, scenario, stage, class, i, v) + end + return nothing +end + +""" + record_scalar!(writer, scenario, stage, class, value) -> Nothing + +Write a per-stage scalar at index 0. +""" +record_scalar!(writer, scenario, stage, class, value) = + record!(writer, scenario, stage, class, 0, value) + +# ── Reading ─────────────────────────────────────────────────────────────────── + +""" + read_solution(path) -> Dict{Tuple{Int,Int,String,Int},Float64} + +Load a long-format solution keyed by `(scenario, stage, class, index)`. + +A duplicate key is an error: it would mean the producer wrote the same variable +twice, and silently keeping the last value would hide whichever run was wrong. +""" +function read_solution(path::AbstractString) + isfile(path) || error("missing solution file: $path") + out = Dict{Tuple{Int,Int,String,Int},Float64}() + open(path) do io + header = readline(io) + strip(header) == "scenario,stage,class,index,value" || + error("$path is not a long-format solution file (header: $header)") + for line in eachline(io) + isempty(strip(line)) && continue + parts = split(line, ',') + length(parts) == 5 || error("malformed row in $path: $line") + key = ( + parse(Int, parts[1]), parse(Int, parts[2]), + String(parts[3]), parse(Int, parts[4]), + ) + haskey(out, key) && error("duplicate entry $key in $path") + out[key] = parse(Float64, parts[5]) + end + end + return out +end + +# ── Comparison ──────────────────────────────────────────────────────────────── + +""" +One class's worst disagreement between two solutions. + +`max_abs` / `max_rel` are the largest absolute and relative differences over +every `(scenario, stage, index)` the class covers; `at` names where the absolute +maximum occurred, and `left` / `right` are the two values there. `scale` is the +denominator used for the relative difference, `max(|a|, |b|, rel_floor)`, so a +variable that is zero in both engines cannot manufacture a relative difference. +""" +struct ClassDifference + class::String + group::String + n::Int + max_abs::Float64 + max_rel::Float64 + at::Tuple{Int,Int,Int} + left::Float64 + right::Float64 +end + +""" + compare_solutions(left, right; rel_floor=1.0, classes=ALL_CLASSES) + -> (differences, missing_keys) + +Difference two solutions class by class. + +`rel_floor` is the smallest magnitude used as a relative-difference denominator. +It defaults to 1.0 because the case's variables are per-unit quantities of order +1 (voltages ~1.0, flows and dispatch < 10, storage < 1); dividing a 1e-9 +disagreement by a 1e-12 spill value would report a "relative difference" of +1000 that means nothing physical. + +`missing_keys` lists every key present in exactly one of the two solutions. It +is returned rather than tolerated: the gate requires that no physical variable +be silently omitted, and an omitted variable shows up here rather than as a +smaller maximum. +""" +function compare_solutions( + left::AbstractDict, right::AbstractDict; + rel_floor::Real = 1.0, + classes = ALL_CLASSES, +) + wanted = Set(classes) + keys_left = Set(k for k in keys(left) if k[3] in wanted) + keys_right = Set(k for k in keys(right) if k[3] in wanted) + missing_keys = sort(collect(symdiff(keys_left, keys_right))) + + differences = ClassDifference[] + for class in classes + shared = [k for k in keys_left if k[3] == class && haskey(right, k)] + isempty(shared) && continue + max_abs = -Inf + max_rel = 0.0 + at = (0, 0, 0) + best_left = 0.0 + best_right = 0.0 + for k in shared + a = left[k] + b = right[k] + d = abs(a - b) + r = d / max(abs(a), abs(b), rel_floor) + max_rel = max(max_rel, r) + if d > max_abs + max_abs = d + at = (k[1], k[2], k[4]) + best_left = a + best_right = b + end + end + push!(differences, ClassDifference( + class, class_group(class), length(shared), + max_abs, max_rel, at, best_left, best_right, + )) + end + return differences, missing_keys +end + +""" + difference_table(differences) -> String + +Render `differences` as a fixed-width table: class, index group, number of +compared scalars, maximum absolute and relative difference, and the +`(scenario, stage, index)` at which the absolute maximum occurred together with +both values there. +""" +function difference_table(differences) + io = IOBuffer() + @printf(io, "%-22s %-7s %8s %14s %14s %-18s %-16s %-16s\n", + "class", "group", "n", "max|Δ|", "max relΔ", "at (scen,stage,idx)", + "left", "right") + println(io, "-"^126) + for d in differences + marker = d.class in UNPRICED_SLACK_CLASSES ? " *" : "" + @printf(io, "%-22s %-7s %8d %14.6e %14.6e (%5d,%4d,%4d) %16.9g %16.9g%s\n", + d.class, d.group, d.n, d.max_abs, d.max_rel, + d.at[1], d.at[2], d.at[3], d.left, d.right, marker) + end + if any(d.class in UNPRICED_SLACK_CLASSES for d in differences) + println(io) + println(io, " * unpriced free slack: zero objective coefficient, no other " * + "constraint, no upper bound —") + println(io, " the model does not determine its value, so a difference here " * + "is not a model difference.") + end + return String(take!(io)) +end + +""" + generator_bus(case_dir, parsefile) -> Dict{Int,Int} + +Generator index to the bus it injects at, from `PowerModels.json`. +""" +function generator_bus(case_dir::AbstractString, parsefile) + gens = parsefile(joinpath(case_dir, "PowerModels.json"))["gen"] + return Dict(Int(g["index"]) => Int(g["gen_bus"]) for g in values(gens)) +end + +""" + augment_nodal!(solution, gen_bus) -> solution + +Add the derived `pg_bus` / `qg_bus` entries to a loaded solution, in place. + +Derived here rather than written by each engine so the aggregation is one +implementation shared by both sides: an aggregate that disagreed only because +two producers summed differently would be worse than no aggregate at all. +""" +function augment_nodal!(solution::AbstractDict, gen_bus::AbstractDict) + totals = Dict{Tuple{Int,Int,String,Int},Float64}() + for ((scenario, stage, class, index), value) in solution + (class == "pg" || class == "qg") || continue + haskey(gen_bus, index) || error("generator $index is not in PowerModels.json") + key = (scenario, stage, class * "_bus", gen_bus[index]) + totals[key] = get(totals, key, 0.0) + value + end + merge!(solution, totals) + return solution +end + +""" + branch_orientation(case_dir, parsefile) -> Dict{Tuple{Int,Int,Int},Tuple{Bool,Int}} + +Map a serialized branch-flow subscript `(l, i, j)` onto `(is_from_end, l)`. + +HydroPowerModels/PowerModels names both ends of branch `l` `0_p[(l, i, j)]`, +distinguished only by whether `(i, j)` is `(f_bus, t_bus)` or its reverse. +Resolving that against `PowerModels.json` is what keeps a branch's two ends from +being silently compared to each other. + +`parsefile` is passed in (rather than importing JSON here) so this module stays +dependency-free and includable from either package. +""" +function branch_orientation(case_dir::AbstractString, parsefile) + branches = parsefile(joinpath(case_dir, "PowerModels.json"))["branch"] + out = Dict{Tuple{Int,Int,Int},Tuple{Bool,Int}}() + for branch in values(branches) + l = Int(branch["index"]) + f = Int(branch["f_bus"]) + t = Int(branch["t_bus"]) + out[(l, f, t)] = (true, l) + out[(l, t, f)] = (false, l) + end + return out +end + +""" + solution_class(name, orientation) -> Union{Nothing,Tuple{String,Int}} + +Map a serialized JuMP variable name onto `(class, index)` in this schema. + +Returns `nothing` for names that are not physical state: the `_`-prefixed JuMP +parameters the DecisionRules loader introduces for the incoming state and the +target, and SDDP's own `_subproblem`-internal bookkeeping variables (the +`theta`/`bellman` cost-to-go term, which is a value-function surrogate and not a +physical quantity — it exists in the SDDP subproblem and cannot exist in a +one-stage model). + +Every OTHER name raises: an unrecognized variable must be classified +deliberately, not dropped, or the gate's promise that no physical variable is +silently omitted would be void. +""" +function solution_class(name::AbstractString, orientation) + startswith(name, "_") && return nothing + name in ("bellman_term", "theta", "_theta") && return nothing + m = match( + r"^(0_va|0_vm|0_pg|0_qg|deficit|inflow|outflow|spill|min_volume_violation|min_outflow_violation)\[(\d+)\]$", + name, + ) + if m !== nothing + class = Dict( + "0_va" => "va", "0_vm" => "vm", "0_pg" => "pg", "0_qg" => "qg", + "deficit" => "deficit", "inflow" => "inflow", "outflow" => "outflow", + "spill" => "spill", + "min_volume_violation" => "min_volume_violation", + "min_outflow_violation" => "min_outflow_violation", + )[m.captures[1]] + return (class, parse(Int, m.captures[2])) + end + m = match(r"^reservoir\[(\d+)\]_(in|out)$", name) + m !== nothing && return ("reservoir_" * m.captures[2], parse(Int, m.captures[1])) + m = match(r"^0_(p|q)\[\((\d+), (\d+), (\d+)\)\]$", name) + if m !== nothing + key = ( + parse(Int, m.captures[2]), parse(Int, m.captures[3]), + parse(Int, m.captures[4]), + ) + haskey(orientation, key) || + error("branch subscript $key is not a branch of PowerModels.json") + from_end, l = orientation[key] + return (m.captures[1] * (from_end ? "_fr" : "_to"), l) + end + return error("unclassified variable name: $name") +end + +""" + verify_index_convention(case_dir) -> Nothing + +Assert that the `PowerModels.json` bus, generator and branch indices are exactly +`1:n`, so that a class written by position (`record_vector!`) carries the case's +own index. + +If a future case breaks this, every engine's solution would still be written, +but the comparison would silently align different physical objects. Failing here +is the alternative. +""" +function verify_index_convention(case_dir::AbstractString, parsefile) + power = parsefile(joinpath(case_dir, "PowerModels.json")) + for section in ("bus", "gen", "branch") + indices = sort([Int(v["index"]) for v in values(power[section])]) + indices == collect(1:length(indices)) || error( + "$section indices in PowerModels.json are not 1:$(length(indices)); " * + "the position-based solution schema would misalign them", + ) + end + return nothing +end + +export HYDRO_CLASSES, BUS_CLASSES, GEN_CLASSES, BRANCH_CLASSES, SCALAR_CLASSES, + PRICE_CLASSES, ALL_CLASSES, UNPRICED_SLACK_CLASSES, class_group, SolutionWriter, record!, + record_vector!, record_scalar!, read_solution, ClassDifference, + compare_solutions, difference_table, branch_orientation, solution_class, + generator_bus, augment_nodal!, verify_index_convention + +end # module diff --git a/examples/HydroPowerModels/load_hydropowermodels.jl b/examples/HydroPowerModels/load_hydropowermodels.jl index 613b425..1cda6d3 100644 --- a/examples/HydroPowerModels/load_hydropowermodels.jl +++ b/examples/HydroPowerModels/load_hydropowermodels.jl @@ -2,6 +2,36 @@ using JuMP using CSV using Tables using JSON +using StableRNGs + +# Paired evaluation protocol: at stage t of paired scenario s, EVERY method +# (SDDP.Historical, TS-DDR CPU/GPU rollouts) realizes joint inflow scenario +# `paired_scenario_indices(N, nCen)[t, s]`. StableRNG streams are stable +# across Julia versions, so the protocol is fully defined by this seed — no +# data file to distribute or track. +const PAIRED_SCENARIO_SEED = 20260706 +# The generated matrix ALWAYS has this many stage rows (the full SDDP horizon: +# 96 reported + 30 end-of-horizon buffer). Consumers that need fewer stages +# slice rows — they must never generate a smaller matrix, because arrays of +# different shapes consume the RNG stream differently and pairing across +# methods would silently break. +const PAIRED_NUM_STAGES = 126 + +""" + paired_scenario_indices(num_scenarios, nCen; + seed = PAIRED_SCENARIO_SEED) -> Matrix{Int} + +Deterministic paired-evaluation index matrix of fixed shape +`PAIRED_NUM_STAGES × num_scenarios`: entry `[t, s]` is uniform on `1:nCen` +(the per-stage joint inflow support, `nCen = ncol(inflows.csv) ÷ nHyd`). +Slice rows for shorter horizons; never regenerate at a different shape. +""" +function paired_scenario_indices( + num_scenarios::Integer, nCen::Integer; + seed::Integer = PAIRED_SCENARIO_SEED, +) + return rand(StableRNG(seed), 1:Int(nCen), PAIRED_NUM_STAGES, Int(num_scenarios)) +end function find_reservoirs_and_inflow(model::JuMP.Model) reservoir_in = find_variables(model, ["reservoir", "_in"]) @@ -27,6 +57,354 @@ function read_inflow(file::String, nHyd::Int; num_stages=nothing) return vector_inflows, nCen, num_stages end +""" + read_stage_hours(case_folder; default=1) -> Int + +Read the stage duration (hours per stage) from `case_folder/hydro.json`. + +`stage_hours` scales the water-balance conversion factor: the HydroPowerModels.jl +reservoir balance uses `K = 0.0036 · stage_hours`, where `0.0036 = 3600·1e-6` +converts a flow of m³/s to hm³ accumulated over one hour. A weekly stage therefore +declares `stage_hours = 168` (`K = 0.6048`). + +`stage_hours` must be baked into the exported MOF subproblems and passed to every +`create_param` that builds a HydroPowerModels model, so the JuMP/SDDP and Exa +engines share one water balance. Cases whose `hydro.json` predates the field get +`default` (1 ⇒ `K = 0.0036`), preserving backward compatibility. +""" +function read_stage_hours(case_folder::AbstractString; default::Int=1) + hydro_path = joinpath(case_folder, "hydro.json") + isfile(hydro_path) || return default + return Int(get(JSON.parsefile(hydro_path), "stage_hours", default)) +end + +# ── Per-stage demand support ────────────────────────────────────────────────── +# +# The stage subproblem MOF files ship with a single (historically 0.6-scaled) +# demand baked into the per-bus power-balance constraints. The functions below +# replace those baked constants stage by stage with the real seasonal demand +# from `demand.csv`, matching the SDDP baseline (`sddp/run_sddp_inconsistent.jl` +# `load_case_data`) and the GPU companion package DecisionRulesExa.jl +# (`load_demand` + `set_demand!` in its HydroPowerModels example). + +""" + read_load_data(pm_file) -> NamedTuple + +Parse the case's `PowerModels.json` for the load-to-bus mapping and the +default (nominal) load values needed for per-stage demand substitution. + +Loads are sorted by their PowerModels `index`, so column ``j`` of `demand.csv` +corresponds to the load with `index == j` (for Bolivia, load ``j`` sits at bus +``j``, ``j = 1, \\dots, 26``). + +# Arguments +- `pm_file::AbstractString`: path to `PowerModels.json`. + +# Returns +A `NamedTuple` with fields: +- `nbus::Int`: number of buses. +- `load_bus::Vector{Int}`: bus of each load, sorted by load index. +- `load_pd::Vector{Float64}`: nominal active demand per load (pu). +- `load_qd::Vector{Float64}`: nominal reactive demand per load (pu). +""" +function read_load_data(pm_file::AbstractString) + # Parse the PowerModels network description + pm = JSON.parsefile(pm_file) + # Number of buses (bus indices are 1-based and consecutive for Bolivia) + nbus = length(pm["bus"]) + # Loads sorted by PowerModels index so demand.csv column j == load index j + loads = sort!(collect(values(pm["load"])); by=l -> l["index"]) + load_bus = [Int(l["load_bus"]) for l in loads] + load_pd = [Float64(get(l, "pd", 0.0)) for l in loads] + load_qd = [Float64(get(l, "qd", 0.0)) for l in loads] + return (nbus=nbus, load_bus=load_bus, load_pd=load_pd, load_qd=load_qd) +end + +""" + read_demand(file, num_loads; num_stages) -> Matrix{Float64} + +Read a per-stage demand CSV (rows = stages of one annual cycle, columns = +loads by PowerModels index) and tile it cyclically over `num_stages` stages: + +```math +D^{\\mathrm{tiled}}_{t,j} = D_{((t-1) \\bmod n_{\\mathrm{rows}}) + 1,\\; j}, +\\qquad t = 1, \\dots, T. +``` + +This is the same cyclic tiling used by the SDDP baseline +(`sddp/run_sddp_inconsistent.jl`) and DecisionRulesExa.jl's `load_demand`, +so all methods see identical stage demands. + +# Arguments +- `file::AbstractString`: path to `demand.csv` (no header; pu units). +- `num_loads::Int`: expected number of columns (loads); a mismatch warns. +- `num_stages::Int`: horizon length ``T`` to tile to. + +# Returns +- `Matrix{Float64}` of size `num_stages × num_loads`. +""" +function read_demand(file::AbstractString, num_loads::Int; num_stages::Int) + # Read the raw stage × load demand table (no header) + raw = CSV.read(file, Tables.matrix; header=false) + nrows, ncols = size(raw) + # Guard against a stale demand file that does not match the network + ncols == num_loads || + @warn "demand file has $ncols columns but the case has $num_loads loads" + # Cyclic tiling: stage t uses annual-cycle row ((t-1) mod nrows) + 1 + demand = Matrix{Float64}(undef, num_stages, ncols) + for t in 1:num_stages, j in 1:ncols + demand[t, j] = Float64(raw[((t - 1) % nrows) + 1, j]) + end + return demand +end + +""" + find_bus_balance_constraints(model) -> (active, reactive) + +Locate the per-bus active and reactive power-balance constraints of an OPF +stage subproblem read from a MOF file, keyed by bus index. + +PowerModels writes both nodal balances as scalar equality constraints whose +normalized right-hand side carries (minus) the bus demand: + +```math +\\sum_{a \\in A_b} p_a - \\sum_{g \\in G_b} pg_g - \\mathrm{deficit}_b + = -pd_b, \\qquad +\\sum_{a \\in A_b} q_a - \\sum_{g \\in G_b} qg_g \\; (+\\, b^{sh}_b vm_b^2) + = -qd_b, +``` + +so per-stage demand substitution reduces to `set_normalized_rhs`. Constraints +are identified structurally (constraint names are not preserved by the MOF +round-trip): +- **active** balance at bus ``b``: the unique affine/quadratic equality + containing the load-shedding variable `deficit[b]` (HydroPowerModels adds + one per bus); +- **reactive** balance at bus ``b``: the unique affine/quadratic equality + containing a reactive branch-flow variable `0_q[(l, b, j)]` (the second + tuple element of a PowerModels arc is the bus whose balance it enters) and + no `deficit[...]` variable. + +The active-balance orientation is validated: the coefficient of `deficit[b]` +must be ``-1`` (the PowerModels/JuMP canonical form above); otherwise an +error is thrown rather than silently writing a wrong-signed demand. + +# Arguments +- `model::JuMP.Model`: a stage subproblem read from the MOF file. + +# Returns +- `(active, reactive)`: two `Dict{Int,JuMP.ConstraintRef}` mapping bus index + to its balance constraint. `reactive` is empty for formulations without + reactive balances (e.g. DC). +""" +function find_bus_balance_constraints(model::JuMP.Model) + active = Dict{Int,JuMP.ConstraintRef}() + reactive = Dict{Int,JuMP.ConstraintRef}() + # Reactive branch-flow (arc) variable name: 0_q[(line, from_bus, to_bus)] + arc_regex = r"^0_q\[\((\d+), (\d+), (\d+)\)\]$" + # Scan affine and quadratic equalities (nonlinear AC flow-definition rows + # are ScalarNonlinearFunction and are correctly excluded by these types) + for F in (JuMP.AffExpr, JuMP.QuadExpr) + for con in JuMP.all_constraints(model, F, MOI.EqualTo{Float64}) + func = JuMP.constraint_object(con).func + # Affine part of the function (QuadExpr wraps an AffExpr) + aff = F === JuMP.QuadExpr ? func.aff : func + # Active balance: contains the bus load-shedding variable deficit[b] + found_deficit = false + for (var, coef) in aff.terms + vname = JuMP.name(var) + if startswith(vname, "deficit[") + # Bus index from the variable name "deficit[b]" + bus = parse(Int, vname[(length("deficit[") + 1):(end - 1)]) + # Validate canonical orientation so RHS = -pd is correct + coef ≈ -1.0 || error( + "deficit[$bus] enters its balance with coefficient " * + "$coef (expected -1); demand substitution would be " * + "wrong-signed — regenerate the MOF file", + ) + active[bus] = con + found_deficit = true + break + end + end + found_deficit && continue + # Reactive balance: contains a q-arc variable; its second tuple + # element is the bus whose balance this constraint expresses + for (var, _) in aff.terms + m = match(arc_regex, JuMP.name(var)) + if !isnothing(m) + reactive[parse(Int, m.captures[2])] = con + break + end + end + end + end + return active, reactive +end + +""" + set_bus_demand!(active, reactive, pd_bus, qd_bus) -> Nothing + +Overwrite the demand baked into the per-bus balance constraints of one stage +subproblem. For each bus ``b`` the normalized right-hand side is set to + +```math +\\mathrm{rhs}^{P}_b = -pd_b, \\qquad \\mathrm{rhs}^{Q}_b = -qd_b, +``` + +matching the PowerModels canonical balance orientation validated by +[`find_bus_balance_constraints`](@ref). Buses absent from a dictionary (e.g. +no reactive balance in DC formulations) are skipped. + +# Arguments +- `active::Dict{Int,JuMP.ConstraintRef}`: bus → active balance constraint. +- `reactive::Dict{Int,JuMP.ConstraintRef}`: bus → reactive balance constraint. +- `pd_bus::Vector{Float64}`: per-bus active demand (pu) for this stage. +- `qd_bus::Vector{Float64}`: per-bus reactive demand (pu) for this stage. +""" +function set_bus_demand!( + active::Dict{Int,JuMP.ConstraintRef}, + reactive::Dict{Int,JuMP.ConstraintRef}, + pd_bus::Vector{Float64}, + qd_bus::Vector{Float64}, +) + # Active balance: rhs = -pd (canonical orientation, validated at discovery) + for (bus, con) in active + JuMP.set_normalized_rhs(con, -pd_bus[bus]) + end + # Reactive balance: rhs = -qd (same exporter, same orientation) + for (bus, con) in reactive + JuMP.set_normalized_rhs(con, -qd_bus[bus]) + end + return nothing +end + +""" + set_load_deficit_cost!(model, deficit_cost) -> Nothing + +Set the objective coefficient of every per-bus load-shedding variable +`deficit[b]` to `deficit_cost`: + +```math +\\text{objective} \\mathrel{+}= c_{\\mathrm{def}} \\sum_b \\mathrm{deficit}_b, +``` + +replacing the cost baked into the MOF file (historically +``60\\,\\\$/\\mathrm{MWh} \\times \\mathrm{baseMVA}\\,100 = 6{,}000`` per pu). +The paper recipe uses ``c_{\\mathrm{def}} = 10^5``, matching +DecisionRulesExa.jl's `deficit_cost` (a low shedding cost lets the solver +serve the seasonal peak by shedding load instead of storing water). + +Must be called **after** [`create_deficit!`](@ref) in non-strict mode: that +function derives `:auto` target penalties from the maximum objective +coefficient, which must keep its historical (pre-override) value. + +# Arguments +- `model::JuMP.Model`: stage subproblem containing `deficit[b]` variables. +- `deficit_cost::Real`: load-shedding cost per pu (``10^5`` in the paper). +""" +function set_load_deficit_cost!(model::JuMP.Model, deficit_cost::Real) + for var in JuMP.all_variables(model) + # Only the per-bus load-shedding variables named "deficit[b]" + if startswith(JuMP.name(var), "deficit[") + JuMP.set_objective_coefficient(model, var, Float64(deficit_cost)) + end + end + return nothing +end + +""" + build_hydropowermodels(case_folder, subproblem_file; num_stages, penalty, penalty_l1, + penalty_l2, optimizer, strict, demand_file, load_scaler, + deficit_cost) -> (subproblems, state_params_in, + state_params_out, uncertainty_samples, initial_state, max_volume, + hydro_meta) + +Build multi-stage hydro power subproblems from a case folder containing `hydro.json`, +`inflows.csv`, and a MOF subproblem file. Each stage gets its own JuMP model with +parameterized incoming state, outgoing target (with or without deficit slack), and +uncertainty (inflow) samples. + +# Per-stage demand and deficit cost (parity with SDDP / DecisionRulesExa.jl) + +When the case folder contains `demand.csv` (or `demand_file` points to one), +the demand baked into the MOF file (historically ``0.6 \\times`` the +`PowerModels.json` loads) is **replaced stage by stage**: the active demand of +load ``j`` at stage ``t`` is the cyclically tiled CSV entry + +```math +pd_{t,j} = s \\cdot D_{((t-1) \\bmod n_{\\mathrm{rows}}) + 1,\\; j}, +``` + +with `load_scaler` ``s`` (default 1 — the real seasonal demand, no 0.6 +scaler), and the reactive demand is the nominal `PowerModels.json` value +``qd_j`` scaled by the same ``s``. This matches the SDDP baseline +(`sddp/run_sddp_inconsistent.jl` `load_case_data`) and DecisionRulesExa.jl +(`load_demand` with `load_scaler=1.0`). Without a demand file the baked MOF +demand is left untouched (historical behavior). + +Independently, `deficit_cost` (default ``10^5``, the paper recipe shared with +DecisionRulesExa.jl) overrides the objective coefficient of the per-bus +load-shedding variables `deficit[b]`; pass `nothing` to keep the baked +coefficient (historically 6,000 per pu). The override is applied **after** +[`create_deficit!`](@ref) so `:auto` target penalties keep their historical +value. + +When `strict=true`, the outgoing state is bound to the target via a hard equality +constraint (`reservoir_out == target`) with **no deficit variables** and **no penalty +term**. The dual of this equality is the clean shadow price ∂Q/∂target — pure economic +signal without penalty noise. This requires a feasibility-guaranteeing policy (e.g. +[`HydroReachablePolicy`]) to avoid infeasible subproblems. + +When `strict=false` (default), deficit variables are created via [`create_deficit!`](@ref) +and penalized in the objective, allowing the solver to deviate from the target. + +# Arguments +- `case_folder::AbstractString`: path to the case directory (must contain `hydro.json` + and `inflows.csv`) +- `subproblem_file::AbstractString`: MOF filename for the stage subproblem (e.g. + `"ACPPowerModel.mof.json"`) +- `num_stages`: number of stages (default: number of rows in `inflows.csv`) +- `penalty`: legacy L1 penalty coefficient (use `penalty_l1`/`penalty_l2` instead) +- `penalty_l1`: L1 norm penalty coefficient, or `:auto` +- `penalty_l2`: L2 squared norm penalty coefficient, or `:auto` +- `optimizer`: optimizer factory for DiffOpt, e.g. `() -> DiffOpt.diff_optimizer(...)` +- `strict::Bool=false`: if `true`, use hard equality target constraints (no deficit) +- `demand_file=:auto`: per-stage demand CSV. `:auto` uses + `case_folder/demand.csv` when it exists; `nothing` disables the substitution + (keep the demand baked into the MOF); a path string forces a specific file +- `load_scaler::Real=1.0`: scaler ``s`` applied to both the per-stage active + demand and the nominal reactive demand when a demand file is in effect + (1.0 = real seasonal demand; only used with a demand file) +- `deficit_cost=1e5`: objective coefficient of the per-bus load-shedding + variables `deficit[b]`, or `nothing` to keep the baked MOF coefficient + +# Returns +A 7-tuple `(subproblems, state_params_in, state_params_out, uncertainty_samples, +initial_state, max_volume, hydro_meta)` where: +- `subproblems::Vector{JuMP.Model}`: one JuMP model per stage +- `state_params_in::Vector{Vector{Any}}`: incoming state parameters per stage +- `state_params_out::Vector{Vector{Tuple{Any,VariableRef}}}`: `(parameter, variable)` + tuples for outgoing state per stage +- `uncertainty_samples`: joint inflow scenarios per stage +- `initial_state::Vector{Float64}`: initial reservoir volumes +- `max_volume::Vector{Float64}`: maximum reservoir volumes +- `hydro_meta::NamedTuple`: hydro system metadata for policy construction (see below) + +## `hydro_meta` fields +- `nHyd::Int`: number of hydro units +- `min_vol`, `max_vol`: per-unit volume bounds +- `min_turn`, `max_turn`: per-unit turbine outflow bounds +- `initial_volume`: initial reservoir volumes +- `downstream_turn`, `downstream_spill`: downstream connectivity (by hydro index) +- `upstream_turn`: `Vector{Vector{Tuple{Int,Float64}}}` — for each unit, list of + `(upstream_array_pos, upstream_max_turn)` pairs feeding into it +- `upstream_spill`: same structure for spill connections +- `K::Float64`: water-balance conversion factor from flow units to volume units +- `production_factor`: per-unit production factors + +See also: [`create_deficit!`](@ref), [`variable_to_parameter`](@ref) +""" function build_hydropowermodels( case_folder::AbstractString, subproblem_file::AbstractString; @@ -35,15 +413,131 @@ function build_hydropowermodels( penalty_l1=nothing, penalty_l2=nothing, optimizer=nothing, + strict::Bool=true, + demand_file=nothing, + load_scaler::Real=0.6, + deficit_cost=6000.0, ) - hydro_file = JSON.parsefile(joinpath(case_folder, "hydro.json"))["Hydrogenerators"] + # Parse the hydro system data file + hydro_json = JSON.parsefile(joinpath(case_folder, "hydro.json")) + hydro_file = hydro_json["Hydrogenerators"] nHyd = length(hydro_file) + # Extract water-balance conversion factor K from the MOF model's hydro_balance + # constraint. K = 0.0036·stage_hours converts flow (m³/s) to volume (hm³) over a + # `stage_hours`-long stage, and is baked into the MOF at export time (via + # `create_param(stage_hours=…)` → HydroPowerModels `constraint_hydro_balance`). + _tmp_model = JuMP.read_from_file( + joinpath(case_folder, subproblem_file); use_nlp_block=false + ) + _hb_con = JuMP.constraint_by_name(_tmp_model, "hydro_balance[1]") + _hb_func = JuMP.constraint_object(_hb_con).func + _inflow_var = first(filter( + v -> occursin("inflow", JuMP.name(v)), JuMP.all_variables(_tmp_model) + )) + K = abs(JuMP.coefficient(_hb_func, _inflow_var)) + # Fail-closed guard against a STALE MOF: the exported subproblem's baked-in K + # must match 0.0036·stage_hours declared by this case's hydro.json. A mismatch + # means the MOF was generated for a different stage duration (e.g. a pre-168h + # file) and would silently apply the wrong water balance. Backward compatible: + # cases without stage_hours default to 1 (K = 0.0036). + _stage_hours = read_stage_hours(case_folder) + _K_expected = 0.0036 * _stage_hours + if !isapprox(K, _K_expected; rtol=1e-6) + error( + "Water-balance mismatch for $(subproblem_file): MOF hydro_balance " * + "coefficient K=$(K) but hydro.json stage_hours=$(_stage_hours) implies " * + "K=0.0036·$(_stage_hours)=$(_K_expected). Regenerate the MOF from the " * + "current PowerModels.json with create_param(stage_hours=$(_stage_hours)).", + ) + end + # Read historical inflow scenarios from CSV vector_inflows, nCen, num_stages = read_inflow( joinpath(case_folder, "inflows.csv"), nHyd; num_stages=num_stages ) - initial_state = [hydro["initial_volume"] for hydro in hydro_file] + # Extract volume bounds max_volume = [hydro["max_volume"] for hydro in hydro_file] + min_volume = [hydro["min_volume"] for hydro in hydro_file] + # Initial volumes clamped into [min_vol, max_vol] (parity with + # DecisionRulesExa.jl): Bolivia's CHJ unit has max_volume = 0 and a + # denormal ~1e-316 initial_volume in hydro.json, which would sit above its + # upper bound; clamping maps it (and any other out-of-bounds value) onto + # the feasible box, so x0 is always a feasible reservoir state. + initial_state = [ + clamp(hydro["initial_volume"], min_volume[i], max_volume[i]) + for (i, hydro) in enumerate(hydro_file) + ] + # ── Per-stage demand (parity with SDDP + DecisionRulesExa.jl) ───────────── + # Canonical MAIN uses the 0.6-scaled demand baked into the verified MOF. + # A noncanonical external demand overlay must be requested explicitly. + resolved_demand_file = demand_file + # Per-stage per-bus active demand [num_stages × nbus] and constant per-bus + # reactive demand [nbus], both already scaled by load_scaler; or nothing. + pd_bus, qd_bus = if isnothing(resolved_demand_file) + nothing, nothing + else + # Load → bus mapping and nominal reactive demand from PowerModels.json + load_data = read_load_data(joinpath(case_folder, "PowerModels.json")) + # Active demand per load, tiled cyclically over the horizon + demand = read_demand( + resolved_demand_file, length(load_data.load_bus); num_stages=num_stages + ) + # Aggregate loads onto buses: pd_bus[t, b] = s · Σ_{j: bus(j)=b} D[t, j] + _pd = zeros(Float64, num_stages, load_data.nbus) + for (j, bus) in enumerate(load_data.load_bus) + j > size(demand, 2) && break + for t in 1:num_stages + _pd[t, bus] += load_scaler * demand[t, j] + end + end + # Reactive demand stays at the (scaled) nominal PowerModels.json value: + # qd_bus[b] = s · Σ_{j: bus(j)=b} qd_j (SDDP's set_active_demand! + # touches only pd; DecisionRulesExa uses default_bus_reactive_demand) + _qd = zeros(Float64, load_data.nbus) + for (j, bus) in enumerate(load_data.load_bus) + _qd[bus] += load_scaler * load_data.load_qd[j] + end + _pd, _qd + end + + # Build upstream connectivity: for each unit, who feeds into it? + # The hydro.json stores downstream references; we invert them here. + # index_to_pos maps the hydro "index" field to the array position (1-based) + index_to_pos = Dict(hydro["index"] => i for (i, hydro) in enumerate(hydro_file)) + # upstream_turn[r] = [(upstream_array_pos, upstream_max_turn), ...] + upstream_turn = [Tuple{Int,Float64}[] for _ in 1:nHyd] + # upstream_spill[r] = [(upstream_array_pos, Inf), ...] — spill is unbounded + upstream_spill = [Tuple{Int,Float64}[] for _ in 1:nHyd] + for (i, hydro) in enumerate(hydro_file) + # Turbine outflow from unit i feeds into each downstream unit + for ds_idx in hydro["downstream_turn"] + ds_pos = index_to_pos[ds_idx] + push!(upstream_turn[ds_pos], (i, hydro["max_turn"])) + end + # Spillage from unit i feeds into each downstream unit + for ds_idx in hydro["downstream_spill"] + ds_pos = index_to_pos[ds_idx] + push!(upstream_spill[ds_pos], (i, Inf)) + end + end + + # Assemble hydro metadata for policy construction (e.g. HydroReachablePolicy) + hydro_meta = ( + nHyd = nHyd, + min_vol = min_volume, + max_vol = max_volume, + min_turn = [hydro["min_turn"] for hydro in hydro_file], + max_turn = [hydro["max_turn"] for hydro in hydro_file], + initial_volume = initial_state, + downstream_turn = [hydro["downstream_turn"] for hydro in hydro_file], + downstream_spill = [hydro["downstream_spill"] for hydro in hydro_file], + upstream_turn = upstream_turn, + upstream_spill = upstream_spill, + K = K, + production_factor = [hydro["production_factor"] for hydro in hydro_file], + ) + + # Allocate per-stage containers subproblems = Vector{JuMP.Model}(undef, num_stages) state_params_in = Vector{Vector{Any}}(undef, num_stages) state_params_out = Vector{Vector{Tuple{Any,VariableRef}}}(undef, num_stages) @@ -52,6 +546,7 @@ function build_hydropowermodels( ) for t in 1:num_stages + # Read the stage subproblem from MOF file subproblems[t] = JuMP.read_from_file( joinpath(case_folder, subproblem_file); use_nlp_block=false ) @@ -59,25 +554,66 @@ function build_hydropowermodels( if !isnothing(optimizer) set_optimizer(subproblems[t], optimizer) end - norm_deficit, _deficit = create_deficit!( - subproblems[t], - nHyd; - penalty=penalty, - penalty_l1=penalty_l1, - penalty_l2=penalty_l2, - ) - # delete fix constraints + + # Replace the baked MOF demand with this stage's seasonal demand: + # active balance rhs = -pd_bus[t, b], reactive balance rhs = -qd_bus[b] + if !isnothing(pd_bus) + active_cons, reactive_cons = find_bus_balance_constraints(subproblems[t]) + set_bus_demand!(active_cons, reactive_cons, vec(pd_bus[t, :]), qd_bus) + end + + if strict + # Strict mode: no deficit variables, no penalty — hard equality + # reservoir_out[i] == target[i] enforced directly + else + # Default mode: create deficit variables with penalty + norm_deficit, _deficit = create_deficit!( + subproblems[t], + nHyd; + penalty=penalty, + penalty_l1=penalty_l1, + penalty_l2=penalty_l2, + ) + end + + # Override the load-shedding cost AFTER create_deficit! so that :auto + # target penalties (max |objective coefficient| at call time) keep the + # historical baked value instead of picking up the 1e5 override. + if !isnothing(deficit_cost) + set_load_deficit_cost!(subproblems[t], deficit_cost) + end + + # Delete fix constraints (fixed-value equality constraints on variables) for con in JuMP.all_constraints(subproblems[t], VariableRef, MOI.EqualTo{Float64}) delete(subproblems[t], con) end + # Identify reservoir and inflow variables by name pattern state_params_in[t], state_param_out, inflow = find_reservoirs_and_inflow( subproblems[t] ) + # Convert incoming state variables to parameters state_params_in[t] = variable_to_parameter.(subproblems[t], state_params_in[t]) - state_params_out[t] = [ - variable_to_parameter(subproblems[t], state_param_out[i]; deficit=_deficit[i]) - for i in 1:nHyd - ] + + if strict + # Strict mode: hard equality constraint (no deficit slack) + # variable_to_parameter without deficit creates: reservoir_out[i] == parameter + # Returns just the parameter; we manually pair it with the variable + state_params_out[t] = [ + let param = variable_to_parameter(subproblems[t], state_param_out[i]) + (param, state_param_out[i]) + end + for i in 1:nHyd + ] + else + # Default mode: variable_to_parameter with deficit returns (parameter, variable) + state_params_out[t] = [ + variable_to_parameter( + subproblems[t], state_param_out[i]; deficit=_deficit[i] + ) + for i in 1:nHyd + ] + end + # Joint scenarios: all hydro units share the same scenario index ω, # preserving the spatial correlation in the historical inflow data. inflow_params = [variable_to_parameter(subproblems[t], inflow[i]) for i in 1:nHyd] @@ -90,7 +626,7 @@ function build_hydropowermodels( return subproblems, state_params_in, state_params_out, uncertainty_samples, initial_state, - max_volume + max_volume, hydro_meta end function ensure_feasibility_cap(state_out, state_in, uncertainty, max_volume) diff --git a/examples/HydroPowerModels/plot_hydro_results.jl b/examples/HydroPowerModels/plot_hydro_results.jl new file mode 100644 index 0000000..48dfa08 --- /dev/null +++ b/examples/HydroPowerModels/plot_hydro_results.jl @@ -0,0 +1,646 @@ +#!/usr/bin/env julia + +# Publication figures for the Bolivia hydro case study. +# +# Every figure is generated from the compact evidence committed under +# `results/`, so `julia --project plot_hydro_results.jl` reproduces the +# published assets deterministically without re-running training, evaluation, or +# anything on a GPU. +# +# Produces, in `docs/src/assets/`: +# +# hydro_training_history.png the from-scratch training run +# hydro_cost_distributions.png absolute cost densities, both policies +# hydro_paired_differences.png paired TS-DDR - SDDP differences, zero marked +# hydro_stagewise_physical.png where the cost difference is actually incurred +# hydro_energy_price.png the mean nodal energy price, week by week +# +# ── The training figure, and the mistakes it is built to avoid ──────────────── +# +# Three quantities live on this run and they are NOT interchangeable: +# +# * the STOCHASTIC TRAINING LOSS — one noisy sample of the 126-stage +# deterministic-equivalent objective per update, over `nt` freshly sampled +# inflow trajectories; +# * the 126-stage TRAINING OBJECTIVE per epoch — the same quantity averaged +# over an epoch's samples; +# * the 96-stage FIXED-PANEL ROLLOUT — the ten common-random-number scenarios +# on which checkpoints are actually SELECTED. +# +# They differ in horizon (126 vs 96), in sampling (fresh vs fixed), and in level +# by tens of thousands. Plotting them on one axis invites exactly the error of +# reading a drop in a noisy training sample as progress on the selection metric, +# so they are drawn in SEPARATE PANELS with their own axes. +# +# The raw training loss is drawn faintly and smoothed. The smoothing window is a +# fixed number of SAMPLED TRAJECTORIES, not of updates: `nt` changes between +# stages (16 -> 24), so a fixed-update window would average four thousand +# trajectories in one stage and six thousand in another and the curve's noise +# level would change for a reason that has nothing to do with learning. The +# smoothing RESETS at each restart boundary — a restart re-initialises the +# optimizer and the learning-rate phase, and carrying an average across it would +# invent a transition that did not happen. +# +# The x-axis is ACTIVE WALL TIME, cumulative across the selected lineage. Update +# count would hide that the stages have different per-update costs. +# +# Only the SELECTED lineage is drawn (coldB -> C1 -> C3). The rejected C2 branch +# is deliberately absent from the curve; it is reported in the text and in +# `results/rejected_branch_C2.csv` as discarded search work. The final paired-500 +# result is NOT a point on this figure: it is a different, larger evaluation and +# appears in its own figures. + +using CSV, DataFrames +using JSON +using Plots +using Printf +using Statistics + +const HYDRO_DIR = @__DIR__ +const RESULTS = joinpath(HYDRO_DIR, "results") +const ASSETS = normpath(joinpath(HYDRO_DIR, "..", "..", "docs", "src", "assets")) +mkpath(ASSETS) + +# Okabe-Ito, a validated colour-vision-deficiency-safe set. The assignment +# follows the ENTITY and never changes between figures: SDDP is green, +# TS-DDR blue, and neutral ink is grey. +const C_SDDP = colorant"#009E73" +const C_TSDDR = colorant"#0072B2" +const C_RAW = colorant"#0072B2" +const C_INK = colorant"#4D4D4D" +const C_ACCENT = colorant"#D55E00" + +# Smoothing window for the stochastic training loss, in SAMPLED TRAJECTORIES. +# 8,000 is ~20 updates at nt = 16 and ~13 at nt = 24: enough to see through the +# sample noise, short enough to keep a real change visible. +const SMOOTH_TRAJECTORIES = 8_000 + +""" + phase_label(stage) -> String + +Display name for a training phase. + +The recorded evidence keys phases by the identifiers the original run used. +Those are lab-notebook tags: they carry no meaning to a reader and, worse, they +read as a search over many attempts. A published figure names phases by their +position in the schedule; the identifiers stay in the record, where they are +what actually indexes the data. +""" +phase_label(stage) = get(PHASE_LABELS, stage, stage) + +const PHASE_LABELS = Dict("coldB" => "phase 1", "C1" => "phase 2", "C3" => "phase 3") + +""" + gaussian_kde(samples; npoints=512) -> (xs, density) + +Gaussian kernel density estimate with Silverman's rule-of-thumb bandwidth + +```math +h = 0.9 \\, \\min(\\hat\\sigma, \\mathrm{IQR}/1.34) \\, n^{-1/5}, +``` + +evaluated on an even grid spanning the sample range padded by three bandwidths +so the tails fall smoothly to zero inside the plot. +""" +function gaussian_kde(samples::AbstractVector{<:Real}; npoints::Int = 512) + n = length(samples) + sigma = std(samples) + iqr = quantile(samples, 0.75) - quantile(samples, 0.25) + h = max(0.9 * min(sigma, iqr / 1.34) * n^(-1 / 5), 1e-9 * max(abs(mean(samples)), 1.0)) + xs = range(minimum(samples) - 3h, maximum(samples) + 3h; length = npoints) + dens = [sum(exp(-0.5 * ((x - s) / h)^2) for s in samples) / (n * h * sqrt(2pi)) for x in xs] + return collect(xs), dens +end + +""" + trajectory_smooth(times, values, nt, window) -> (times, smoothed) + +Trailing mean of `values` over the most recent `window` SAMPLED TRAJECTORIES, +where update `i` contributes `nt[i]` trajectories. + +Returned aligned with `times`. The first points average fewer trajectories than +the window, which is unavoidable and visible: the curve simply starts where the +data do. +""" +function trajectory_smooth(times, values, nt, window::Real) + n = length(values) + out = similar(values, Float64) + for i in 1:n + total = 0.0 + acc = 0.0 + weight = 0.0 + j = i + while j >= 1 && total < window + total += nt[j] + acc += values[j] * nt[j] + weight += nt[j] + j -= 1 + end + out[i] = acc / weight + end + return times, out +end + +""" + load_training() -> (DataFrame, Dict) + +The selected lineage's training history and its time accounting. + +`_runtime` in the raw history is per-STAGE. The lineage's active time is +cumulative, so each stage is offset by the total active time of the stages +before it, taken from `lineage_accounting.json` — the same numbers the reported +time-to-policy uses, rather than a second derivation of them. +""" +function load_training() + history = CSV.read(joinpath(RESULTS, "training_history.csv"), DataFrame) + accounting = JSON.parsefile(joinpath(RESULTS, "lineage_accounting.json")) + selected = [s for s in accounting["selected_ancestry"] if s != "random initialisation"] + per_stage = accounting["components"]["per_stage"] + + offset = 0.0 + frames = DataFrame[] + for stage in selected + rows = history[history.stage .== stage, :] + rows = copy(rows) + rows.active_seconds = rows[!, "_runtime"] .+ offset + push!(frames, rows) + offset += per_stage[stage]["active_seconds"] + end + return vcat(frames...), accounting +end + +# ── Figure 1: the from-scratch training run ─────────────────────────────────── + +function figure_training() + history, accounting = load_training() + selected = [s for s in accounting["selected_ancestry"] if s != "random initialisation"] + per_stage = accounting["components"]["per_stage"] + + # Restart boundaries: the cumulative active time at which each stage ended. + boundaries = Float64[] + running = 0.0 + for stage in selected[1:(end - 1)] + running += per_stage[stage]["active_seconds"] + push!(boundaries, running / 3600) + end + + loss = dropmissing(history, "metrics/training_loss") + panel = dropmissing(history, "metrics/rollout_objective_no_target_penalty") + epochs = dropmissing(history, "metrics/epoch_objective") + + # Reserve empty bands above and below the data: the phase annotations live in + # the upper one and the legend in the lower right, so neither can land on the + # curves or on each other. Placing both at :topright previously overlapped the + # annotations with the legend box and clipped the last phase at the frame. + loss_lo = minimum(skipmissing(loss[!, "metrics/training_loss"])) + loss_hi = maximum(skipmissing(loss[!, "metrics/training_loss"])) + loss_span = loss_hi - loss_lo + annotation_y = loss_hi + 0.11 * loss_span + + # Pad the time axis so the last phase's centred annotation cannot run into the + # frame. Both panels get the SAME limits: they are stacked and read as one + # time axis, so padding only the top one would misalign the restart lines. + hours_max = maximum(loss.active_seconds) / 3600 + xlimits = (-0.02 * hours_max, 1.05 * hours_max) + + top = plot(; + ylabel = "126-stage objective", + title = "Training from random initialisation — " * + join(phase_label.(selected), " → "), + legend = :bottomright, grid = :y, gridalpha = 0.15, + ylims = (loss_lo - 0.20 * loss_span, loss_hi + 0.22 * loss_span), + xlims = xlimits, + ) + # Raw stochastic samples, faint. Smoothing is per STAGE so it resets at each + # restart, and per trajectory so its noise level does not track nt. + for stage in selected + rows = loss[loss.stage .== stage, :] + isempty(rows) && continue + hours = rows.active_seconds ./ 3600 + plot!(top, hours, rows[!, "metrics/training_loss"]; + color = C_RAW, alpha = 0.18, linewidth = 1, + label = stage == first(selected) ? "stochastic training loss (per update)" : "") + xs, ys = trajectory_smooth(hours, Float64.(rows[!, "metrics/training_loss"]), + Float64.(rows[!, "metrics/num_train_per_batch"]), + SMOOTH_TRAJECTORIES) + plot!(top, xs, ys; color = C_RAW, linewidth = 2.5, + label = stage == first(selected) ? + "smoothed over $(SMOOTH_TRAJECTORIES) sampled trajectories" : "") + end + if !isempty(epochs) + scatter!(top, epochs.active_seconds ./ 3600, epochs[!, "metrics/epoch_objective"]; + color = C_INK, markershape = :diamond, markersize = 3, + markerstrokewidth = 0, label = "126-stage epoch objective") + end + for (i, b) in enumerate(boundaries) + vline!(top, [b]; color = C_ACCENT, linestyle = :dash, linewidth = 1.2, + label = i == 1 ? "restart (optimiser, LR schedule and warm-up reset)" : "") + end + + bottom = plot(; + xlabel = "active wall time (h)", + ylabel = "96-stage fixed-panel cost", + legend = :topright, grid = :y, gridalpha = 0.15, + xlims = xlimits, + ) + hours = panel.active_seconds ./ 3600 + plot!(bottom, hours, panel[!, "metrics/rollout_objective_no_target_penalty"]; + color = C_TSDDR, linewidth = 2, markershape = :circle, markersize = 4, + markerstrokewidth = 0, label = "fixed 10-scenario panel (selection metric)") + # Only complete evaluations are selectable; incomplete ones are marked so the + # curve is not read as if every point were a candidate. + incomplete = panel[panel[!, "metrics/rollout_n_ok"] .< 10, :] + isempty(incomplete) || scatter!(bottom, + incomplete.active_seconds ./ 3600, + incomplete[!, "metrics/rollout_objective_no_target_penalty"]; + color = C_ACCENT, markershape = :xcross, markersize = 7, markerstrokewidth = 2, + label = "incomplete evaluation — refused for selection") + statistics = JSON.parsefile(joinpath(RESULTS, "statistics.json"))["statistics"] + hline!(bottom, [313331.56404]; color = C_SDDP, linewidth = 2, linestyle = :dash, + label = "SDDP on the same panel") + for (i, b) in enumerate(boundaries) + vline!(bottom, [b]; color = C_ACCENT, linestyle = :dash, linewidth = 1.2, label = "") + end + + # Stage annotations: nt and the learning-rate band actually used. + # + # The schedule RAMPS UP from LR/100 across the warm-up before the cosine + # decay begins, so a plain `minimum` over the logged rate returns the warm-up's + # first step rather than the schedule's floor — for phase 1 that is + # 1e-3 * (0.01 + 0.99/20) = 6e-5, which reads as a decay target it never was. + # The floor after the peak is the band the phase actually descended through, + # and it stays truthful when a phase stops before the cosine completes. + running = 0.0 + for stage in selected + rows = history[history.stage .== stage, :] + nt = Int(first(skipmissing(rows[!, "metrics/num_train_per_batch"]))) + lrs = collect(skipmissing(rows[!, "metrics/lr"])) + lr_peak = maximum(lrs) + lr_floor = minimum(@view lrs[argmax(lrs):end]) + mid = (running + per_stage[stage]["active_seconds"] / 2) / 3600 + annotate!(top, mid, annotation_y, + text(@sprintf("%s\nsample %d\nLR %.0e→%.0e", + phase_label(stage), nt, lr_peak, lr_floor), + 7, C_INK, :center)) + running += per_stage[stage]["active_seconds"] + end + + figure = plot(top, bottom; layout = grid(2, 1; heights = [0.55, 0.45]), + size = (1000, 760), left_margin = 8Plots.mm, bottom_margin = 6Plots.mm) + path = joinpath(ASSETS, "hydro_training_history.png") + savefig(figure, path) + println("Saved: $path") + return nothing +end + +# ── Figures 2 and 3: the paired 500-scenario evaluation ─────────────────────── + +function figure_distributions(paired, statistics) + tsddr = Float64.(paired.tsddr_cost) + sddp = Float64.(paired.sddp_cost) + + figure = plot(; + xlabel = "96-stage true-ACP operating cost (objective units)", + ylabel = "density", + title = @sprintf("Cost over %d paired inflow scenarios", nrow(paired)), + legend = :topright, grid = :y, gridalpha = 0.15, size = (1000, 460), + left_margin = 12Plots.mm, bottom_margin = 10Plots.mm, + ) + for (label, costs, colour) in (("SDDP", sddp, C_SDDP), ("TS-DDR", tsddr, C_TSDDR)) + xs, dens = gaussian_kde(costs) + plot!(figure, xs, dens; label = @sprintf("%s mean %.0f, sd %.0f", label, + mean(costs), std(costs)), + color = colour, linewidth = 2, fill = (0, 0.25, colour)) + vline!(figure, [mean(costs)]; color = colour, linestyle = :dash, + linewidth = 1, alpha = 0.8, label = "") + end + # The two distributions overlap almost completely; saying so on the figure + # keeps it from being read as two separated populations. + annotate!(figure, mean(sddp), 0.0, + text("the two distributions differ in mean by " * + @sprintf("%.0f (%.4f%%), against a spread of ~%.0f", + statistics["paired_difference"]["mean"], + statistics["paired_difference"]["relative_gap_pct"], + std(sddp)), + 8, C_INK, :bottom)) + path = joinpath(ASSETS, "hydro_cost_distributions.png") + savefig(figure, path) + println("Saved: $path") + return nothing +end + +function figure_paired_differences(paired, statistics) + diffs = Float64.(paired.paired_difference) + d = statistics["paired_difference"] + wins = statistics["wins_losses_ties"]["tsddr_wins"] + + figure = plot(; + xlabel = "paired difference, TS-DDR − SDDP, same scenario (objective units)", + ylabel = "density", + title = "Paired differences — the comparison the evaluation is designed to make", + # The mass sits to the RIGHT of zero, so :topright puts the legend on top + # of the peak. The left half of this axis is empty by construction. + legend = :topleft, grid = :y, gridalpha = 0.15, size = (1000, 470), + left_margin = 12Plots.mm, bottom_margin = 10Plots.mm, + ) + xs, dens = gaussian_kde(diffs) + plot!(figure, xs, dens; color = C_TSDDR, linewidth = 2, + fill = (0, 0.25, C_TSDDR), label = "") + # Mass to the LEFT of zero is where TS-DDR is cheaper. Shaded so the reader + # sees the sign of the result without decoding the axis. + left = xs .<= 0 + any(left) && plot!(figure, xs[left], dens[left]; color = C_SDDP, linewidth = 0, + fill = (0, 0.45, C_SDDP), + label = @sprintf("TS-DDR cheaper: %d of %d scenarios", + wins, nrow(paired))) + vline!(figure, [0.0]; color = C_INK, linewidth = 1.5, label = "zero") + vline!(figure, [d["mean"]]; color = C_ACCENT, linewidth = 2, linestyle = :dash, + label = @sprintf("mean +%.1f (95%% CI [+%.1f, +%.1f])", + d["mean"], d["ci95_cost"][1], d["ci95_cost"][2])) + path = joinpath(ASSETS, "hydro_paired_differences.png") + savefig(figure, path) + println("Saved: $path") + return nothing +end + +# ── Figure 4: where the difference is incurred ──────────────────────────────── + +function figure_stagewise() + stagewise = CSV.read(joinpath(RESULTS, "stagewise_physical.csv"), DataFrame) + reported = stagewise[stagewise.stage .<= 96, :] + + top = plot(; + ylabel = "cumulative cost difference\n(objective units)", + title = "Where the cost difference is incurred — means over 500 paired scenarios", + legend = :bottomright, grid = :y, gridalpha = 0.15, + ) + plot!(top, reported.stage, reported.cum_cost_difference; + color = C_TSDDR, linewidth = 2.5, label = "cumulative TS-DDR − SDDP") + hline!(top, [0.0]; color = C_INK, linewidth = 1, label = "") + + middle = plot(; ylabel = "reservoir 2 storage (pu)", + legend = :topright, grid = :y, gridalpha = 0.15) + plot!(middle, reported.stage, reported.sddp_reservoir2; + color = C_SDDP, linewidth = 2, label = "SDDP") + plot!(middle, reported.stage, reported.tsddr_reservoir2; + color = C_TSDDR, linewidth = 2, label = "TS-DDR") + + bottom = plot(; xlabel = "stage (week)", ylabel = "thermal generation (MW)", + legend = :topright, grid = :y, gridalpha = 0.15) + plot!(bottom, reported.stage, reported.sddp_thermal_MW; + color = C_SDDP, linewidth = 2, label = "SDDP") + plot!(bottom, reported.stage, reported.tsddr_thermal_MW; + color = C_TSDDR, linewidth = 2, label = "TS-DDR") + + figure = plot(top, middle, bottom; layout = (3, 1), size = (1000, 900), + left_margin = 14Plots.mm, bottom_margin = 8Plots.mm) + path = joinpath(ASSETS, "hydro_stagewise_physical.png") + savefig(figure, path) + println("Saved: $path") + return nothing +end + +""" + price_series() -> Union{Nothing,DataFrame} + +Per-stage nodal energy price for each policy, averaged over the panel columns. + +Prefers the compact `results/stagewise_prices.csv`. If that is absent but the +raw solution dumps are, it reduces them and writes the compact file, so the +figure is reproducible from `results/` alone thereafter. Returns `nothing` when +neither exists, and the price figure is then skipped rather than faked. + +The reduction is a mean of `price_active` over buses and over the scenarios the +two policies have IN COMMON — averaging one policy over ten columns and the other +over one would compare scenario sets, not policies. The number of paired +scenarios is carried in the output and shown on the figure. + +It is a *system* price, not a locational one: the point of the figure is when +energy is expensive, and how the two policies' water decisions move that in +time. Per-bus detail is in the dumps for anyone who wants it. + +`price_active` is the dual of a bus's active-power balance, in objective units +per per-unit power per stage; dividing by `baseMVA = 100` would put it per MW. +The objective's own unit is whatever the case's cost coefficients are denominated +in, which the case does not state, so it is not called a currency here — the +load-shedding price of 6000 is the reference that makes the level interpretable. +""" +function price_series() + compact = joinpath(RESULTS, "stagewise_prices.csv") + isfile(compact) && return CSV.read(compact, DataFrame) + + audit = joinpath(HYDRO_DIR, "bolivia", "ACPPowerModel", "audit") + isdir(audit) || return nothing + sources = Dict( + "sddp" => filter(f -> occursin(r"^sddp_\d+_\d+_solution\.csv$", f), readdir(audit)), + "tsddr" => filter(f -> occursin(r"solution.*\.csv$", f), + readdir(joinpath(HYDRO_DIR, "bolivia", "ACPPowerModel"))), + ) + isempty(sources["sddp"]) && return nothing + + # Accumulate per (policy, scenario, stage) so the two policies can be + # restricted to the SAME scenarios before averaging. A mean over ten columns + # on one side and one column on the other would not be a comparison of + # policies — it would be a comparison of scenario sets. + price = Dict{String,Dict{Tuple{Int,Int},Vector{Float64}}}() + for (policy, files) in sources + acc = Dict{Tuple{Int,Int},Vector{Float64}}() + base = policy == "sddp" ? audit : joinpath(HYDRO_DIR, "bolivia", "ACPPowerModel") + for f in files + path = joinpath(base, f) + isfile(path) || continue + for row in CSV.Rows(path; + types = Dict(:scenario => Int, :stage => Int, + :value => Float64)) + row.class == "price_active" || continue + push!(get!(acc, (row.scenario, row.stage), Float64[]), row.value) + end + end + isempty(acc) || (price[policy] = acc) + end + haskey(price, "sddp") || return nothing + + scenarios = Set(k[1] for k in keys(price["sddp"])) + for policy in keys(price) + intersect!(scenarios, Set(k[1] for k in keys(price[policy]))) + end + isempty(scenarios) && return nothing + stages = sort(unique(k[2] for k in keys(price["sddp"]) if k[1] in scenarios)) + @info "nodal prices" policies = sort(collect(keys(price))) n_scenarios = + length(scenarios) scenarios = sort(collect(scenarios)) + + frame = DataFrame(stage = stages) + for policy in ("sddp", "tsddr") + haskey(price, policy) || continue + frame[!, Symbol(policy * "_price")] = [ + mean(vcat((get(price[policy], (s, t), Float64[]) for s in scenarios)...)) + for t in stages + ] + end + frame[!, :n_scenarios] .= length(scenarios) + CSV.write(compact, frame) + println("Wrote: $compact") + return frame +end + +""" + price_bands(prices; min_run=3) -> Vector{NamedTuple} + +Contiguous runs of constant sign in the per-stage price difference +`TS-DDR − SDDP`, keeping only runs of at least `min_run` stages. + +This exists because the obvious summary is misleading. Bucketing the horizon +into equal segments and averaging reports a smooth drift from cheaper to dearer; +the difference actually alternates in bands tied to the reservoir cycle, and +fixed buckets straddle them. Runs of constant sign are the structure that is +there, so the prose quotes this rather than a bucketing chosen in advance. + +`min_run` drops one- and two-stage sign flips, which are sampling noise on a +ten-scenario mean rather than a change in behaviour. +""" +function price_bands(prices::DataFrame; min_run::Int = 3) + delta = (.-prices.tsddr_price) .- (.-prices.sddp_price) + stages = prices.stage + bands = NamedTuple[] + i = 1 + while i <= length(delta) + j = i + while j < length(delta) && (delta[j + 1] > 0) == (delta[i] > 0) + j += 1 + end + if j - i + 1 >= min_run + push!(bands, (first_stage = stages[i], last_stage = stages[j], + n = j - i + 1, dearer = delta[i] > 0, + mean = mean(view(delta, i:j)))) + end + i = j + 1 + end + return bands +end + +""" + report_price_bands() + +Print the sign bands of the price difference. + +The case study quotes these numbers, so they are printed by the script that +draws the figure rather than derived once by hand: a table transcribed into prose +has no way to notice when the evidence beneath it changes. +""" +function report_price_bands() + prices = price_series() + prices === nothing && return nothing + all(c -> Symbol(c) in propertynames(prices), ("sddp_price", "tsddr_price")) || + return nothing + println("\nPrice difference (TS-DDR − SDDP), contiguous sign bands of >= 3 stages:") + for b in price_bands(prices) + @printf(" stages %3d-%-3d (%2d stages) %-14s mean %+7.1f\n", + b.first_stage, b.last_stage, b.n, + b.dearer ? "TS-DDR dearer" : "TS-DDR cheaper", b.mean) + end + return nothing +end + +function figure_prices() + prices = price_series() + if prices === nothing + @warn "no nodal-price data found; skipping the price figure. Produce it with " * + "DR_SOLUTION_DUMP=1 on either paired evaluator." + return nothing + end + # The recorded dual is of the balance AS STORED, which is the NEGATIVE of the + # conventional price (see PRICE_CLASSES). Negating puts "expensive" up, where + # a reader expects it. + n_paired = :n_scenarios in propertynames(prices) ? + Int(first(prices.n_scenarios)) : 0 + suffix = n_paired == 0 ? "" : + " ($n_paired paired scenario$(n_paired == 1 ? "" : "s"))" + + has_both = all(c -> Symbol(c) in propertynames(prices), + ("sddp_price", "tsddr_price")) + + # LEVELS. Drawn on the data's own scale. Earlier versions put the + # load-shedding price (6000) on this axis as a reference line, which set the + # y-range to [0, 6000] and squeezed the entire signal — a band about 120 wide + # — into an unreadable sliver at the bottom. The reference belongs in words: + # serving load costs roughly a quarter of what shedding it does, which is why + # nothing is shed anywhere in this study. + # Negate once, here: the recorded dual is of the balance as stored, and every + # panel below plots the conventional price. + series = Dict(col => .-prices[!, Symbol(col)] + for col in ("sddp_price", "tsddr_price") + if Symbol(col) in propertynames(prices)) + + levels = plot(; + ylabel = "marginal cost of load\n(objective units per pu per stage)", + title = "What energy is worth, week by week" * suffix, + legend = :topright, grid = :y, gridalpha = 0.15, + ) + for (col, label, colour) in (("sddp_price", "SDDP", C_SDDP), + ("tsddr_price", "TS-DDR", C_TSDDR)) + haskey(series, col) || continue + plot!(levels, prices.stage, series[col]; + color = colour, linewidth = 2, label = label) + end + annotate!(levels, first(prices.stage), maximum(series["sddp_price"]), + text("load shedding is priced at 6000, far above this axis", + 7, C_INK, :left, :top)) + + # DIFFERENCE. The levels differ by well under a percent, so the sign of the + # difference — cheaper early, dearer at the end — is not legible from two + # overlaid curves however they are scaled. It is the claim the text makes, so + # it gets its own panel rather than a reader's benefit of the doubt. + panels = Any[levels] + if has_both + delta = series["tsddr_price"] .- series["sddp_price"] + gap = plot(; xlabel = "stage (week)", + ylabel = "TS-DDR − SDDP", + legend = :topleft, grid = :y, gridalpha = 0.15) + plot!(gap, prices.stage, delta; color = C_TSDDR, linewidth = 2, + fill = (0, 0.20, C_TSDDR), label = "difference in marginal cost") + hline!(gap, [0.0]; color = C_INK, linewidth = 1.2, label = "") + push!(panels, gap) + else + plot!(levels; xlabel = "stage (week)") + end + + figure = length(panels) == 1 ? plot(panels[1]; size = (1000, 480)) : + plot(panels...; layout = grid(2, 1; heights = [0.62, 0.38]), + size = (1000, 700)) + plot!(figure; left_margin = 14Plots.mm, bottom_margin = 10Plots.mm) + path = joinpath(ASSETS, "hydro_energy_price.png") + savefig(figure, path) + println("Saved: $path") + return nothing +end + +function main() + paired = CSV.read(joinpath(RESULTS, "paired_500.csv"), DataFrame) + statistics = JSON.parsefile(joinpath(RESULTS, "statistics.json"))["statistics"] + + # The published statistics must be the ones these rows imply; a figure drawn + # from rows that disagree with the reported table would be worse than none. + @assert nrow(paired) == statistics["n_scenarios"] + @assert isapprox(mean(paired.tsddr_cost), statistics["tsddr"]["mean"]; rtol = 1e-9) + @assert isapprox(mean(paired.sddp_cost), statistics["sddp"]["mean"]; rtol = 1e-9) + @assert isapprox(mean(paired.paired_difference), + statistics["paired_difference"]["mean"]; rtol = 1e-9) + @assert all(paired.tsddr_all_solved) && all(paired.sddp_all_solved) + + figure_training() + figure_distributions(paired, statistics) + figure_paired_differences(paired, statistics) + figure_stagewise() + figure_prices() + + println("\nPaired evaluation, n = ", nrow(paired)) + @printf(" TS-DDR %.5f (sd %.5f)\n", statistics["tsddr"]["mean"], statistics["tsddr"]["sd"]) + @printf(" SDDP %.5f (sd %.5f)\n", statistics["sddp"]["mean"], statistics["sddp"]["sd"]) + d = statistics["paired_difference"] + @printf(" paired difference +%.5f, SE %.5f, t = %.2f\n", d["mean"], d["se"], d["t"]) + @printf(" relative %+.6f%%, 95%% CI [%+.6f%%, %+.6f%%]\n", + d["relative_gap_pct"], d["ci95_pct"][1], d["ci95_pct"][2]) + report_price_bands() +end + +(abspath(PROGRAM_FILE) == @__FILE__) && main() diff --git a/examples/HydroPowerModels/results/lineage_accounting.json b/examples/HydroPowerModels/results/lineage_accounting.json new file mode 100644 index 0000000..30fa0ef --- /dev/null +++ b/examples/HydroPowerModels/results/lineage_accounting.json @@ -0,0 +1,67 @@ +{ + "runtime_definition": "ACTIVE TIME = wall time of the stage PROCESS from the start of problem construction to the end of training, i.e. construction + validation + the training loop. It excludes only Julia package instantiation, which precedes it. Reported per stage and summed over the SELECTED ancestry; the rejected C2 branch is accounted separately.", + "selected_ancestry": [ + "random initialisation", + "coldB", + "C1", + "C3" + ], + "rejected_branch": { + "stage": "C2", + "parent": "C1", + "why": "produced no valid best; stopped by the two-barren-evaluation rule inside a high-LR restart transient. Not an ancestor of C3." + }, + "primary_from_scratch_time_to_policy_seconds": 39481.6, + "primary_from_scratch_time_to_policy_hours": 10.9671, + "total_campaign_compute_including_C2_seconds": 42544.0, + "total_campaign_compute_including_C2_hours": 11.8178, + "discarded_search_work_seconds": 3062.4, + "components": { + "selected": { + "training_loop_seconds": 38234.5, + "init_and_validation_seconds": 1247.1, + "active_seconds": 39481.6 + }, + "all_including_C2": { + "training_loop_seconds": 41067.3, + "init_and_validation_seconds": 1476.7, + "active_seconds": 42544.0 + }, + "per_stage": { + "coldB": { + "active_seconds": 15904.5, + "training_loop_seconds": 15579.7, + "init_and_validation_seconds": 324.8, + "selected": true, + "md5": "6cb72daa5e8a", + "stage_updates": 390 + }, + "C1": { + "active_seconds": 15111.1, + "training_loop_seconds": 14872.681457996368, + "init_and_validation_seconds": 238.4, + "selected": true, + "md5": "f8f285dd44a8f6bbf565f26fd4ed8449", + "stage_updates": 400 + }, + "C2": { + "active_seconds": 3062.4, + "training_loop_seconds": 2832.7296900749207, + "init_and_validation_seconds": 229.7, + "selected": false, + "md5": null, + "stage_updates": null + }, + "C3": { + "active_seconds": 8466.0, + "training_loop_seconds": 7782.14440202713, + "init_and_validation_seconds": 683.9, + "selected": true, + "md5": "d875a27371b272e1badbeb23f0ca0a01", + "stage_updates": 100 + } + } + }, + "selected_lineage_updates_total": 890, + "note": "Cluster job ids and W&B run ids have been removed: they identify runs on the machine this was produced on and mean nothing elsewhere. Everything needed to reproduce the lineage is in lineage_from_scratch.json and the checkpoint hashes below." +} \ No newline at end of file diff --git a/examples/HydroPowerModels/results/statistics.json b/examples/HydroPowerModels/results/statistics.json new file mode 100644 index 0000000..1eeb0a3 --- /dev/null +++ b/examples/HydroPowerModels/results/statistics.json @@ -0,0 +1,238 @@ +{ + "statistics": { + "n_scenarios": 500, + "tsddr": { + "mean": 314023.6178991833, + "sd": 5998.371093278646 + }, + "sddp": { + "mean": 313546.0899814266, + "sd": 5925.4220618959325 + }, + "paired_difference": { + "mean": 477.52791775669147, + "sd": 363.42261283014085, + "se": 16.252753336975644, + "t": 29.381355137550567, + "ci95_cost": [ + 445.5961332755354, + 509.4597022378475 + ], + "ci95_pct": [ + 0.14211503428473019, + 0.16248319418303897 + ], + "relative_gap_pct": 0.1522991142338846 + }, + "wins_losses_ties": { + "tsddr_wins": 29, + "tsddr_losses": 471, + "ties": 0 + }, + "difference_quantiles": { + "p0": -1657.11450045096, + "p5": -129.9830595868377, + "p25": 360.77945845185604, + "p50": 498.1808755902457, + "p75": 655.3950516526093, + "p95": 947.2079611674147, + "p100": 1465.8719146864605 + }, + "worst_for_tsddr": [ + { + "scenario": 189, + "difference": 1465.8719146864605, + "pct": 0.46553342832598243 + }, + { + "scenario": 254, + "difference": 1409.9438183908933, + "pct": 0.4570442287862192 + }, + { + "scenario": 366, + "difference": 1272.5140079116682, + "pct": 0.4124114385177244 + }, + { + "scenario": 269, + "difference": 1216.1438632631907, + "pct": 0.39334584149921364 + }, + { + "scenario": 154, + "difference": 1184.2453745946405, + "pct": 0.38784779280374415 + } + ], + "best_for_tsddr": [ + { + "scenario": 322, + "difference": -1657.11450045096, + "pct": -0.5477930517832351 + }, + { + "scenario": 323, + "difference": -1583.8105190423084, + "pct": -0.5176213068596144 + }, + { + "scenario": 409, + "difference": -1336.4004396636155, + "pct": -0.43883687061197746 + }, + { + "scenario": 125, + "difference": -1209.5911590777687, + "pct": -0.39808991831924806 + }, + { + "scenario": 191, + "difference": -1080.5316618173965, + "pct": -0.3543638665831061 + } + ], + "ten_column_check": { + "tsddr_panel_mean_in_500": 313751.5548636604, + "tsddr_panel_reference": 313751.55485, + "tsddr_panel_abs_diff": 1.3660406693816185e-05, + "sddp_panel_mean_in_500": 313331.5640418305, + "sddp_panel_reference": 313331.56404, + "sddp_panel_abs_diff": 1.8304563127458096e-06, + "panel_paired_difference": 419.9908218299388, + "panel_gap_pct": 0.1340403808707472, + "full_gap_pct": 0.1522991142338846, + "direction_representative": true + }, + "solve_and_retry": { + "tsddr_solved_first_attempt": 498, + "tsddr_solved_on_retry": 2, + "tsddr_retry_scenarios": [ + 174, + 369 + ], + "tsddr_all_solved": 500, + "sddp_all_solved": 500 + }, + "load_shedding": { + "tsddr_total_pu": -1.342339332850907, + "tsddr_max_bus_stage_pu": -9.986889685697293e-07, + "tsddr_scenarios_above_tol": 0, + "sddp_total_pu": -0.011777147909951049, + "sddp_max_bus_stage_pu": -8.636197073593447e-09, + "sddp_scenarios_above_tol": 0, + "tolerance_pu": 1e-06 + } + }, + "stagewise_at_reported_stages": [ + { + "stage": 1, + "cum_cost_difference": -40.04996530098548, + "tsddr_thermal_MW": 204.29771609919916, + "sddp_thermal_MW": 207.2608805475295, + "tsddr_hydro_MW": 285.08792718727364, + "sddp_hydro_MW": 283.57363871469744, + "tsddr_outflow": 51.692054741254516, + "sddp_outflow": 50.94909904106046, + "tsddr_spill": 6.167786045036055, + "sddp_spill": 6.145322018719535, + "tsddr_storage": 11.190650877500884, + "sddp_storage": 11.57552688513707, + "tsddr_cost_gen": 3092.8029742613435, + "sddp_cost_gen": 3132.6866182201784, + "tsddr_reservoir2": 6.837547402858734, + "sddp_reservoir2": 7.521491300440377 + }, + { + "stage": 12, + "cum_cost_difference": -576.5362495347238, + "tsddr_thermal_MW": 208.5214671507899, + "sddp_thermal_MW": 211.5628963879422, + "tsddr_hydro_MW": 279.94730043418565, + "sddp_hydro_MW": 277.37859687715434, + "tsddr_outflow": 50.10303436596119, + "sddp_outflow": 49.54785016039068, + "tsddr_spill": 1.3279974288625183, + "sddp_spill": 1.257343553191559, + "tsddr_storage": 127.76804535322404, + "sddp_storage": 131.86874060938038, + "tsddr_cost_gen": 3155.291432554409, + "sddp_cost_gen": 3200.2830730787173, + "tsddr_reservoir2": 102.47207635498047, + "sddp_reservoir2": 104.04050778217848 + }, + { + "stage": 48, + "cum_cost_difference": -859.7714653506465, + "tsddr_thermal_MW": 209.79350578483326, + "sddp_thermal_MW": 212.66267347209882, + "tsddr_hydro_MW": 277.59674521972903, + "sddp_hydro_MW": 274.8033926207215, + "tsddr_outflow": 49.4322074441544, + "sddp_outflow": 48.621280373789496, + "tsddr_spill": 0.28534781830273015, + "sddp_spill": 0.26779515902684276, + "tsddr_storage": 3.1070826823431617, + "sddp_storage": 8.722544813009966, + "tsddr_cost_gen": 3174.615844651683, + "sddp_cost_gen": 3217.2598328376885, + "tsddr_reservoir2": 2.558086918890476, + "sddp_reservoir2": 5.789908706664637 + }, + { + "stage": 62, + "cum_cost_difference": -1688.5006177943958, + "tsddr_thermal_MW": 201.8605866971662, + "sddp_thermal_MW": 208.3645429757912, + "tsddr_hydro_MW": 286.2728764441136, + "sddp_hydro_MW": 279.6238813150079, + "tsddr_outflow": 51.021672589030445, + "sddp_outflow": 49.595181998080555, + "tsddr_spill": 1.2016411693751103, + "sddp_spill": 1.1039514253909046, + "tsddr_storage": 139.0943122653477, + "sddp_storage": 149.90363754468396, + "tsddr_cost_gen": 3061.015213115031, + "sddp_cost_gen": 3153.282927963118, + "tsddr_reservoir2": 110.46901580810547, + "sddp_reservoir2": 115.65898162739586 + }, + { + "stage": 90, + "cum_cost_difference": -1.7280534516271437, + "tsddr_thermal_MW": 214.1447991558952, + "sddp_thermal_MW": 212.29003853423058, + "tsddr_hydro_MW": 272.8952650387885, + "sddp_hydro_MW": 274.7866000753065, + "tsddr_outflow": 48.30150134838584, + "sddp_outflow": 48.493615901185926, + "tsddr_spill": 0.22633468625691391, + "sddp_spill": 0.19691187804887905, + "tsddr_storage": 4.502946114490515, + "sddp_storage": 6.83535468813608, + "tsddr_cost_gen": 3240.7255262076137, + "sddp_cost_gen": 3211.6383958712813, + "tsddr_reservoir2": 3.3230299972891806, + "sddp_reservoir2": 5.326980226302594 + }, + { + "stage": 96, + "cum_cost_difference": 477.52791775669147, + "tsddr_thermal_MW": 211.77914976801958, + "sddp_thermal_MW": 195.26403718436774, + "tsddr_hydro_MW": 275.68412007012813, + "sddp_hydro_MW": 292.62325175677074, + "tsddr_outflow": 49.2292116305868, + "sddp_outflow": 51.770335949679875, + "tsddr_spill": 0.35130498984654046, + "sddp_spill": 0.31171347268552235, + "tsddr_storage": 0.4074755772385115, + "sddp_storage": 2.0720856543639283, + "tsddr_cost_gen": 3211.4770384034487, + "sddp_cost_gen": 2969.0593596834974, + "tsddr_reservoir2": 0.17949001667363337, + "sddp_reservoir2": 0.35051766084313296 + } + ], + "n_scenarios_in_stagewise": 500 +} \ No newline at end of file diff --git a/examples/HydroPowerModels/sddp/Project.toml b/examples/HydroPowerModels/sddp/Project.toml index 2aac97c..8c105f1 100644 --- a/examples/HydroPowerModels/sddp/Project.toml +++ b/examples/HydroPowerModels/sddp/Project.toml @@ -1,11 +1,22 @@ [deps] +StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3" CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b" Clarabel = "61c947e1-3e6d-4ee4-985a-eec8c727bd6e" DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" HydroPowerModels = "1bf2e10f-7293-4f36-bafb-f7584ca75eae" +JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" JuMP = "4076af6c-e467-56ae-b986-b466b2749572" +Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" MadNLP = "2621e9c9-9eb4-46b1-8089-e8c72242dfb6" Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" PowerModels = "c36e90e8-916a-50a6-bd94-075b64ef4655" SDDP = "f4570300-c277-11e8-125c-4912f86ce65d" Wandb = "ad70616a-06c9-5745-b1f1-6a5f42545108" + +[sources] +# HydroPowerModels.jl is not in the General registry. Pinning it here — rather +# than only in a Manifest — is what makes this environment reproducible from the +# committed Project.toml alone: the SDDP cuts that ship with the example were +# built by THIS package, and a different revision can build a different stage +# model from the same case files. +HydroPowerModels = {rev = "main", url = "https://github.com/LAMPSPUC/HydroPowerModels.jl"} diff --git a/examples/HydroPowerModels/sddp/eval_paired_sddp.jl b/examples/HydroPowerModels/sddp/eval_paired_sddp.jl new file mode 100644 index 0000000..2189b12 --- /dev/null +++ b/examples/HydroPowerModels/sddp/eval_paired_sddp.jl @@ -0,0 +1,548 @@ +# Paired SDDP simulation on the seeded paired protocol via SDDP.Historical. +# +# Scenario indices are generated from PAIRED_SCENARIO_SEED (identical to +# eval_paired_tsddr.jl's protocol), so the SDDP policy is simulated under the +# exact inflow realizations every TS-DDR evaluation uses. +# +# Usage: +# julia --project -t auto eval_paired_sddp.jl +using MadNLP +using StableRNGs +using HydroPowerModels +using JuMP +using PowerModels +using Statistics +using SDDP: SDDP +using DelimitedFiles +using CSV, DataFrames +using JSON + +const CASE = "bolivia" +const SDDP_DIR = dirname(@__FILE__) +const HYDRO_DIR = dirname(SDDP_DIR) +const CASE_DIR = joinpath(HYDRO_DIR, CASE) +const RM_STAGES = 30 +const REPORT_STAGES = 96 +const NUM_STAGES = REPORT_STAGES + RM_STAGES +const FORMULATION = ACPPowerModel +const FORMULATION_B = SOCWRConicPowerModel + +include(joinpath(HYDRO_DIR, "hydro_solution_schema.jl")) +using .HydroSolutionSchema + +# The frozen case has DETERMINISTIC demand: `0.6 x PowerModels.json` active and +# reactive load at every stage, and inflow as the only uncertainty. This is +# asserted rather than assumed — a demand file appearing in the case directory +# would silently change the stochastic program, so its absence is checked here +# and again by `generate_canonical_case_artifacts.jl --verify`. +for name in ("demand.csv", "demand_scenarios.csv", "demand_noise.csv") + isfile(joinpath(CASE_DIR, name)) && error( + "$name is present in $CASE_DIR. The frozen experiment has deterministic " * + "demand and inflow-only uncertainty; a demand file means a different " * + "stochastic program and different cuts.", + ) +end +@info "Demand model" deterministic = true uncertainty = "inflow only" + +# ── Paired scenario indices (seeded protocol) ────────────────────────────── +# Identical generation to load_hydropowermodels.jl's paired_scenario_indices: +# entry [t, s] is uniform on 1:nCen from StableRNG(PAIRED_SCENARIO_SEED), so +# this script and every TS-DDR evaluation realize the same inflow at the same +# stage of the same paired scenario — with no shared data file. nCen is +# derived from the inflow data (columns ÷ hydro units), never hardcoded. +const PAIRED_SCENARIO_SEED = 20260706 +# Fixed generated shape shared by ALL consumers (see load_hydropowermodels.jl: +# arrays of different shapes consume the RNG stream differently, so every +# script must generate exactly this shape and slice what it needs). +const PAIRED_NUM_STAGES = 126 +const N_HYDRO = 11 +@assert NUM_STAGES == PAIRED_NUM_STAGES "SDDP horizon must equal the paired protocol shape" +num_scenarios = parse(Int, get(ENV, "DR_NUM_SCENARIOS", "500")) +nCen = div(size(readdlm(joinpath(HYDRO_DIR, CASE, "inflows.csv"), ','), 2), N_HYDRO) +# ALWAYS generate the full protocol matrix (fixed shape — see the note above), +# then optionally simulate only a shard of its columns so the 500 scenarios +# can run in parallel across nodes (DR_SCENARIO_FIRST/LAST, 1-based inclusive). +all_indices = rand(StableRNG(PAIRED_SCENARIO_SEED), 1:nCen, PAIRED_NUM_STAGES, num_scenarios) +scen_first = parse(Int, get(ENV, "DR_SCENARIO_FIRST", "1")) +scen_last = parse(Int, get(ENV, "DR_SCENARIO_LAST", string(num_scenarios))) +@assert 1 <= scen_first <= scen_last <= num_scenarios +scen_range = scen_first:scen_last +println("Paired protocol: seed=$PAIRED_SCENARIO_SEED, $(PAIRED_NUM_STAGES)×$(num_scenarios), nCen=$nCen") +println("Evaluating scenarios $scen_first:$scen_last, $REPORT_STAGES reported stages (of $NUM_STAGES total)") + +# ── Build SDDP model and load cuts ──────────────────────────────────────── +global alldata = HydroPowerModels.parse_folder(CASE_DIR; stages=NUM_STAGES) +for data in alldata + for load in values(data["powersystem"]["load"]) + load["pd"] *= 0.6 + load["qd"] *= 0.6 + end + data["powersystem"]["cost_deficit"] = 6000.0 / data["powersystem"]["baseMVA"] +end +@info "Canonical MAIN demand" pd_scale=0.6 qd_scale=0.6 deficit_cost=6000.0 + +stage_hours = Int(get(alldata[1]["hydro"], "stage_hours", 1)) # K = 0.0036·stage_hours +params = create_param(; + stages=NUM_STAGES, + stage_hours=stage_hours, + model_constructor_grid=FORMULATION, + post_method=PowerModels.build_opf, + # Hardened solver settings for the 500-scenario simulation: with bare + # defaults one nonconvex ACP node failed to converge on one seeded draw + # (SDDP aborts the whole simulation on any node failure). Larger + # iteration budget + explicit tolerance make every node solvable; the + # cuts themselves are unaffected (they were trained separately). + optimizer=() -> MadNLP.Optimizer(; + print_level=0, + max_iter=9000, + tol=1e-6, + ), +) + +m = hydro_thermal_operation(alldata, params) + +# DR_CUTS_FILE lets the launcher point at a stable SNAPSHOT of the live cuts +# (the training job rewrites the canonical file every iteration → reading it +# directly risks a torn JSON). Defaults to the canonical inconsistent-run path. +cuts_file = get(ENV, "DR_CUTS_FILE", joinpath( + CASE_DIR, + string(FORMULATION), + string(FORMULATION_B) * "-" * string(FORMULATION) * ".cuts.json", +)) +SDDP.read_cuts_from_file(m.forward_graph, cuts_file) +println("Loaded cuts: $cuts_file") + +# ── Build SDDP.Historical sampling scheme ────────────────────────────────── +# Each scenario is a vector of (node, noise_term) pairs: node = stage index, +# noise term = the inflow atom this protocol column realizes at that stage. +historical_scenarios = [ + [(t, all_indices[t, s]) for t in 1:NUM_STAGES] + for s in scen_range +] +n_sim = length(scen_range) + +sampling_scheme = SDDP.Historical(historical_scenarios) + +# ── Simulate ─────────────────────────────────────────────────────────────── +# `DR_PHYSICAL_AUDIT=1` records the PHYSICAL decision variables of every solved +# stage subproblem alongside the stock HydroPowerModels recorders. It cannot go +# through `HydroPowerModels.simulate`, which hardcodes its `custom_recorders` +# and drops `kwargs...`; so the audit path calls `SDDP.simulate` directly with a +# SUPERSET of the stock recorder dictionary and rebuilds the same result +# `Dict`. The extra recorders only READ values off models the simulation has +# already solved — no extra solve, and the recorded costs are bit-identical to +# the un-instrumented run (verified against the existing shard costs). +const PHYSICAL_AUDIT = get(ENV, "DR_PHYSICAL_AUDIT", "0") == "1" +# `DR_SOLUTION_DUMP=1` additionally records the FULL physical solution of every +# simulated stage — every named primal variable plus the nodal prices — in the +# shared long format of `hydro_solution_schema.jl`, together with the decision +# trace (incoming state, realized inflow, outgoing reservoir level). +# +# This is the only path by which per-bus physics leaves the solver. The four +# aggregate CSVs above answer "how much thermal, how much water, was any load +# shed"; they cannot answer "what was energy worth at bus 14 in week 62", which +# is a dual and exists nowhere else. The stagewise and price figures are built +# from this dump. +const SOLUTION_DUMP = get(ENV, "DR_SOLUTION_DUMP", "0") == "1" +SOLUTION_DUMP && !PHYSICAL_AUDIT && + error("DR_SOLUTION_DUMP=1 requires DR_PHYSICAL_AUDIT=1 (it rides on the same recorders)") +# Stages whose full solution is dumped. Defaults to the whole simulated horizon, +# not the reported window: the look-ahead stages are part of the trajectory even +# though no cost is reported from them. +const SOLUTION_DUMP_STAGES = parse(Int, get(ENV, "DR_SOLUTION_DUMP_STAGES", string(NUM_STAGES))) +println("\nSimulating $n_sim scenarios with SDDP.Historical...") +results = if !PHYSICAL_AUDIT + HydroPowerModels.simulate(m, n_sim; sampling_scheme=sampling_scheme) +else + println("PHYSICAL AUDIT enabled: recording per-bus deficit[b] and hydro decisions") + sims = SDDP.simulate( + m.forward_graph, n_sim; + sampling_scheme=sampling_scheme, + custom_recorders=Dict{Symbol,Function}( + # ── stock HydroPowerModels recorders (kept identical) ────────── + :powersystem => HydroPowerModels.build_sol_powermodels, + :reservoirs => HydroPowerModels.build_sol_reservoirs, + :objective => objective_value, + # ── PHYSICAL load shedding: the per-bus active-power balance + # slack `deficit[b]` (pu). This — and ONLY this — is load + # shedding; the reservoir-target penalty bookkeeping is a + # different quantity entirely. + :deficit_bus => sp -> Vector{Float64}(JuMP.value.(sp[:deficit])), + # ── hydro physical decisions (pu-volume units of the case) ───── + :outflow_r => sp -> Vector{Float64}(JuMP.value.(sp[:outflow])), + :spill_r => sp -> Vector{Float64}(JuMP.value.(sp[:spill])), + :inflow_r => sp -> Vector{Float64}(JuMP.value.(sp[:inflow])), + # ── objective decomposition: `sp.ext[:cost]` holds the JuMP + # expression of each additive term of the stage objective + # (generation, spill, deficit, …), so the stage cost can be + # attributed without re-deriving it. + :cost_gen => sp -> JuMP.value(sp.ext[:cost][:gen_cost]), + :cost_deficit => sp -> JuMP.value(sp.ext[:cost][:deficit_cost]), + :cost_spill => sp -> JuMP.value(sp.ext[:cost][:spill_cost]), + # Remaining additive terms (minimal-outflow / minimal-volume + # violation), so gen+deficit+spill+other == stage_objective and the + # decomposition can be checked rather than assumed. + :cost_other => sp -> sum( + JuMP.value(e) for (k, e) in sp.ext[:cost] + if !(k in (:gen_cost, :deficit_cost, :spill_cost)); + init=0.0, + ), + # ── solve status of the stage subproblem ─────────────────────── + :status => sp -> string(JuMP.termination_status(sp)), + # ── FULL primal solution, by variable NAME ───────────────────── + # Every named variable of the solved stage. Recorded only under + # DR_SOLUTION_DUMP because it is one entry per variable per stage. + # Reading them by their serialized names — the same names + # `export_subproblem_mof.jl` writes — is what lets this solution be + # compared, plotted or replayed elsewhere without re-deriving an + # index convention. + :named_solution => sp -> SOLUTION_DUMP ? + Dict{String,Float64}( + JuMP.name(v) => JuMP.value(v) for v in JuMP.all_variables(sp) + if !isempty(JuMP.name(v)) + ) : Dict{String,Float64}(), + # ── NODAL PRICES ─────────────────────────────────────────────── + # The dual of each bus's active-power balance is the locational + # marginal price of energy at that bus (USD per pu per stage); the + # reactive balance gives the price of reactive support. These are + # the economic read-out of the dispatch — what the policy's water + # decisions are worth to the network — and they exist only as duals, + # so no primal recording can substitute for them. + # + # `lam_kcl_r` / `lam_kcl_i` are the constraint references + # PowerModels stores per bus, and the same ones HydroPowerModels' + # own `constraint_mod_deficit` uses to insert the load-shedding + # variable, so the sign convention is the package's own. + # `PowerModels.sol(pm, 0, :bus)` is a Dict keyed by BUS INDEX, so it + # is indexed by id — iterating it would yield Pairs and, worse, in an + # unspecified order, which would silently scramble the prices across + # buses. + :price_active => sp -> SOLUTION_DUMP ? begin + buses = PowerModels.sol(sp.ext[:pm], 0, :bus) + Float64[JuMP.dual(buses[b][:lam_kcl_r]) for b in 1:length(buses)] + end : Float64[], + :price_reactive => sp -> SOLUTION_DUMP ? begin + buses = PowerModels.sol(sp.ext[:pm], 0, :bus) + Float64[JuMP.dual(buses[b][:lam_kcl_i]) for b in 1:length(buses)] + end : Float64[], + ), + ) + Dict{Symbol,Any}( + :simulations => sims, + :params => m.params, + :data => m.alldata, + ) +end + +# The simulation must have realized the protocol's inflow atoms, not SDDP's own +# sampling. Checked against the independently generated index matrix. +for (si, s) in enumerate(first(scen_range, min(3, n_sim))), t in 1:min(5, REPORT_STAGES) + recorded_ω = results[:simulations][si][t][:noise_term] + if recorded_ω != all_indices[t, s] + error("Mismatch at scenario $s, stage $t: got noise=$recorded_ω, expected $(all_indices[t, s])") + end +end +println("Inflow protocol verification passed (spot-checked)") + +# ── Extract results ──────────────────────────────────────────────────────── +nhyd = alldata[1]["hydro"]["nHyd"] +volume_to_mw(volume; k=0.0036) = volume / k + +objective_values = [ + sum(results[:simulations][i][t][:stage_objective] for t in 1:REPORT_STAGES) + for i in 1:n_sim +] + +hydro_vol = [ + mean( + sum( + volume_to_mw(results[:simulations][i][t][:reservoirs][:reservoir][j].out) for + j in 1:nhyd + ) for i in 1:n_sim + ) for t in 1:REPORT_STAGES +] + +num_gen = length(results[:simulations][1][1][:powersystem]["solution"]["gen"]) +hydro_idx = HydroPowerModels.idx_hydro(results[:data][1]) +thermal_gen = [ + mean( + sum( + results[:simulations][i][t][:powersystem]["solution"]["gen"]["$j"]["pg"] * + results[:data][1]["powersystem"]["baseMVA"] for + j in 1:num_gen if !(j in hydro_idx) + ) for i in 1:n_sim + ) for t in 1:REPORT_STAGES +] + +# ── Report ───────────────────────────────────────────────────────────────── +println("\n" * "=" ^ 60) +println("Results: Paired SDDP ($REPORT_STAGES stages, $num_scenarios scenarios)") +println("=" ^ 60) +println(" Mean cost: $(round(mean(objective_values); digits=1))") +println(" Std: $(round(std(objective_values); digits=1))") +println(" Min: $(round(minimum(objective_values); digits=1))") +println(" Max: $(round(maximum(objective_values); digits=1))") +println(" Median: $(round(median(objective_values); digits=1))") +println("=" ^ 60) + +# ── Save results ─────────────────────────────────────────────────────────── +out_dir = joinpath(CASE_DIR, string(FORMULATION)) + +# ── PHYSICAL AUDIT OUTPUT ────────────────────────────────────────────────── +# Three CSVs per shard, written into `/audit/`: +# *_deficit.csv one row per (scenario, stage, bus) with NONZERO deficit +# above `AUDIT_TOL`, plus raw extrema, so both the raw and the +# thresholded views are recoverable; +# *_stage.csv one row per (scenario, stage): stage totals for shedding, +# thermal generation, hydro in/out/spill, cost decomposition, +# and solve status; +# *_scenario.csv one row per scenario: totals + the cost that MUST reproduce +# the existing shard cost. +# baseMVA converts per-unit power to MW; deficit[b] is an active-power +# injection slack, so `deficit_MW = deficit_pu * baseMVA`. +const AUDIT_TOL = 1e-6 # pu — numerical-tolerance gate +if PHYSICAL_AUDIT + baseMVA = alldata[1]["powersystem"]["baseMVA"] + audit_dir = joinpath(out_dir, "audit") + isdir(audit_dir) || mkpath(audit_dir) + tag = "sddp_$(scen_first)_$(scen_last)" + + def_rows = DataFrame( + scenario=Int[], stage=Int[], bus=Int[], + deficit_pu=Float64[], deficit_MW=Float64[], + ) + stage_rows = DataFrame( + scenario=Int[], stage=Int[], + deficit_pu=Float64[], deficit_MW=Float64[], + max_bus_deficit_pu=Float64[], argmax_bus=Int[], n_buses_shedding=Int[], + thermal_MW=Float64[], hydro_MW=Float64[], + inflow=Float64[], outflow=Float64[], spill=Float64[], storage=Float64[], + cost_gen=Float64[], cost_deficit=Float64[], cost_spill=Float64[], + cost_other=Float64[], stage_objective=Float64[], status=String[], + ) + for (i, s) in enumerate(scen_range) + for t in 1:REPORT_STAGES + rec = results[:simulations][i][t] + d = rec[:deficit_bus] # Vector{Float64}, pu + # Raw per-bus rows, thresholded so the file stays readable; the + # unthresholded extrema are carried in the stage row regardless. + for (b, v) in enumerate(d) + v > AUDIT_TOL && push!(def_rows, (s, t, b, v, v * baseMVA)) + end + dmax, dargmax = findmax(d) + gen = rec[:powersystem]["solution"]["gen"] + th = sum(gen["$j"]["pg"] * baseMVA for j in 1:num_gen if !(j in hydro_idx)) + hy = sum(gen["$j"]["pg"] * baseMVA for j in 1:num_gen if j in hydro_idx) + push!(stage_rows, ( + s, t, + sum(d), sum(d) * baseMVA, + dmax, dargmax, count(>(AUDIT_TOL), d), + th, hy, + sum(rec[:inflow_r]), sum(rec[:outflow_r]), sum(rec[:spill_r]), + sum(rec[:reservoirs][:reservoir][j].out for j in 1:nhyd), + rec[:cost_gen], rec[:cost_deficit], rec[:cost_spill], + rec[:cost_other], rec[:stage_objective], rec[:status], + )) + end + end + + # Per-scenario roll-up. `cost` here is the SAME sum as the shard file, so + # equality with the existing shard CSV validates the instrumentation. + # Per-reservoir storage / turbine outflow / spill, so a cost gap against + # another policy can be attributed to individual reservoirs rather than only + # to aggregate water. Mirrors the TS-DDR dump's `*_reservoir.csv` schema. + res_rows = DataFrame( + scenario=Int[], stage=Int[], reservoir=Int[], + storage=Float64[], outflow=Float64[], spill=Float64[], + ) + for (i, s) in enumerate(scen_range) + for t in 1:REPORT_STAGES + rec = results[:simulations][i][t] + for r in 1:nhyd + push!(res_rows, ( + s, t, r, + rec[:reservoirs][:reservoir][r].out, + rec[:outflow_r][r], rec[:spill_r][r], + )) + end + end + end + CSV.write(joinpath(audit_dir, "$(tag)_reservoir.csv"), res_rows) + + scen_rows = DataFrame( + scenario=Int[], cost=Float64[], + deficit_pu=Float64[], deficit_MW=Float64[], + max_bus_stage_deficit_pu=Float64[], max_bus_stage_deficit_MW=Float64[], + n_stages_with_deficit=Int[], n_bus_stage_with_deficit=Int[], + cost_deficit=Float64[], cost_gen=Float64[], cost_spill=Float64[], + all_stages_solved=Bool[], + ) + for (i, s) in enumerate(scen_range) + g = stage_rows[stage_rows.scenario .== s, :] + push!(scen_rows, ( + s, objective_values[i], + sum(g.deficit_pu), sum(g.deficit_MW), + maximum(g.max_bus_deficit_pu), maximum(g.max_bus_deficit_pu) * baseMVA, + count(>(AUDIT_TOL), g.deficit_pu), sum(g.n_buses_shedding), + sum(g.cost_deficit), sum(g.cost_gen), sum(g.cost_spill), + all(st -> st in ("LOCALLY_SOLVED", "OPTIMAL"), g.status), + )) + end + + CSV.write(joinpath(audit_dir, "$(tag)_deficit.csv"), def_rows) + CSV.write(joinpath(audit_dir, "$(tag)_stage.csv"), stage_rows) + CSV.write(joinpath(audit_dir, "$(tag)_scenario.csv"), scen_rows) + + # ── FULL PHYSICAL SOLUTION ──────────────────────────────────────────── + # Every named primal variable and both nodal prices, per stage, plus the + # decision trace that reproduces the trajectory. + if SOLUTION_DUMP + verify_index_convention(CASE_DIR, JSON.parsefile) + writer = SolutionWriter(joinpath(audit_dir, "$(tag)_solution.csv")) + orientation = branch_orientation(CASE_DIR, JSON.parsefile) + trace_rows = DataFrame( + scenario=Int[], stage=Int[], reservoir=Int[], + state_in=Float64[], target=Float64[], inflow=Float64[], + ) + n_dump = min(SOLUTION_DUMP_STAGES, NUM_STAGES) + for (i, s) in enumerate(scen_range) + cumulative = 0.0 + for t in 1:n_dump + rec = results[:simulations][i][t] + for (name, value) in rec[:named_solution] + mapped = solution_class(name, orientation) + mapped === nothing && continue + record!(writer, s, t, mapped[1], mapped[2], value) + end + record_vector!(writer, s, t, "price_active", rec[:price_active]) + record_vector!(writer, s, t, "price_reactive", rec[:price_reactive]) + cumulative += rec[:stage_objective] + record_scalar!(writer, s, t, "stage_objective", rec[:stage_objective]) + record_scalar!(writer, s, t, "cum_objective", cumulative) + for r in 1:nhyd + state_in = rec[:reservoirs][:reservoir][r].in + state_out = rec[:reservoirs][:reservoir][r].out + # The cut policy's DECISION is the outgoing level, so it is + # also what a strict replay would be told to hit; recording + # it as `target` keeps one trace schema for both policies. + record!(writer, s, t, "target", r, state_out) + push!(trace_rows, (s, t, r, state_in, state_out, rec[:inflow_r][r])) + end + end + end + close(writer) + CSV.write(joinpath(audit_dir, "$(tag)_trace.csv"), trace_rows) + println(" Full solution + trace: $audit_dir/$(tag)_{solution,trace}.csv " * + "($(n_dump) stages per scenario)") + end + + println("\n" * "=" ^ 60) + println("PHYSICAL LOAD-SHEDDING AUDIT (deficit[b], tol=$AUDIT_TOL pu)") + println("=" ^ 60) + for r in eachrow(scen_rows) + println(" scen $(r.scenario): cost=$(round(r.cost; digits=2)) " * + "deficit=$(r.deficit_pu) pu ($(r.deficit_MW) MW-stage) " * + "max_bus_stage=$(r.max_bus_stage_deficit_pu) pu " * + "stages_shedding=$(r.n_stages_with_deficit)/$REPORT_STAGES " * + "cost_deficit=$(r.cost_deficit) all_solved=$(r.all_stages_solved)") + end + println(" RAW MAX over all (scen,stage,bus): " * + "$(maximum(stage_rows.max_bus_deficit_pu)) pu") + println(" Audit CSVs: $audit_dir/$(tag)_{deficit,stage,scenario}.csv") + println("=" ^ 60) +end + +# Shard mode: emit only this shard's per-scenario costs (merged afterwards by +# merge_sddp_shards.jl); the full-run outputs below are skipped. +# +# The `scenario` column holds the GLOBAL protocol column id, never a +# shard-local 1..n index — that is what lets `merge_sddp_shards.jl` prove the +# shards partition the protocol, and what keeps the ids comparable to the +# TS-DDR side. `all_stages_solved` travels with the cost so an unsolved +# scenario stays visible through the merge instead of being averaged in. +if n_sim != num_scenarios + shard_file = joinpath(out_dir, "sddp_shard_$(scen_first)_$(scen_last).csv") + solved = if PHYSICAL_AUDIT + [ + all( + results[:simulations][i][t][:status] in ("LOCALLY_SOLVED", "OPTIMAL") + for t in 1:REPORT_STAGES + ) + for i in 1:n_sim + ] + else + # Without the audit recorders the per-stage status is not read back. + # SDDP.simulate itself aborts on a failed node, so reaching this line + # means every stage solved; the column records that it was inferred + # rather than observed. + fill(true, n_sim) + end + CSV.write(shard_file, DataFrame( + scenario = collect(scen_range), + cost = objective_values, + all_stages_solved = solved, + status_observed = fill(PHYSICAL_AUDIT, n_sim), + )) + println("Shard written: $shard_file (ids $scen_first:$scen_last, " * + "$(count(solved))/$n_sim fully solved)") + exit(0) +end + +# Optional output tag (mirrors eval_paired_tsddr.jl): when DR_OUTPUT_TAG is +# set, every output filename gets an _ suffix so re-evaluations at a +# different scenario count never overwrite existing result files. Note that a +# tagged run starts fresh tagged files; the merge-with-existing-columns logic +# only applies within the same tag. +tag_suffix = let tag = get(ENV, "DR_OUTPUT_TAG", "") + isempty(tag) ? "" : "_$(tag)" +end +isempty(tag_suffix) || println("Output tag suffix: $tag_suffix") + +const COL_NAME = "SDDP-SOC (paired)" +costs_file = joinpath(out_dir, "paired_costs$(tag_suffix).csv") +if isfile(costs_file) + df = CSV.read(costs_file, DataFrame) + df[!, COL_NAME] = objective_values +else + df = DataFrame(Symbol(COL_NAME) => objective_values) +end +CSV.write(costs_file, df) +println("Updated: $costs_file") + +vol_file = joinpath(out_dir, "paired_MeanVolume$(tag_suffix).csv") +if isfile(vol_file) + df_vol = CSV.read(vol_file, DataFrame; header=true) + df_vol[!, COL_NAME] = hydro_vol +else + df_vol = DataFrame(Symbol(COL_NAME) => hydro_vol) +end +CSV.write(vol_file, df_vol) +println("Updated: $vol_file") + +gen_file = joinpath(out_dir, "paired_MeanGeneration$(tag_suffix).csv") +if isfile(gen_file) + df_gen = CSV.read(gen_file, DataFrame; header=true) + df_gen[!, COL_NAME] = thermal_gen +else + df_gen = DataFrame(Symbol(COL_NAME) => thermal_gen) +end +CSV.write(gen_file, df_gen) +println("Updated: $gen_file") + +# Per-scenario paired costs for direct comparison +println("\nPer-scenario cost comparison (first 10):") +if isfile(costs_file) + df_all = CSV.read(costs_file, DataFrame) + if hasproperty(df_all, Symbol("TS-DDR (strict, paired)")) + tsddr_costs = df_all[!, "TS-DDR (strict, paired)"] + sddp_costs = df_all[!, COL_NAME] + diffs = sddp_costs .- tsddr_costs + println(" Scenario | SDDP | TS-DDR | Diff") + for s in 1:min(10, num_scenarios) + println(" $(lpad(s, 7)) | $(lpad(round(sddp_costs[s]; digits=1), 9)) | $(lpad(round(tsddr_costs[s]; digits=1), 9)) | $(round(diffs[s]; digits=1))") + end + println("\n Mean diff (SDDP - TS-DDR): $(round(mean(diffs); digits=1))") + println(" Std diff: $(round(std(diffs); digits=1))") + println(" Paired t-test p-value: (compute externally)") + end +end diff --git a/examples/HydroPowerModels/sddp/merge_sddp_shards.jl b/examples/HydroPowerModels/sddp/merge_sddp_shards.jl new file mode 100644 index 0000000..062f3f8 --- /dev/null +++ b/examples/HydroPowerModels/sddp/merge_sddp_shards.jl @@ -0,0 +1,110 @@ +# Merge sharded paired-evaluation outputs into one per-scenario cost table. +# +# `eval_paired_sddp.jl` writes one `sddp_shard__.csv` per shard, keyed by +# the GLOBAL protocol column id. Concatenating those shards reproduces a full run +# EXACTLY — but only if the partition is complete and disjoint. A silently +# missing shard would change the mean without changing anything visible, so the +# partition is CHECKED here, and a violation is an error, not a warning. +# +# Nothing about the final published result is baked in: the expected scenario set +# is a parameter, and a two-scenario smoke run merges the same way a 500-scenario +# run does. +# +# Environment: +# DR_SHARD_DIR directory holding sddp_shard_*.csv (default ".") +# DR_SHARD_GLOB filename pattern prefix (default "sddp_shard_") +# DR_SCENARIO_FIRST first expected global scenario id (default 1) +# DR_SCENARIO_LAST last expected global scenario id (default 500) +# DR_MERGE_OUT output csv path (default /sddp_paired_merged.csv) +# DR_ALLOW_PARTIAL "true" to merge an INCOMPLETE set anyway (default "false") +# +# `DR_ALLOW_PARTIAL` exists for inspecting a run still in flight. It renames the +# output to `*_PARTIAL.csv` and labels every printed statistic, because a mean +# over a subset of the protocol is NOT an estimate of the same quantity as a mean +# over all of it. + +using CSV, DataFrames, Statistics, Printf + +const DIR = get(ENV, "DR_SHARD_DIR", ".") +const PREFIX = get(ENV, "DR_SHARD_GLOB", "sddp_shard_") +const FIRST = parse(Int, get(ENV, "DR_SCENARIO_FIRST", "1")) +const LAST = parse(Int, get(ENV, "DR_SCENARIO_LAST", "500")) +const ALLOW_PARTIAL = lowercase(strip(get(ENV, "DR_ALLOW_PARTIAL", "false"))) in ("1", "true", "yes") + +FIRST <= LAST || error("DR_SCENARIO_FIRST ($FIRST) must not exceed DR_SCENARIO_LAST ($LAST)") +const EXPECTED = FIRST:LAST + +pattern = Regex("^" * PREFIX * raw"\d+_\d+\.csv$") +files = sort(filter(f -> occursin(pattern, f), readdir(DIR))) +isempty(files) && error("no $(PREFIX)*.csv shard files in $DIR") + +# Read every shard and remember which file each row came from, so a duplicate or +# an out-of-range id can be attributed to a specific shard rather than merely +# reported to exist. +frames = DataFrame[] +for file in files + frame = CSV.read(joinpath(DIR, file), DataFrame) + hasproperty(frame, :scenario) || + error("$file has no `scenario` column; shards must carry GLOBAL scenario ids") + hasproperty(frame, :cost) || error("$file has no `cost` column") + frame[!, :shard_file] .= file + push!(frames, frame) +end +df = sort!(reduce(vcat, frames; cols = :union), :scenario) + +# ── Partition checks: complete, disjoint, in range ──────────────────────────── +duplicates = [id for id in unique(df.scenario) if count(==(id), df.scenario) > 1] +if !isempty(duplicates) + offenders = unique(df[in(duplicates).(df.scenario), :shard_file]) + error("duplicate scenario ids across shards: $(first(duplicates, 10)) " * + "(shards $(offenders)). Overlapping shard ranges would double-count.") +end + +out_of_range = setdiff(df.scenario, EXPECTED) +isempty(out_of_range) || + error("shards contain scenario ids outside $(FIRST):$(LAST): $(first(sort(out_of_range), 10))") + +missing_ids = setdiff(EXPECTED, df.scenario) +if !isempty(missing_ids) + message = "INCOMPLETE merge: $(length(missing_ids)) of $(length(EXPECTED)) " * + "scenarios are missing (first: $(first(sort(missing_ids), 10))). " * + "A mean over a subset is not a merge of the protocol." + ALLOW_PARTIAL || error(message * " Set DR_ALLOW_PARTIAL=true to inspect it anyway.") + @warn message +end + +# ── Unsolved scenarios stay visible ─────────────────────────────────────────── +# Shards written with the physical audit carry `all_stages_solved`. A scenario +# whose rollout did not solve every stage has a cost that is not comparable, so +# it is reported and excluded from the statistics rather than averaged in. +unsolved = if hasproperty(df, :all_stages_solved) + df.scenario[.!coalesce.(df.all_stages_solved, false)] +else + Int[] +end +usable = isempty(unsolved) ? df : df[.!in(unsolved).(df.scenario), :] + +complete = isempty(missing_ids) && isempty(unsolved) +default_out = joinpath(DIR, complete ? "sddp_paired_merged.csv" : "sddp_paired_merged_PARTIAL.csv") +out = get(ENV, "DR_MERGE_OUT", default_out) +CSV.write(out, df) + +costs = usable.cost +n = length(costs) +n > 0 || error("no usable scenarios after excluding unsolved ones") +m = mean(costs) +sd = std(costs) +se = sd / sqrt(n) +label = complete ? "COMPLETE" : "PARTIAL — NOT the protocol mean" +@printf("shards merged : %d files, %d rows, ids %d:%d\n", length(files), nrow(df), FIRST, LAST) +@printf("coverage : %d of %d expected [%s]\n", nrow(df), length(EXPECTED), label) +isempty(missing_ids) || @printf("missing ids : %s\n", string(first(sort(missing_ids), 20))) +isempty(unsolved) || @printf("unsolved ids : %s (excluded from statistics)\n", string(sort(unsolved))) +@printf("mean cost : %.5f\n", m) +@printf("std dev : %.5f\n", sd) +@printf("std error : %.5f\n", se) +@printf("95%% CI : [%.5f, %.5f]\n", m - 1.96se, m + 1.96se) +@printf("min / max : %.5f / %.5f\n", minimum(costs), maximum(costs)) +@printf("quartiles : %.5f / %.5f / %.5f\n", + quantile(costs, 0.25), median(costs), quantile(costs, 0.75)) +println("merged -> $out") diff --git a/examples/HydroPowerModels/sddp/run_sddp.jl b/examples/HydroPowerModels/sddp/run_sddp.jl deleted file mode 100644 index 6643640..0000000 --- a/examples/HydroPowerModels/sddp/run_sddp.jl +++ /dev/null @@ -1,168 +0,0 @@ -# SDDP baseline: train and simulate SDDP policy on the Bolivia LTHD problem -# using a consistent convex SOCWRConic formulation. - -using Clarabel -using HydroPowerModels -using JuMP -using Logging -using PowerModels -using Random -using SDDP -using Statistics -using Wandb, Dates - -const SEED = parse(Int, get(ENV, "DR_SDDP_SEED", "1221")) -const CASE = get(ENV, "DR_SDDP_CASE", "bolivia") -const HYDRO_DIR = dirname(@__DIR__) -const CASE_DIR = joinpath(HYDRO_DIR, CASE) -const RM_STAGES = parse(Int, get(ENV, "DR_SDDP_RM_STAGES", "30")) -const NUM_STAGES = parse(Int, get(ENV, "DR_SDDP_NUM_STAGES", string(96 + RM_STAGES))) -const ITERATION_LIMIT = parse(Int, get(ENV, "DR_SDDP_ITERATION_LIMIT", "200")) -const NUM_SIMULATIONS = parse(Int, get(ENV, "DR_SDDP_SIMULATIONS", "300")) -const STAT_REPLICATIONS = parse(Int, get(ENV, "DR_SDDP_STAT_REPLICATIONS", "300")) -const STAT_PERIOD = parse(Int, get(ENV, "DR_SDDP_STAT_PERIOD", "50")) -const FORMULATION = SOCWRConicPowerModel -const save_file = "SDDP-$(CASE)-$(FORMULATION)-$(FORMULATION)-h$(NUM_STAGES)-$(Dates.now())" -const CUTS_FILE = joinpath( - CASE_DIR, - string(FORMULATION), - string(FORMULATION) * "-" * string(FORMULATION) * ".cuts.json", -) - -function clarabel_optimizer() - return Clarabel.Optimizer(; - verbose=false, - max_iter=parse(Int, get(ENV, "DR_SDDP_CLARABEL_MAX_ITER", "1000")), - tol_gap_abs=parse(Float64, get(ENV, "DR_SDDP_CLARABEL_TOL", "1e-7")), - tol_gap_rel=parse(Float64, get(ENV, "DR_SDDP_CLARABEL_TOL", "1e-7")), - tol_feas=parse(Float64, get(ENV, "DR_SDDP_CLARABEL_TOL", "1e-7")), - ) -end - -mutable struct WandBLog <: SDDP.AbstractStoppingRule - cuts_file::String - lg -end - -SDDP.stopping_rule_status(::WandBLog) = :not_solved - -function SDDP.convergence_test( - policy::SDDP.PolicyGraph, - log::Vector{SDDP.Log}, - rule::WandBLog, -) - mkpath(dirname(rule.cuts_file)) - SDDP.write_cuts_to_file(policy, rule.cuts_file) - latest = log[end] - Wandb.log( - rule.lg, - Dict( - "batch" => length(log), - "metrics/loss" => latest.bound, - "metrics/rollout_realized_objective_no_deficit" => latest.simulation_value, - ), - ) - println( - "iteration=$(length(log)) bound=$(latest.bound) simulation_value=$(latest.simulation_value)", - ) - flush(stdout) - return false -end - -function load_case_data() - alldata = HydroPowerModels.parse_folder(CASE_DIR) - for load in values(alldata[1]["powersystem"]["load"]) - load["qd"] *= 0.6 - load["pd"] *= 0.6 - end - return alldata -end - -function main() - println("Run: ", save_file) - println("Case directory: ", CASE_DIR) - println("Formulation: ", FORMULATION, " with Clarabel") - - Random.seed!(SEED) - mkpath(dirname(CUTS_FILE)) - alldata = load_case_data() - lg = WandbLogger(; - project="RL", - name=save_file, - save_code=false, - config=Dict( - "case_name" => CASE, - "training_method" => "sddp_consistent", - "formulation" => string(FORMULATION), - "solver" => "Clarabel", - "num_stages" => NUM_STAGES, - "rm_stages" => RM_STAGES, - "iteration_limit" => ITERATION_LIMIT, - "num_simulations" => NUM_SIMULATIONS, - "stat_replications" => STAT_REPLICATIONS, - "stat_period" => STAT_PERIOD, - "seed" => SEED, - ), - ) - params = create_param(; - stages=NUM_STAGES, - model_constructor_grid=FORMULATION, - post_method=PowerModels.build_opf, - optimizer=clarabel_optimizer, - ) - model = hydro_thermal_operation(alldata, params) - - if isfile(CUTS_FILE) - println("Loading existing cuts: ", CUTS_FILE) - SDDP.read_cuts_from_file(model.forward_graph, CUTS_FILE) - end - - stopping_rules = SDDP.AbstractStoppingRule[WandBLog(CUTS_FILE, lg)] - if STAT_REPLICATIONS > 0 - push!( - stopping_rules, - SDDP.Statistical(; - num_replications=STAT_REPLICATIONS, - iteration_period=STAT_PERIOD, - ), - ) - end - - start_time = time() - HydroPowerModels.train( - model; - iteration_limit=ITERATION_LIMIT, - stopping_rules=stopping_rules, - ) - elapsed = time() - start_time - bound = SDDP.calculate_bound(model.forward_graph) - println("Termination status: ", SDDP.termination_status(model.forward_graph)) - println("Elapsed seconds: ", elapsed) - println("Bound: ", bound) - - SDDP.write_cuts_to_file(model.forward_graph, CUTS_FILE) - println("Saved cuts: ", CUTS_FILE) - - Random.seed!(SEED) - results = HydroPowerModels.simulate(model, NUM_SIMULATIONS) - objective_values = [ - sum(results[:simulations][i][t][:stage_objective] for t in 1:(NUM_STAGES - RM_STAGES)) - for i in 1:length(results[:simulations]) - ] - final_loss = mean(objective_values) - println("Mean Sim: ", final_loss) - Wandb.log( - lg, - Dict( - "batch" => ITERATION_LIMIT, - "metrics/loss" => bound, - "metrics/final_loss" => final_loss, - "metrics/rollout_realized_objective_no_deficit" => final_loss, - "metrics/final_rollout_realized_objective_no_deficit" => final_loss, - "metrics/elapsed_seconds" => elapsed, - ), - ) - close(lg) -end - -main() diff --git a/examples/HydroPowerModels/sddp/run_sddp_inconsistent.jl b/examples/HydroPowerModels/sddp/run_sddp_inconsistent.jl index 0035912..ea88ac1 100644 --- a/examples/HydroPowerModels/sddp/run_sddp_inconsistent.jl +++ b/examples/HydroPowerModels/sddp/run_sddp_inconsistent.jl @@ -17,7 +17,16 @@ using PowerModels using Random using SDDP using Statistics -using Wandb, Dates +using Dates + +# Weights & Biases is OPTIONAL telemetry, and it is loaded lazily on purpose. +# `Wandb` pulls in PythonCall/CondaPkg, which builds a Python environment on +# first use; importing it unconditionally would make merely REPRODUCING the +# published numbers depend on that build succeeding. `DR_SDDP_WANDB=false` skips +# it entirely. +const ENABLE_WANDB = lowercase(get(ENV, "DR_SDDP_WANDB", "true")) in ("true", "1", "yes") +ENABLE_WANDB && @eval using Wandb +using CSV, DataFrames const SEED = parse(Int, get(ENV, "DR_SDDP_SEED", "1221")) const CASE = get(ENV, "DR_SDDP_CASE", "bolivia") @@ -29,23 +38,49 @@ const ITERATION_LIMIT = parse(Int, get(ENV, "DR_SDDP_ITERATION_LIMIT", "2000")) const NUM_SIMULATIONS = parse(Int, get(ENV, "DR_SDDP_SIMULATIONS", "300")) const STAT_REPLICATIONS = parse(Int, get(ENV, "DR_SDDP_STAT_REPLICATIONS", "300")) const STAT_PERIOD = parse(Int, get(ENV, "DR_SDDP_STAT_PERIOD", "200")) +# Reactive-demand scaler (historical value 0.6; see load_case_data comment) +const QD_SCALER = parse(Float64, get(ENV, "DR_SDDP_QD_SCALER", "0.6")) const FORMULATION_BACKWARD = SOCWRConicPowerModel const FORMULATION_FORWARD = ACPPowerModel + +# Robust flat-voltage primal starts for the ACP forward graph (vm = 0 default +# start is singular for polar AC and crashes MadNLP at stressed load levels). +include(joinpath(@__DIR__, "sddp_ac_starts.jl")) + +# The frozen case has DETERMINISTIC demand and inflow-only uncertainty, so the +# stage noise is HydroPowerModels' own `rainfall_noises` — no override, no +# product atoms. A demand file appearing in the case directory would change the +# stochastic program underneath the cuts, so its absence is asserted before any +# model is built. +for name in ("demand.csv", "demand_scenarios.csv", "demand_noise.csv") + isfile(joinpath(CASE_DIR, name)) && error( + "$name is present in $CASE_DIR. Cuts trained against a different " * + "stochastic program are not valid lower bounds for this one.", + ) +end + const save_file = "SDDP-$(CASE)-$(FORMULATION_FORWARD)-$(FORMULATION_BACKWARD)-h$(NUM_STAGES)-$(Dates.now())" const CUTS_DIR = joinpath(CASE_DIR, string(FORMULATION_FORWARD)) -const CUTS_FILE = joinpath( +const CUTS_FILE = get(ENV, "DR_SDDP_CUTS_FILE", joinpath( CUTS_DIR, string(FORMULATION_BACKWARD) * "-" * string(FORMULATION_FORWARD) * ".cuts.json", -) +)) function clarabel_optimizer() return Clarabel.Optimizer(; verbose=false, - max_iter=parse(Int, get(ENV, "DR_SDDP_CLARABEL_MAX_ITER", "1000")), - tol_gap_abs=parse(Float64, get(ENV, "DR_SDDP_CLARABEL_TOL", "1e-7")), - tol_gap_rel=parse(Float64, get(ENV, "DR_SDDP_CLARABEL_TOL", "1e-7")), - tol_feas=parse(Float64, get(ENV, "DR_SDDP_CLARABEL_TOL", "1e-7")), + # Bound integrity is more important than continuing a damaged run. + # This configuration independently solved the cut-loaded node-14 dump + # to OPTIMAL; stronger 1e-5/1e-4 regularization falsely reported that + # same feasible problem INFEASIBLE (cutval_11220957.out). + max_iter=parse(Int, get(ENV, "DR_SDDP_CLARABEL_MAX_ITER", "200000")), + tol_gap_abs=parse(Float64, get(ENV, "DR_SDDP_CLARABEL_TOL", "1e-8")), + tol_gap_rel=parse(Float64, get(ENV, "DR_SDDP_CLARABEL_TOL", "1e-8")), + tol_feas=parse(Float64, get(ENV, "DR_SDDP_CLARABEL_TOL", "1e-8")), + equilibrate_enable=false, + static_regularization_constant=parse(Float64, + get(ENV, "DR_SDDP_CLARABEL_STATREG", "1e-8")), ) end @@ -55,11 +90,127 @@ function madnlp_optimizer() ) end +# Regularization variants for the recovery ladder (rung 3+). Identical to +# `clarabel_optimizer` in every respect EXCEPT static regularization, and in +# particular at the same strict 1e-8 feasibility/gap tolerances — this is not a +# tolerance ladder. Rungs 1 and 2 of the recovery are numerically identical to +# each other, so an ALMOST_OPTIMAL caused by a knife-edge KKT resonance +# reproduces on both; node-122 diagnosis (PROJECT.md §19.12) showed 1e-11, +# 3e-11, 3e-10 and 1e-9 all reach literal OPTIMAL on the instance where 1e-10 +# does not, with objectives agreeing to ~1e-7 relative. Ordered nearest-first +# from the default so the mildest change is tried first. +const CLARABEL_STATREG_VARIANTS = let raw = get(ENV, "DR_SDDP_CLARABEL_STATREG_VARIANTS", + "3e-10,3e-11,1e-9,1e-11") + [parse(Float64, strip(x)) for x in split(raw, ",") if !isempty(strip(x))] +end + +function clarabel_variant_optimizers() + base = parse(Float64, get(ENV, "DR_SDDP_CLARABEL_STATREG", "1e-8")) + tol = parse(Float64, get(ENV, "DR_SDDP_CLARABEL_TOL", "1e-8")) + maxit = parse(Int, get(ENV, "DR_SDDP_CLARABEL_MAX_ITER", "200000")) + # Skip any variant equal to the base setting: retrying it would repeat the + # failing solve exactly, which is what rungs 1-2 already do. + return Function[ + () -> Clarabel.Optimizer(; verbose=false, max_iter=maxit, + tol_gap_abs=tol, tol_gap_rel=tol, tol_feas=tol, + equilibrate_enable=false, static_regularization_constant=sr) + for sr in CLARABEL_STATREG_VARIANTS if !isapprox(sr, base; rtol=1e-12) + ] +end + mutable struct WandBLog <: SDDP.AbstractStoppingRule cuts_file::String lg end +# Out-of-sample metrics produced by StatisticalMetrics (below) and picked up by WandBLog +# on the next iteration's log line. A Ref rather than a second simulation: SDDP's own +# convergence check already simulates the policy out-of-sample, so these numbers are a +# by-product of work that is happening anyway. +const OUT_OF_SAMPLE_METRICS = Ref{Dict{String,Any}}(Dict{String,Any}()) + +""" + StatisticalMetrics(; num_replications, iteration_period, z_score, lg) + +Drop-in REPLACEMENT for `SDDP.Statistical` — not an addition. It performs the identical +convergence test (simulate `num_replications` out-of-sample paths every +`iteration_period` iterations; stop when the bound enters the simulation's confidence +interval) but keeps the simulation results instead of discarding them, and records the +physical quantities that decide whether the reported AC-SOC gap is real: +deficit (is the AC policy shedding load?), storage, and spill. + +`SDDP.Statistical` cannot be reused for this: its `results` is a local variable inside +`convergence_test` and is never exposed. Since this rule replaces it, the number of +simulations is UNCHANGED — the same 300 replications every 200 iterations, simply not +thrown away. Running this alongside `SDDP.Statistical` would double the simulation cost +and must not be done. + +The recorders read values off models the simulation has already solved, so they add no +solves — only field reads. +""" +struct StatisticalMetrics <: SDDP.AbstractStoppingRule + num_replications::Int + iteration_period::Int + z_score::Float64 + lg + baseMVA::Float64 # pu -> MW for the deficit report; taken from the parsed case +end + +SDDP.stopping_rule_status(::StatisticalMetrics) = :statistical + +function SDDP.convergence_test( + graph::SDDP.PolicyGraph, + log::Vector{SDDP.Log}, + rule::StatisticalMetrics, +) + if length(log) % rule.iteration_period != 0 + return false + end + results = SDDP.simulate(graph, rule.num_replications; + custom_recorders = Dict{Symbol,Function}( + :deficit => sp -> sum(JuMP.value.(sp[:deficit])), + :volume => sp -> sum(JuMP.value(sp[:reservoir][i].out) + for i in 1:length(sp[:reservoir])), + :spill => sp -> sum(JuMP.value.(sp[:spill])), + )) + objectives = map(sim -> sum(s[:stage_objective] for s in sim), results) + sample_mean = mean(objectives) + sample_ci = rule.z_score * std(objectives) / sqrt(rule.num_replications) + + # Physical audit over the SAME simulations. baseMVA converts pu -> MW so the deficit + # is reported in physical units and is directly comparable to the case's served load. + baseMVA = rule.baseMVA + T = length(results[1]) + defs = [sum(s[:deficit] for s in sim) * baseMVA for sim in results] + vols = [mean(s[:volume] for s in sim) for sim in results] + spil = [sum(s[:spill] for s in sim) for sim in results] + nshed = sum(count(s -> s[:deficit] > 1e-6, sim) for sim in results) + bound = log[end].bound + OUT_OF_SAMPLE_METRICS[] = Dict{String,Any}( + "metrics/oos_cost_mean" => sample_mean, + "metrics/oos_cost_ci95" => sample_ci, + "metrics/oos_gap_pct" => abs(bound) > 0 ? 100 * (sample_mean - bound) / abs(bound) : NaN, + "metrics/oos_deficit_mw_stages_mean" => mean(defs), + "metrics/oos_deficit_mw_stages_max" => maximum(defs), + "metrics/oos_scenarios_with_deficit" => count(>(1e-6), defs), + "metrics/oos_stages_with_deficit" => nshed, + "metrics/oos_stages_total" => T * length(results), + "metrics/oos_mean_storage" => mean(vols), + "metrics/oos_spill_total" => mean(spil), + "metrics/oos_replications" => rule.num_replications, + ) + println(" [oos] it=$(length(log)) cost=$(round(sample_mean;digits=1))±$(round(sample_ci;digits=1)) " * + "gap=$(round(100*(sample_mean-bound)/abs(bound);digits=3))% " * + "deficit_MW=$(round(mean(defs);digits=4)) shed_stages=$nshed/$(T*length(results)) " * + "storage=$(round(mean(vols);digits=3)) spill=$(round(mean(spil);digits=3))") + flush(stdout) + rule.lg === nothing || Wandb.log(rule.lg, + merge(Dict{String,Any}("batch" => length(log)), OUT_OF_SAMPLE_METRICS[])) + + return graph.objective_sense == MOI.MIN_SENSE ? + sample_mean - sample_ci <= bound : bound <= sample_mean + sample_ci +end + SDDP.stopping_rule_status(::WandBLog) = :not_solved function SDDP.convergence_test( @@ -70,27 +221,43 @@ function SDDP.convergence_test( mkpath(dirname(rule.cuts_file)) SDDP.write_cuts_to_file(policy, rule.cuts_file) latest = log[end] - Wandb.log( + gap = abs(latest.bound) > 0 ? + 100 * (latest.simulation_value - latest.bound) / abs(latest.bound) : NaN + # NOTE: no simulation is run here. The out-of-sample metrics come from the + # StatisticalMetrics rule below, which extracts them from the simulations SDDP's own + # convergence check ALREADY performs — adding a second simulation here would slow + # training to re-derive information that already exists. + extra = OUT_OF_SAMPLE_METRICS[] + rule.lg === nothing || Wandb.log( rule.lg, - Dict( + merge(Dict{String,Any}( "batch" => length(log), "metrics/loss" => latest.bound, + "metrics/bound" => latest.bound, + "metrics/simulation_value" => latest.simulation_value, + "metrics/gap_pct" => gap, "metrics/rollout_realized_objective_no_deficit" => latest.simulation_value, - ), + "metrics/elapsed_seconds" => latest.time, + "metrics/total_solves" => latest.total_solves, + ), extra), ) println( - "iteration=$(length(log)) bound=$(latest.bound) simulation_value=$(latest.simulation_value)", + "iteration=$(length(log)) bound=$(latest.bound) simulation_value=$(latest.simulation_value) gap=$(round(gap;digits=3))%", ) flush(stdout) return false end function load_case_data() - alldata = HydroPowerModels.parse_folder(CASE_DIR) - for load in values(alldata[1]["powersystem"]["load"]) - load["qd"] *= 0.6 - load["pd"] *= 0.6 + alldata = HydroPowerModels.parse_folder(CASE_DIR; stages=NUM_STAGES) + for data in alldata + for load in values(data["powersystem"]["load"]) + load["pd"] *= 0.6 + load["qd"] *= 0.6 + end + data["powersystem"]["cost_deficit"] = 6000.0 / data["powersystem"]["baseMVA"] end + @info "Canonical MAIN demand" pd_scale=0.6 qd_scale=0.6 deficit_cost=6000.0 return alldata end @@ -106,7 +273,10 @@ function main() Random.seed!(SEED) mkpath(CUTS_DIR) alldata = load_case_data() - lg = WandbLogger(; + lg = nothing + if ENABLE_WANDB + try + lg = WandbLogger(; project="RL", name=save_file, save_code=false, @@ -124,11 +294,18 @@ function main() "stat_replications" => STAT_REPLICATIONS, "stat_period" => STAT_PERIOD, "seed" => SEED, + "demand" => "deterministic (0.6 x PowerModels.json, active and reactive)", ), - ) + ) + catch err; @warn "W&B init failed; stdout-only" err; lg=nothing; end + end + # Water balance: K = 0.0036·stage_hours (from hydro.json; default 1). + stage_hours = Int(get(alldata[1]["hydro"], "stage_hours", 1)) + @info "SDDP water balance" stage_hours K_eff = 0.0036 * stage_hours params = create_param(; stages=NUM_STAGES, + stage_hours=stage_hours, model_constructor_grid=FORMULATION_BACKWARD, model_constructor_grid_forward=FORMULATION_FORWARD, post_method=PowerModels.build_opf, @@ -137,6 +314,18 @@ function main() ) model = hydro_thermal_operation(alldata, params) + # ACP forward subproblems need non-singular voltage starts (see sddp_ac_starts.jl) + preset_ac_starts!(model.forward_graph) + # multi-attempt numerical recovery on BOTH graphs (intermittent MadNLP + # failures at stressed operating points survive SDDP's single-retry default; + # rung 2+ re-attaches a brand-new solver instance — see sddp_ac_starts.jl) + # NOTE: the conic_variants regularization ladder is deliberately NOT used. Retrying + # a failed backward solve at a different regularization until one returns OPTIMAL + # changes which cuts get built, i.e. it influences cut creation. Cut generation must + # be stock SDDP behaviour, so the recovery is the historical 2-arg form only. + recovery = make_robust_recovery(madnlp_optimizer, clarabel_optimizer) + model.forward_graph.ext[:numerical_difficulty_callback] = recovery + model.backward_graph.ext[:numerical_difficulty_callback] = recovery if isfile(CUTS_FILE) println("Loading existing cuts: ", CUTS_FILE) @@ -145,21 +334,29 @@ function main() stopping_rules = SDDP.AbstractStoppingRule[WandBLog(CUTS_FILE, lg)] if STAT_REPLICATIONS > 0 + # StatisticalMetrics REPLACES SDDP.Statistical (identical convergence test, same + # number of simulations) and additionally records deficit/storage/spill from + # those same out-of-sample paths. Never push both: that would simulate twice. push!( stopping_rules, - SDDP.Statistical(; - num_replications=STAT_REPLICATIONS, - iteration_period=STAT_PERIOD, + StatisticalMetrics( + STAT_REPLICATIONS, + STAT_PERIOD, + 1.96, + lg, + Float64(alldata[1]["powersystem"]["baseMVA"]), ), ) end start_time = time() - HydroPowerModels.train( - model; - iteration_limit=ITERATION_LIMIT, - stopping_rules=stopping_rules, - ) + _tl = parse(Float64, get(ENV, "DR_SDDP_TIME_LIMIT", "0")) + # Cut generation is stock SDDP: no custom duality_handler. StrictConicDuality was + # removed because rejecting/accepting backward duals on a status test is an + # intervention in how cuts are created; SDDP's own ConicDuality is used instead. + _kw = _tl>0 ? (iteration_limit=ITERATION_LIMIT, stopping_rules=stopping_rules, time_limit=_tl) : + (iteration_limit=ITERATION_LIMIT, stopping_rules=stopping_rules) + HydroPowerModels.train(model; _kw...) elapsed = time() - start_time status = SDDP.termination_status(model.forward_graph) @@ -172,25 +369,41 @@ function main() println("Saved cuts: ", CUTS_FILE) Random.seed!(SEED) - results = HydroPowerModels.simulate(model, NUM_SIMULATIONS) - objective_values = [ - sum(results[:simulations][i][t][:stage_objective] for t in 1:(NUM_STAGES - RM_STAGES)) - for i in 1:length(results[:simulations]) - ] + # SDDP.simulate directly: HydroPowerModels.simulate hardcodes its own + # custom_recorders and silently drops this one (the :deficit reads below + # would KeyError after the full training otherwise). + sims = SDDP.simulate(model.forward_graph, NUM_SIMULATIONS; + custom_recorders = Dict{Symbol,Function}( + :deficit => (sp::JuMP.Model) -> sum(JuMP.value.(sp[:deficit])))) + Teval = NUM_STAGES - RM_STAGES + # Full-horizon forward cost: the ONLY number comparable to the bound + # (bounds are horizon-specific — a T-stage bound does not bound a T'-stage + # metric). The Teval truncation below is a separate policy-quality report. + full_objective_values = [sum(sims[i][t][:stage_objective] for t in 1:NUM_STAGES) + for i in 1:length(sims)] + full_loss = mean(full_objective_values) + objective_values = [sum(sims[i][t][:stage_objective] for t in 1:Teval) + for i in 1:length(sims)] final_loss = mean(objective_values) + def_per = [sum(sims[i][t][:deficit] for t in 1:Teval) for i in 1:length(sims)] + served = sum(sum(l["pd"] for l in values(alldata[min(t,length(alldata))]["powersystem"]["load"])) for t in 1:Teval) + mean_def = mean(def_per); pct_def = 100*mean_def/served println("Mean Sim: ", final_loss) - Wandb.log( - lg, - Dict( - "batch" => ITERATION_LIMIT, - "metrics/loss" => bound, - "metrics/final_loss" => final_loss, - "metrics/rollout_realized_objective_no_deficit" => final_loss, - "metrics/final_rollout_realized_objective_no_deficit" => final_loss, - "metrics/elapsed_seconds" => elapsed, - ), - ) - close(lg) + # THE gap: ACP forward cost vs SOCP bound — SAME horizon (NUM_STAGES) on + # both sides. final_loss (first Teval stages) is reported separately and + # must never be compared to the bound. + println("FINAL bound_T$(NUM_STAGES)=$(bound) fwd_T$(NUM_STAGES)=$(full_loss) ", + "GAP_T$(NUM_STAGES)=$(round(100*(full_loss-bound)/abs(bound);digits=3))% ", + "fwd_first$(Teval)=$(final_loss) ", + "deficit=$(round(mean_def*100;digits=2))MW-stage pct_deficit=$(round(pct_def;digits=4))% elapsed=$(elapsed)") + if lg !== nothing + Wandb.log(lg, Dict("batch"=>ITERATION_LIMIT, "metrics/loss"=>bound, "metrics/final_loss"=>full_loss, + "metrics/rollout_realized_objective_no_deficit"=>full_loss, + "metrics/final_rollout_realized_objective_no_deficit"=>full_loss, + "metrics/elapsed_seconds"=>elapsed, "metrics/gap_pct"=>100*(full_loss-bound)/abs(bound), + "metrics/deficit_pct"=>pct_def)) + close(lg) + end end main() diff --git a/examples/HydroPowerModels/sddp/sddp_ac_starts.jl b/examples/HydroPowerModels/sddp/sddp_ac_starts.jl new file mode 100644 index 0000000..5021f80 --- /dev/null +++ b/examples/HydroPowerModels/sddp/sddp_ac_starts.jl @@ -0,0 +1,257 @@ +# sddp_ac_starts.jl — robust primal starts for ACP forward-pass subproblems. +# +# HydroPowerModels' `rainfall_noises` parameterize block fills a primal start of +# `sp.ext[:lower_bound] = 0.0` into every variable whose start is `nothing` +# (see HydroPowerModels/src/constraint.jl). For the polar-AC forward graph this +# includes the voltage magnitudes, and ``v_m = 0`` is a singular point of the +# polar power-flow equations (every ``v_i v_j \cos(\theta_i-\theta_j)`` term and +# its Jacobian vanish), so MadNLP can fail from that start at stressed +# operating points even though the subproblem is feasible — the identical +# subproblem dumped to MOF (which carries no starts) solves in milliseconds. +# Observed as `Unable to retrieve solution from node 22` on the seasonal-demand +# case (2026-07-15). +# +# The fix: preset every start BEFORE training so the package's fill-in loop +# never runs — flat-voltage ``v_m = 1`` for magnitudes, ``0`` for everything +# else (angles, flows, generation, deficit). + +""" + preset_ac_starts!(graph::SDDP.PolicyGraph) + +Set primal start values on every subproblem of `graph`: variables whose name +contains `"_vm"` (polar-AC voltage magnitudes, PowerModels naming `0_vm[...]`) +start at the flat-voltage point ``v_m = 1``; every other variable with no +start yet gets ``0``. Idempotent; call once after `hydro_thermal_operation` +and before `HydroPowerModels.train`. + +# Arguments + +- `graph::SDDP.PolicyGraph`: the (forward) policy graph whose stage + subproblems are polar-AC OPF models. + +# Example + +```julia +m = hydro_thermal_operation(alldata, params) +preset_ac_starts!(m.forward_graph) # forward pass = ACPPowerModel/MadNLP +HydroPowerModels.train(m; iteration_limit = 100) +``` +""" +function preset_ac_starts!(graph) + # count how many voltage-magnitude variables were preset (sanity print) + n_vm = 0 + # every stage node holds one JuMP subproblem + for (_, node) in graph.nodes + sp = node.subproblem + # walk all variables of the stage subproblem once + for v in JuMP.all_variables(sp) + nm = JuMP.name(v) + if occursin("_vm", nm) + # flat-voltage start: the standard non-singular AC initial point + JuMP.set_start_value(v, 1.0) + n_vm += 1 + elseif JuMP.start_value(v) === nothing + # preserve the package's historical default for the rest + JuMP.set_start_value(v, 0.0) + end + end + end + println("preset_ac_starts!: $n_vm voltage-magnitude starts set to 1.0") + return nothing +end + +""" + make_robust_recovery(ac_optimizer::Function, conic_optimizer::Function) + +Return a `numerical_difficulty_callback` for SDDP (install the result with +`graph.ext[:numerical_difficulty_callback] = cb` on BOTH policy graphs). + +SDDP's default recovery makes a single `MOI.Utilities.reset_optimizer` + +re-solve attempt. On the stressed seasonal-demand case two failure modes +survive it: (a) intermittent MadNLP non-convergence from bad iterates at +near-peak load, and (b) a swallowed solver exception that leaves the caching +layer optimizer-less (`OPTIMIZE_NOT_CALLED` / `NoOptimizer`). The returned +callback escalates through: + +1. plain `reset_optimizer` + re-solve (the SDDP default); +2. **re-attach a brand-new solver instance** (`ac_optimizer()` for polar-AC + subproblems — detected by `_vm` variables — `conic_optimizer()` otherwise) + and restart from the flat-voltage point (``v_m = 1``, all else ``0``); +3. for CONIC subproblems only, one further rung per factory in + `conic_variants`: a brand-new solver that differs **only** in its static + regularization, at unchanged feasibility/gap tolerances. + +Rung 3 exists because rungs 1 and 2 are numerically IDENTICAL — same tolerances, +same regularization — so a solve that fails on a knife-edge reproduces the same +failure on both. Diagnosis of a node-122 `ALMOST_OPTIMAL` abort observed on one +Bolivia-scale conic subproblem showed the failure is a narrow, instance-specific +resonance of the cut-augmented KKT system: on that exact instance +`static_regularization_constant` values of 1e-11, 3e-11, 3e-10 and 1e-9 all +terminate literal `OPTIMAL` while 1e-10 alone returns `ALMOST_OPTIMAL`, and the +objectives agree to ~1e-7 relative. Because the resonance is instance-specific, +no single global regularization is durable; retrying the SAME solve at a +different regularization is. + +**This is not a tolerance relaxation.** `tol_feas`, `tol_gap_abs` and +`tol_gap_rel` are unchanged across every rung, `StrictConicDuality` still +requires literal `OPTIMAL` before a cut is read, and a rung is accepted only if +it genuinely reaches `OPTIMAL`. An earlier revision of this docstring described a +rung that loosened the tolerance to ``10^{-4}``; that rung does not exist and +must not be reintroduced — loose duals invalidate the SDDP lower bound. + +Every mutation is `try/catch`-guarded so one broken attempt never masks the +next; the callback itself never throws — if all attempts fail, SDDP proceeds +to its own diagnostics dump. + +# Arguments +- `ac_optimizer::Function`: factory for polar-AC (forward) subproblems. +- `conic_optimizer::Function`: factory for conic (backward) subproblems. +- `conic_variants::Vector{<:Function}`: optional extra conic factories, tried in + order after rung 2, differing only in regularization. +""" +function make_robust_recovery(ac_optimizer::Function, conic_optimizer::Function; + conic_variants::Vector{<:Function} = Function[]) + return function (model, node; require_dual::Bool = false) + sp = node.subproblem + # polar-AC subproblems carry voltage-magnitude variables named `*_vm*` + is_ac = any(v -> occursin("_vm", JuMP.name(v)), JuMP.all_variables(sp)) + # a solve "worked" when SDDP can read a primal (and, if required, dual). + # For CUT solves the dual must come from a solve that terminated + # OPTIMAL — SDDP's own predicate accepts NEARLY_FEASIBLE_POINT duals, + # which is exactly the invalid-cut hazard we are excluding. + solved() = SDDP._has_primal_solution(node) && + !(require_dual && !(SDDP._has_dual_solution(node) && + JuMP.termination_status(sp) == JuMP.OPTIMAL)) + # No TOLERANCE ladder is permitted: loose cut duals invalidate the SDDP + # lower bound and loose forward solves contaminate the states on which + # cuts are sampled. Regularization variants (rung 3+) are a different + # thing — they change only the KKT regularization, leaving every + # feasibility/gap tolerance at its strict value, and are accepted only on + # a literal OPTIMAL termination. See the docstring for the node-122 + # evidence motivating them. + # AC voltage-magnitude start seeds for the multi-start rungs. Polar-AC is + # nonconvex, so MadNLP can converge to a LOCALLY-infeasible point from one + # flat start even when the subproblem is feasible (the wait-and-see solve + # of the identical horizon confirms feasibility). Retrying from a DIFFERENT + # voltage level escapes that basin. This changes only the primal START, not + # any tolerance — a rung is still accepted only on OPTIMAL/LOCALLY_SOLVED + # with a primal, so it cannot invalidate anything. + ac_vm_seeds = [1.0, 1.05, 0.95, 1.10, 0.90, 1.03] + # AC: attempt 1 = reset, attempts 2..(1+nseeds) = fresh solver at each seed. + # Conic: attempt 1 = reset, 2 = fresh solver, 3.. = regularization variants. + n_attempts = is_ac ? (1 + length(ac_vm_seeds)) : (2 + length(conic_variants)) + for attempt in 1:n_attempts + try + if attempt == 1 + # cheapest first: fresh copy of the cached problem data + MOI.Utilities.reset_optimizer(sp) + else + # hard reset: brand-new solver object (cures NoOptimizer / + # poisoned internal state that reset_optimizer keeps). + # attempt >= 3 additionally swaps in a regularization variant + # (conic) or a fresh voltage seed (AC) so the retry is not + # numerically identical to rung 2. + # NOTE: a variant attached here PERSISTS on this subproblem + # for its later solves (JuMP.set_optimizer is sticky, and + # restoring the base factory would discard the solution we + # just recovered). That is path-dependent but safe: every + # rung uses the same strict tolerances and a cut is still + # only built from a literal OPTIMAL termination. + factory = if is_ac + ac_optimizer # AC: same solver, vary the start + elseif attempt == 2 + conic_optimizer + else + conic_variants[attempt-2] + end + JuMP.set_optimizer(sp, factory) + # AC multi-start: rung 2 uses vm=1 (flat), later rungs sweep + # ac_vm_seeds. Conic: flat restart (vm term absent anyway). + vm_start = is_ac ? ac_vm_seeds[attempt-1] : 1.0 + for v in JuMP.all_variables(sp) + JuMP.set_start_value(v, occursin("_vm", JuMP.name(v)) ? vm_start : 0.0) + end + end + JuMP.optimize!(sp) + catch err + # loud escalation — silent failures cost debugging rounds + println("[recovery] node=", node.index, " rung=", attempt, + " THREW: ", sprint(showerror, err)[1:min(end, 200)]) + end + try + st = JuMP.termination_status(sp) + println("[recovery] node=", node.index, " rung=", attempt, + " status=", st, " primal=", JuMP.primal_status(sp), + " dual=", JuMP.dual_status(sp)) + acceptable = is_ac ? + (st in (JuMP.OPTIMAL, JuMP.LOCALLY_SOLVED) && SDDP._has_primal_solution(node)) : + (st == JuMP.OPTIMAL && solved()) + acceptable && return + catch + end + end + error("strict numerical recovery failed at node $(node.index); aborting to preserve bound integrity") + end +end + +# ── Fail-closed backward-cut duality handler ──────────────────────────────────── +# +# THE HAZARD. SDDP's default `ContinuousConicDuality` reads cut duals whenever +# `SDDP._has_dual_solution(node)` is true, and that predicate accepts BOTH +# `FEASIBLE_POINT` and `NEARLY_FEASIBLE_POINT` (algorithm.jl). A backward +# cut-generating solve that terminates `ALMOST_OPTIMAL` / `ALMOST_SOLVED` +# (Clarabel) reports `dual_status == NEARLY_FEASIBLE_POINT`, so SDDP silently +# builds a cut from the loose dual and NEVER invokes the numerical-difficulty +# recovery callback. Iteration-limit, infeasible, or numerically-failed solves +# with a stale near-feasible dual are the same hazard. A cut from a non-OPTIMAL +# dual is not a valid outer approximation and corrupts the SDDP lower bound. +# +# `StrictConicDuality` closes this: before any cut dual is read it requires the +# backward subproblem to have terminated **literal `OPTIMAL`**. If not, it runs +# the robust recovery ladder (fresh solver, flat-voltage restart — the same one +# installed as the numerical-difficulty callback, which itself requires OPTIMAL), +# then re-checks. If the solve still is not OPTIMAL it raises an explicit +# diagnostic and aborts training instead of emitting an invalid cut. +""" + StrictConicDuality(optimizer = nothing) <: SDDP.AbstractDualityHandler + +Drop-in replacement for `SDDP.ContinuousConicDuality` that refuses to generate a +cut from a backward solve whose termination status is not literal `MOI.OPTIMAL` +(rejecting `ALMOST_OPTIMAL`, iteration-limit, infeasible, and numerically-failed +solves whose near-feasible dual SDDP would otherwise silently accept). Pass it as +`duality_handler = StrictConicDuality()` to `SDDP.train` / `HydroPowerModels.train`. +Delegates `prepare_backward_pass`, `duality_log_key`, and the actual dual read to +an inner `ContinuousConicDuality`. +""" +struct StrictConicDuality <: SDDP.AbstractDualityHandler + inner::SDDP.ContinuousConicDuality +end +StrictConicDuality(optimizer = nothing) = + StrictConicDuality(SDDP.ContinuousConicDuality(optimizer)) + +SDDP.prepare_backward_pass(node::SDDP.Node, h::StrictConicDuality, options::SDDP.Options) = + SDDP.prepare_backward_pass(node, h.inner, options) + +SDDP.duality_log_key(::StrictConicDuality) = "!" # marks strict-cut mode in the log + +function SDDP.get_dual_solution(node::SDDP.Node, h::StrictConicDuality) + sp = node.subproblem + st = JuMP.termination_status(sp) + if st != JuMP.OPTIMAL + # Non-OPTIMAL cut-generating solve: force the recovery ladder (re-solve to + # literal OPTIMAL) rather than let SDDP accept a NEARLY_FEASIBLE_POINT dual. + model = sp.ext[:sddp_policy_graph] + SDDP.attempt_numerical_recovery(model, node; require_dual = true) + st = JuMP.termination_status(sp) + end + if st != JuMP.OPTIMAL + error( + "Fail-closed backward cut: node $(node.index) solve terminated $(st) " * + "(primal=$(JuMP.primal_status(sp)), dual=$(JuMP.dual_status(sp))). " * + "Refusing to build a cut from a non-OPTIMAL solve — this would " * + "invalidate the SDDP lower bound. Investigate solver tolerances / " * + "conditioning at this node instead of continuing.", + ) + end + return SDDP.get_dual_solution(node, h.inner) +end diff --git a/examples/HydroPowerModels/sddp/simulate_sddp_policy.jl b/examples/HydroPowerModels/sddp/simulate_sddp_policy.jl deleted file mode 100644 index a392de6..0000000 --- a/examples/HydroPowerModels/sddp/simulate_sddp_policy.jl +++ /dev/null @@ -1,161 +0,0 @@ -# Simulate a pre-trained SDDP policy (cuts from run_sddp_inconsistent.jl) under -# the ACP formulation and produce comparison plots/CSVs against TS-DDR baselines. -using MadNLP -using HydroPowerModels -using JuMP -using PowerModels -using Statistics -using SDDP: SDDP - -using Random -seed = 1221 - -# Load case -case = "bolivia" -case_dir = joinpath(dirname(@__DIR__), case) -alldata = HydroPowerModels.parse_folder(case_dir); -for load in values(alldata[1]["powersystem"]["load"]) - load["qd"] = load["qd"] * 0.6 - load["pd"] = load["pd"] * 0.6 -end -rm_stages = 30 -num_stages = 96 + rm_stages -formulation = ACPPowerModel -formulation_b = SOCWRConicPowerModel - -params = create_param(; - stages=num_stages, - model_constructor_grid=formulation, - post_method=PowerModels.build_opf, - optimizer=() -> MadNLP.Optimizer(; print_level=0), -); - -m = hydro_thermal_operation(alldata, params); - -# Load pre-trained cuts -SDDP.read_cuts_from_file( - m.forward_graph, - joinpath( - case_dir, - string(formulation), - string(formulation_b)*"-"*string(formulation)*".cuts.json", - ), -) - -# Simulate -Random.seed!(seed) -num_sim = 100 -results = HydroPowerModels.simulate(m, num_sim); - -# Plotting -nhyd = alldata[1]["hydro"]["nHyd"] -using Plots -using CSV -using DataFrames -volume_to_mw(volume, stage_hours; k=0.0036) = volume / (k * stage_hours) - -const SDDP_COL = "SDDP-SOC" -labels = ["TS-DDR"; "TS-LDR"; "SDDP-DCLL"; SDDP_COL] -colors = [:black :purple :red :orange] -markers = [:hline :+ :pixel :diamond] - -const DOCS_ASSETS = joinpath(dirname(@__DIR__), "..", "..", "docs", "src", "assets") -mkpath(DOCS_ASSETS) -out_dir = joinpath(case_dir, string(formulation)) - -# Volume trajectory -hydro_gen = [ - mean( - sum( - volume_to_mw(results[:simulations][i][t][:reservoirs][:reservoir][j].out, 1) for - j in 1:nhyd - ) for i in 1:num_sim - ) for t in 1:(num_stages - rm_stages) -] - -savefig( - plot( - hydro_gen; - legend=false, - xlabel="Stage", - ylabel="Volume (Hm3)", - title="$(case)-$(formulation_b)-$(formulation)", - ), - joinpath(out_dir, "SDDP-$(case)-$(formulation_b)-$(formulation)-Volume.png"), -) - -df = CSV.read(joinpath(out_dir, "MeanVolume.csv"), DataFrame; header=true) -df[!, SDDP_COL] = hydro_gen -CSV.write(joinpath(out_dir, "MeanVolume.csv"), df) - -savefig( - plot( - Matrix(df[!, labels]); - labels=permutedims(labels), - xlabel="Stage", - ylabel="Expected Volume (MWh)", - color=colors, - shape=markers, - title="Reservoir Volume Comparison", - ), - joinpath(DOCS_ASSETS, "hydro_volume_comparison.png"), -) - -# Thermal generation -num_gen = length(results[:simulations][1][1][:powersystem]["solution"]["gen"]) -hydro_idx = HydroPowerModels.idx_hydro(results[:data][1]) -thermal_gen = [ - mean( - sum( - results[:simulations][i][t][:powersystem]["solution"]["gen"]["$j"]["pg"] * - results[:data][1]["powersystem"]["baseMVA"] for - j in 1:num_gen if !(j in hydro_idx) - ) for i in 1:num_sim - ) for t in 1:(num_stages - rm_stages) -] - -savefig( - plot( - thermal_gen; - legend=false, - xlabel="Stage", - ylabel="Mwh", - title="Thermal-Generation $(case)-$(formulation_b)-$(formulation)", - ), - joinpath(out_dir, "SDDP-$(case)-$(formulation_b)-$(formulation)-thermal.png"), -) - -df = CSV.read(joinpath(out_dir, "MeanGeneration.csv"), DataFrame) -df[!, SDDP_COL] = thermal_gen -CSV.write(joinpath(out_dir, "MeanGeneration.csv"), df) - -savefig( - plot( - Matrix(df[!, labels]); - labels=permutedims(labels), - xlabel="Stage", - ylabel="Expected Thermal Generation (MWh)", - color=colors, - shape=markers, - title="Thermal Generation Comparison", - ), - joinpath(DOCS_ASSETS, "hydro_generation_comparison.png"), -) - -# Objective costs -objective_values = [ - sum(results[:simulations][i][t][:stage_objective] for t in 1:(num_stages - rm_stages)) - for i in 1:length(results[:simulations]) -] - -costs_file = joinpath(out_dir, "costs.csv") -if isfile(costs_file) - df = CSV.read(costs_file, DataFrame) - df[!, SDDP_COL] = objective_values -else - df = DataFrame(Symbol(SDDP_COL) => objective_values) -end -CSV.write(costs_file, df) - -println("Mean Sim: ", mean(objective_values)) -println("Std Sim: ", std(objective_values)) diff --git a/examples/HydroPowerModels/test_sampling_consistency.jl b/examples/HydroPowerModels/test_sampling_consistency.jl deleted file mode 100644 index 0bbe997..0000000 --- a/examples/HydroPowerModels/test_sampling_consistency.jl +++ /dev/null @@ -1,166 +0,0 @@ -# test_sampling_consistency.jl -# -# Verifies that DecisionRules.jl and the ExaModels companion package -# (DecisionRulesExa.jl) sample from the exact same inflow distribution -# as SDDP.jl for the Bolivia HydroPowerModels case. -# -# All three systems read the same inflows.csv and hydro.json files. -# The sampling contract is: -# -# At each stage t, draw one scenario index ω ∈ {1, …, nScenarios} -# uniformly at random. All hydro reservoirs receive the inflow from -# column ω of the historical data for their respective row t. -# Stages are sampled independently (no temporal correlation). -# -# This is SDDP.jl's `SDDP.parameterize` semantics: one ω per node, -# applied to all random variables in that node. -# -# What this script checks: -# 1. Both loaders parse inflows.csv into identical per-reservoir matrices. -# 2. Both samplers produce draws from the same support (only historically -# observed joint vectors, never cross-scenario combinations). -# 3. With the same RNG seed, both produce identical trajectories. -# -# Usage: -# julia --project=. test_sampling_consistency.jl (from this dir) -# julia --project=. test_sampling_consistency.jl /path/to/DecisionRulesExa.jl/examples/HydroPowerModels - -using Test -using Random -using CSV, Tables, JSON - -# ── Paths ──────────────────────────────────────────────────────────────────── - -const SCRIPT_DIR = dirname(@__FILE__) -const CASE_DIR = joinpath(SCRIPT_DIR, "bolivia") -const INFLOW_FILE = joinpath(CASE_DIR, "inflows.csv") -const HYDRO_FILE = joinpath(CASE_DIR, "hydro.json") - -const EXA_DIR = length(ARGS) >= 1 ? ARGS[1] : - joinpath(dirname(dirname(dirname(SCRIPT_DIR))), - "..", "DecisionRulesExa.jl", "examples", "HydroPowerModels") - -# ── 1. Parse inflows with both loaders ─────────────────────────────────────── - -# DecisionRules.jl loader (load_hydropowermodels.jl::read_inflow) -function dr_read_inflow(file, nHyd; num_stages=nothing) - allinflows = CSV.read(file, Tables.matrix; header=false) - nlin, ncol = size(allinflows) - if isnothing(num_stages) - num_stages = nlin - elseif num_stages > nlin - number_of_cycles = div(num_stages, nlin) + 1 - allinflows = vcat([allinflows for _ in 1:number_of_cycles]...) - end - nCen = Int(floor(ncol / nHyd)) - vector_inflows = [allinflows[1:num_stages, ((i-1)*nCen+1):(i*nCen)] for i in 1:nHyd] - return vector_inflows, nCen, num_stages -end - -# ExaModels loader (hydro_power_data.jl::load_hydro_data, inflow portion only) -function exa_read_inflow(file, nHyd; num_stages=nothing) - allinflows = CSV.read(file, Tables.matrix; header=false) - nrows, ncols = size(allinflows) - nScenarios = div(ncols, nHyd) - nStagesSample = isnothing(num_stages) ? nrows : num_stages - if !isnothing(num_stages) && num_stages > nrows - repeats = div(num_stages, nrows) + 1 - allinflows = vcat([allinflows for _ in 1:repeats]...) - end - allinflows = allinflows[1:nStagesSample, :] - scenario_inflows = [Float64.(allinflows[:, ((r-1)*nScenarios+1):(r*nScenarios)]) for r in 1:nHyd] - return scenario_inflows, nScenarios, nStagesSample -end - -# ── 2. Sampler implementations (extracted, no package dependencies) ────────── - -function dr_sample_joint(vector_inflows, nCen, T) - nHyd = length(vector_inflows) - trajectory = Vector{Vector{Float64}}(undef, T) - for t in 1:T - ω = rand(1:nCen) - trajectory[t] = [vector_inflows[r][t, ω] for r in 1:nHyd] - end - return trajectory -end - -function exa_sample_scenario(scenario_inflows, nScenarios, T) - nHyd = length(scenario_inflows) - nStagesSample = size(scenario_inflows[1], 1) - w = Vector{Float64}(undef, T * nHyd) - for t in 1:T - t_row = mod1(t, nStagesSample) - j = rand(1:nScenarios) - for r in 1:nHyd - w[(t-1)*nHyd + r] = scenario_inflows[r][t_row, j] - end - end - return w -end - -# ── Tests ──────────────────────────────────────────────────────────────────── - -hydro_json = JSON.parsefile(HYDRO_FILE)["Hydrogenerators"] -nHyd = length(hydro_json) -T = 96 - -@testset "Sampling consistency: DecisionRules vs Exa vs SDDP" begin - dr_inflows, dr_nCen, dr_T = dr_read_inflow(INFLOW_FILE, nHyd; num_stages=T) - exa_inflows, exa_nScen, exa_T = exa_read_inflow(INFLOW_FILE, nHyd; num_stages=T) - - @testset "identical inflow matrices" begin - @test dr_nCen == exa_nScen - @test dr_T == exa_T - for r in 1:nHyd - @test dr_inflows[r] == exa_inflows[r] - end - end - - @testset "same seed → identical trajectories" begin - for seed in [42, 123, 9999] - Random.seed!(seed) - dr_traj = dr_sample_joint(dr_inflows, dr_nCen, T) - - Random.seed!(seed) - exa_flat = exa_sample_scenario(exa_inflows, exa_nScen, T) - - for t in 1:T - for r in 1:nHyd - @test dr_traj[t][r] == exa_flat[(t-1)*nHyd + r] - end - end - end - end - - @testset "samples are always from historical scenarios (joint)" begin - valid_vectors = Set{Vector{Float64}}() - for t in 1:T, ω in 1:dr_nCen - push!(valid_vectors, [dr_inflows[r][t, ω] for r in 1:nHyd]) - end - - Random.seed!(42) - for _ in 1:500 - traj = dr_sample_joint(dr_inflows, dr_nCen, T) - for stage_vec in traj - @test stage_vec in valid_vectors - end - end - end - - @testset "uniform coverage of all scenarios" begin - Random.seed!(42) - N = 10_000 - counts = zeros(Int, dr_nCen) - for _ in 1:N - ω = rand(1:dr_nCen) - counts[ω] += 1 - end - for ω in 1:dr_nCen - freq = counts[ω] / N - expected = 1.0 / dr_nCen - @test abs(freq - expected) < 0.03 - end - end -end - -println("\nAll sampling consistency tests passed.") diff --git a/examples/HydroPowerModels/train_dr_hydropowermodels.jl b/examples/HydroPowerModels/train_dr_hydropowermodels.jl deleted file mode 100644 index ad6876c..0000000 --- a/examples/HydroPowerModels/train_dr_hydropowermodels.jl +++ /dev/null @@ -1,256 +0,0 @@ -# Train HydroPowerModels using Deterministic Equivalent formulation (GPU-enabled) -using DecisionRules -using Statistics -using Random -using Flux - -using Ipopt -using Wandb, Dates, Logging -using JLD2 -using DiffOpt -using JuMP -using MadNLP - -USE_GPU = try - using CUDA, CUDSS, MadNLPGPU - CUDA.functional() -catch - @warn "GPU packages not available — running on CPU" - false -end -@info "GPU status" USE_GPU - -HydroPowerModels_dir = dirname(@__FILE__) -include(joinpath(HydroPowerModels_dir, "load_hydropowermodels.jl")) - -# Functions - -function non_ensurance(x_out, x_in, uncertainty, max_volume) - return x_out -end - -# Parameters -case_name = "bolivia" # bolivia, case3 -formulation = "ACPPowerModel" # SOCWRConicPowerModel, DCPPowerModel, ACPPowerModel -num_stages = parse(Int, get(ENV, "DR_NUM_STAGES", "126")) -model_dir = joinpath(HydroPowerModels_dir, case_name, formulation, "models") -mkpath(model_dir) -solver_tag = USE_GPU ? "gpu" : "cpu" -formulation_file = formulation * ".mof.json" - -# Training parameters -num_epochs = parse(Int, get(ENV, "DR_NUM_EPOCHS", "80")) -num_batches = 100 -_num_train_per_batch = 1 -activation = sigmoid # tanh, identity, relu, sigmoid -layers = Int64[128, 128] -ensure_feasibility = non_ensurance -grad_clip = parse(Float32, get(ENV, "DR_GRAD_CLIP", "0")) -optimizers = if grad_clip > 0 - [Flux.Optimisers.OptimiserChain(Flux.Optimisers.ClipGrad(grad_clip), Flux.Adam())] -else - [Flux.Adam()] -end -pre_trained_model = nothing -penalty_l2 = :auto -penalty_l1 = :auto -penalty_schedule = if get(ENV, "DR_PENALTY_SCHEDULE", "annealed") == "annealed" - :default_annealed -else - nothing -end -clip_tag = grad_clip > 0 ? "-clip$(Int(grad_clip))" : "" -sched_tag = isnothing(penalty_schedule) ? "-const" : "-anneal" -save_file = "$(case_name)-$(formulation)-h$(num_stages)-deteq-$(solver_tag)$(clip_tag)$(sched_tag)-$(now())" -num_eval_scenarios = 4 -eval_every = 25 - -# Build MSP: subproblems for rollout evaluation (stage-wise, CPU, with DiffOpt) -diff_optimizer = - () -> DiffOpt.diff_optimizer( - optimizer_with_attributes( - Ipopt.Optimizer, - "print_level" => 0, - "linear_solver" => "mumps", - ), - ) -subproblems, state_params_in_sub, state_params_out_sub, uncertainty_samples_sub, initial_state, max_volume = build_hydropowermodels( - joinpath(HydroPowerModels_dir, case_name), - formulation_file; - num_stages=num_stages, - optimizer=diff_optimizer, - penalty_l1=penalty_l1, - penalty_l2=penalty_l2, -) - -# Build det-eq for training -subproblems_de, state_params_in, state_params_out, uncertainty_samples, _, _ = build_hydropowermodels( - joinpath(HydroPowerModels_dir, case_name), - formulation_file; - num_stages=num_stages, - penalty_l1=penalty_l1, - penalty_l2=penalty_l2, -) - -det_equivalent = Model(MadNLP.Optimizer) - -if USE_GPU - set_optimizer_attribute(det_equivalent, "array_type", CUDA.CuArray) - set_optimizer_attribute(det_equivalent, "linear_solver", MadNLPGPU.CUDSSSolver) - set_optimizer_attribute(det_equivalent, "print_level", MadNLP.ERROR) - set_optimizer_attribute(det_equivalent, "barrier", MadNLP.LOQOUpdate()) -else - set_optimizer_attribute(det_equivalent, "print_level", MadNLP.ERROR) - set_optimizer_attribute(det_equivalent, "barrier", MadNLP.LOQOUpdate()) - # set_optimizer_attribute(det_equivalent, "linear_solver", MadNLPGPU.LapackCPUSolver()) -end - -det_equivalent, uncertainty_samples = DecisionRules.deterministic_equivalent!( - det_equivalent, - subproblems_de, - state_params_in, - state_params_out, - initial_state, - uncertainty_samples, -) - -num_hydro = length(initial_state) - -# Logging -lg = WandbLogger(; - project="RL", - name=save_file, - save_code=false, - config=Dict( - "layers" => layers, - "activation" => string(activation), - "encoder_type" => "LSTM", - "ensure_feasibility" => string(ensure_feasibility), - "optimizer" => string(optimizers), - "grad_clip" => grad_clip, - "training_method" => "deterministic_equivalent", - "solver" => USE_GPU ? "MadNLP+CUDSS (GPU)" : "MadNLP (CPU)", - "penalty_l1" => string(penalty_l1), - "penalty_l2" => string(penalty_l2), - "penalty_schedule" => string(penalty_schedule), - "num_epochs" => string(num_epochs), - "num_batches" => string(num_batches), - "num_train_per_batch" => string(_num_train_per_batch), - "num_eval_scenarios" => num_eval_scenarios, - "eval_every" => eval_every, - "use_gpu" => USE_GPU, - ), -) - -# Define Model -num_uncertainties = length(uncertainty_samples[1][1]) -models = state_conditioned_policy( - num_uncertainties, - num_hydro, - num_hydro, - layers; - activation=activation, - encoder_type=Flux.LSTM, -) - -# Load pretrained Model -if !isnothing(pre_trained_model) - model_save = JLD2.load(pre_trained_model) - model_state = model_save["model_state"] - Flux.loadmodel!(models, model_state) -end - -# Initial evaluation -Random.seed!(8788) -@time objective_values = [ - simulate_multistage( - det_equivalent, - state_params_in, - state_params_out, - initial_state, - DecisionRules.sample(uncertainty_samples), - models; - ) for _ in 1:2 -] -best_obj = mean(objective_values) - -model_path = joinpath(model_dir, save_file * ".jld2") -save_control = SaveBest(best_obj, model_path) -stall_train = StallingCriterium(num_epochs * num_batches, best_obj, 0) -stall_rollout = StallingCriterium(num_epochs * num_batches, best_obj, 0) - - -# Rollout evaluation (stage-wise subproblems, CPU) -Random.seed!(8789) -eval_scenarios = [ - DecisionRules.sample(uncertainty_samples_sub) for _ in 1:num_eval_scenarios -] -rollout_evaluation = RolloutEvaluation( - subproblems, - state_params_in_sub, - state_params_out_sub, - initial_state, - eval_scenarios; - stride=eval_every, - policy_state=:target, -) -realized_rollout_evaluation = RolloutEvaluation( - subproblems, - state_params_in_sub, - state_params_out_sub, - initial_state, - eval_scenarios; - stride=eval_every, - policy_state=:realized, -) -resolved_penalty_schedule = isnothing(penalty_schedule) ? nothing : - DecisionRules._resolve_penalty_schedule(penalty_schedule, num_epochs * num_batches) - -# Train Model using deterministic equivalent. -train_multistage( - models, - initial_state, - det_equivalent, - state_params_in, - state_params_out, - uncertainty_samples; - num_batches=num_epochs * num_batches, - num_train_per_batch=_num_train_per_batch, - optimizer=first(optimizers), - record=(sample_log, iter, model) -> begin - training_loss = mean(sample_log.objectives) - loss_no_deficit = mean(sample_log.objectives_no_deficit) - metrics = Dict( - "metrics/loss" => loss_no_deficit, - "metrics/training_loss" => training_loss, - ) - rollout_evaluation(iter, model) - realized_rollout_evaluation(iter, model) - converged_training = stall_train(iter, model, training_loss) - converged_rollout = false - if iter % eval_every == 0 - converged_rollout = stall_rollout( - iter, model, rollout_evaluation.last_objective_no_deficit - ) - metrics["metrics/rollout_objective_no_deficit"] = - rollout_evaluation.last_objective_no_deficit - metrics["metrics/rollout_target_violation_share"] = - rollout_evaluation.last_violation_share - metrics["metrics/rollout_realized_objective_no_deficit"] = - realized_rollout_evaluation.last_objective_no_deficit - metrics["metrics/rollout_realized_target_violation_share"] = - realized_rollout_evaluation.last_violation_share - end - if !isnothing(resolved_penalty_schedule) - metrics["metrics/target_penalty_multiplier"] = - DecisionRules._penalty_multiplier_for(resolved_penalty_schedule, iter) - end - Wandb.log(lg, metrics) - save_control(iter, model, training_loss) - return converged_training && converged_rollout && isapprox(training_loss, rollout_evaluation.last_objective_no_deficit; rtol=0.01) - end, - penalty_schedule=penalty_schedule, -) - -# Finish the run -close(lg) diff --git a/examples/HydroPowerModels/train_dr_hydropowermodels_multipleshooting.jl b/examples/HydroPowerModels/train_dr_hydropowermodels_multipleshooting.jl deleted file mode 100644 index 906f8e4..0000000 --- a/examples/HydroPowerModels/train_dr_hydropowermodels_multipleshooting.jl +++ /dev/null @@ -1,208 +0,0 @@ -# Train HydroPowerModels using multiple shooting (windowed decomposition) -using DecisionRules -using Statistics -using Random -using Flux - -using Ipopt -using Wandb, Dates, Logging -using JLD2 -using DiffOpt - -HydroPowerModels_dir = dirname(@__FILE__) -include(joinpath(HydroPowerModels_dir, "load_hydropowermodels.jl")) - -# Functions - -function non_ensurance(x_out, x_in, uncertainty, max_volume) - return x_out -end - -# Parameters -case_name = "bolivia" # bolivia, case3 -formulation = "ACPPowerModel" # SOCWRConicPowerModel, DCPPowerModel, ACPPowerModel -num_stages = parse(Int, get(ENV, "DR_NUM_STAGES", "126")) -window_size = 12 # 12, 6 -model_dir = joinpath(HydroPowerModels_dir, case_name, formulation, "models") -mkpath(model_dir) -formulation_file = formulation * ".mof.json" - -# Training parameters -num_epochs = parse(Int, get(ENV, "DR_NUM_EPOCHS", "80")) -num_batches = 100 -_num_train_per_batch = 1 -activation = sigmoid # tanh, identity, relu, sigmoid -layers = Int64[128, 128] -ensure_feasibility = non_ensurance -grad_clip = parse(Float32, get(ENV, "DR_GRAD_CLIP", "0")) -optimizers = if grad_clip > 0 - [Flux.Optimisers.OptimiserChain(Flux.Optimisers.ClipGrad(grad_clip), Flux.Adam())] -else - [Flux.Adam()] -end -pre_trained_model = nothing -penalty_l2 = :auto -penalty_l1 = :auto -penalty_schedule = get(ENV, "DR_PENALTY_SCHEDULE", "annealed") == "annealed" ? :default_annealed : nothing -clip_tag = grad_clip > 0 ? "-clip$(Int(grad_clip))" : "" -sched_tag = isnothing(penalty_schedule) ? "-const" : "-anneal" -save_file = "$(case_name)-$(formulation)-h$(num_stages)-shooting-w$(window_size)$(clip_tag)$(sched_tag)-$(now())" -num_eval_scenarios = 4 -eval_every = 25 - -# Build MSP using subproblems (not deterministic equivalent) - -# Define the DiffOpt optimizer for subproblems and window models -diff_optimizer = - () -> DiffOpt.diff_optimizer( - optimizer_with_attributes( - Ipopt.Optimizer, - "print_level" => 0, - "linear_solver" => "mumps", - ), - ) - -diff_model = - () -> DiffOpt.nonlinear_diff_model( - optimizer_with_attributes( - Ipopt.Optimizer, - "print_level" => 0, - "linear_solver" => "mumps", - ), - ) - -subproblems, state_params_in, state_params_out, uncertainty_samples, initial_state, max_volume = build_hydropowermodels( - joinpath(HydroPowerModels_dir, case_name), - formulation_file; - num_stages=num_stages, - optimizer=diff_optimizer, - penalty_l1=penalty_l1, - penalty_l2=penalty_l2, -) - -num_hydro = length(initial_state) - -# Logging -lg = WandbLogger(; - project="RL", - name=save_file, - save_code=false, - config=Dict( - "layers" => layers, - "activation" => string(activation), - "ensure_feasibility" => string(ensure_feasibility), - "optimizer" => string(optimizers), - "grad_clip" => grad_clip, - "training_method" => "multiple_shooting", - "window_size" => string(window_size), - "penalty_l1" => string(penalty_l1), - "penalty_l2" => string(penalty_l2), - "penalty_schedule" => string(penalty_schedule), - "num_epochs" => string(num_epochs), - "num_batches" => string(num_batches), - "num_train_per_batch" => string(_num_train_per_batch), - ), -) - -# Define Model -# Policy architecture: LSTM processes uncertainty, Dense combines with previous state -num_uncertainties = length(uncertainty_samples[1][1]) -models = state_conditioned_policy( - num_uncertainties, - num_hydro, - num_hydro, - layers; - activation=activation, - encoder_type=Flux.LSTM, -) - -# Load pretrained Model -if !isnothing(pre_trained_model) - model_save = JLD2.load(pre_trained_model) - model_state = model_save["model_state"] - Flux.loadmodel!(models, model_state) -end - -# Initial evaluation -Random.seed!(8788) -windows = DecisionRules.setup_shooting_windows( - subproblems, - state_params_in, - state_params_out, - Float64.(initial_state), - uncertainty_samples; - window_size=window_size, - model_factory=diff_model, -) - -objective_values = [ - begin - uncertainty_sample = DecisionRules.sample(uncertainty_samples) - uncertainties_vec = [ - [Float32(u[2]) for u in stage_u] for stage_u in uncertainty_sample - ] - DecisionRules.simulate_multiple_shooting( - windows, models, Float32.(initial_state), uncertainty_sample, uncertainties_vec - ) - end for _ in 1:2 -] - -best_obj = mean(objective_values) - -model_path = joinpath(model_dir, save_file * ".jld2") -save_control = SaveBest(best_obj, model_path) -convergence_criterium = StallingCriterium(num_epochs * num_batches, best_obj, 0) - -Random.seed!(8789) -eval_scenarios = [DecisionRules.sample(uncertainty_samples) for _ in 1:num_eval_scenarios] -rollout_evaluation = RolloutEvaluation( - subproblems, - state_params_in, - state_params_out, - initial_state, - eval_scenarios; - stride=eval_every, - policy_state=:realized, -) -resolved_penalty_schedule = isnothing(penalty_schedule) ? nothing : - DecisionRules._resolve_penalty_schedule(penalty_schedule, num_epochs * num_batches) -pending_metrics = Dict{String,Any}() - -# Train Model using multiple shooting. -# A single call over num_epochs*num_batches batches so the penalty schedule spans the whole -# run (this also keeps one optimizer state throughout, and a `true` return from the record -# callback now stops the whole run). -train_multiple_shooting( - models, - initial_state, - windows, - uncertainty_samples; - num_batches=num_epochs * num_batches, - num_train_per_batch=_num_train_per_batch, - optimizer=first(optimizers), - record_loss=(iter, model, loss, tag) -> begin - pending_metrics[tag] = loss - if tag == "metrics/training_loss" - rollout_evaluation(iter, model) - if iter % eval_every == 0 - pending_metrics["metrics/rollout_objective_no_deficit"] = - rollout_evaluation.last_objective_no_deficit - pending_metrics["metrics/rollout_target_violation_share"] = - rollout_evaluation.last_violation_share - end - if !isnothing(resolved_penalty_schedule) - pending_metrics["metrics/target_penalty_multiplier"] = - DecisionRules._penalty_multiplier_for(resolved_penalty_schedule, iter) - end - Wandb.log(lg, copy(pending_metrics)) - empty!(pending_metrics) - save_control(iter, model, loss) - return convergence_criterium(iter, model, loss) - end - return false - end, - penalty_schedule=penalty_schedule, -) - -# Finish the run -close(lg) diff --git a/examples/HydroPowerModels/train_dr_hydropowermodels_strict.jl b/examples/HydroPowerModels/train_dr_hydropowermodels_strict.jl new file mode 100644 index 0000000..554e95b --- /dev/null +++ b/examples/HydroPowerModels/train_dr_hydropowermodels_strict.jl @@ -0,0 +1,394 @@ +# Train HydroPowerModels using strict subproblems with reachable policy +# +# Strict mode removes the deficit slack variables from the target constraint: +# reservoir_out[r] = target[r] (hard equality, no penalty) +# The dual λ_r is the clean shadow price ∂Q/∂target — pure economic signal. +# +# This requires HydroReachablePolicy, which guarantees every target is within +# the one-stage reachable set via sigmoid-bounded outputs scaled to physical +# reservoir limits. Stage-wise strict mode is closed-loop: each policy call sees +# the realized state from the previous strict stage solve. +# +# Usage: +# julia --project -t auto train_dr_hydropowermodels_strict.jl +# +# Environment overrides: +# DR_NUM_STAGES=126 number of training stages +# DR_NUM_ROLLOUT_STAGES=96 number of rollout evaluation stages (default: 96, +# matching the Exa strict recipe: train 126 / roll out 96) +# DR_LOAD_SCALER=1.0 demand scaler applied to demand.csv active demand and +# the nominal reactive demand (1.0 = real seasonal +# demand, no 0.6 scaler; parity with DecisionRulesExa) +# DR_DEFICIT_COST=1e5 load-shedding cost per pu (paper recipe 1e5) +# DR_NUM_EPOCHS=80 number of epochs +# DR_NUM_BATCHES=100 gradient steps per epoch (total = epochs * batches) +# DR_ENCODER_LAYERS=128,128 recurrent inflow encoder sizes +# DR_HEAD_LAYERS= nonrecurrent state-conditioned target head sizes +# DR_GRAD_CLIP=0 gradient clipping (0 = disabled) +# DR_NUM_TRAIN_PER_BATCH=1 sampled trajectories per gradient step (variance reduction) +# DR_PRETRAINED_MODEL=path warmstart from a StateConditionedPolicy checkpoint +# DR_CONTEXT= optional known context prepended to the policy input: +# ""/"none" = off, "phase" = seasonal sin/cos, +# "phase+progress" = seasonal sin/cos plus t/T +# DR_NUM_EVAL_SCENARIOS=4 fixed held-out scenarios for rollout evaluation +# DR_EVAL_EVERY=25 rollout-evaluate every this many batches +# DR_SAVE_METRIC=training checkpoint-selection metric: +# "training" — per-batch training loss (historical +# behavior; noisy for small DR_NUM_TRAIN_PER_BATCH) +# "rollout" — mean deficit-free objective of the +# fixed held-out rollout evaluation (the metric +# policies are ultimately judged on; evaluated +# every DR_EVAL_EVERY batches) +# DR_LR=0.001 Adam learning rate +# DR_LR_FINAL=DR_LR final learning rate of a cosine decay across the +# full run (equal to DR_LR → constant, historical) +# DR_LR_WARMUP=0 linear warmup iterations from DR_LR/100 to DR_LR. +# Protects a warmstarted policy from the initial +# full-size Adam steps taken while its second-moment +# estimates are still zero. +# +# Reproducible recipes (also listed in this folder's README): +# From scratch (paper configuration — all defaults): +# julia --project -t auto train_dr_hydropowermodels_strict.jl +# Fine-tune from a converged checkpoint (variance-reduced, decayed LR, +# rollout-selected checkpoints): +# DR_PRETRAINED_MODEL= DR_NUM_TRAIN_PER_BATCH=16 \ +# DR_LR=1e-4 DR_LR_FINAL=1e-5 DR_LR_WARMUP=50 \ +# DR_SAVE_METRIC=rollout DR_NUM_EVAL_SCENARIOS=24 DR_NUM_EPOCHS=15 \ +# julia --project -t auto train_dr_hydropowermodels_strict.jl +using DecisionRules +using Statistics +using Random +using Flux + +using Ipopt +using Wandb, Dates, Logging +using JLD2 +using DiffOpt + +HydroPowerModels_dir = dirname(@__FILE__) +include(joinpath(HydroPowerModels_dir, "load_hydropowermodels.jl")) +include(joinpath(HydroPowerModels_dir, "hydro_reachable_policy.jl")) + +# ── Parameters ─────────────────────────────────────────────────────────────── + +case_name = "bolivia" +formulation = "ACPPowerModel" +num_stages = parse(Int, get(ENV, "DR_NUM_STAGES", "126")) +# Default rollout horizon 96 (train 126 / evaluate 96) — the paired-evaluation +# protocol shared with the SDDP baseline and DecisionRulesExa's strict trainer. +num_rollout_stages = parse(Int, get(ENV, "DR_NUM_ROLLOUT_STAGES", "96")) +# Demand scaler: 1.0 = real seasonal demand.csv, no historical 0.6 down-scaling. +load_scaler = parse(Float64, get(ENV, "DR_LOAD_SCALER", "1.0")) +# Load-shedding cost per pu; 1e5 is the paper recipe shared with DecisionRulesExa. +deficit_cost = parse(Float64, get(ENV, "DR_DEFICIT_COST", "1e5")) +model_dir = joinpath(HydroPowerModels_dir, case_name, formulation, "models") +mkpath(model_dir) +formulation_file = formulation * ".mof.json" +num_epochs = parse(Int, get(ENV, "DR_NUM_EPOCHS", "80")) +# Gradient steps per epoch. Configurable so the documented smoke test is +# genuinely small: the total update budget is num_epochs * num_batches, and with +# this fixed at 100 a "2-epoch" run was still 200 updates. +num_batches = parse(Int, get(ENV, "DR_NUM_BATCHES", "100")) +# Trajectories sampled per gradient step; >1 averages the per-sample dual +# gradients, reducing estimator variance at proportionally higher solve cost. +_num_train_per_batch = parse(Int, get(ENV, "DR_NUM_TRAIN_PER_BATCH", "1")) +""" + parse_layers(s::AbstractString) -> Vector{Int64} + +Parse comma-separated policy architecture settings from environment variables. + +`DR_ENCODER_LAYERS` controls the recurrent inflow encoder. `DR_HEAD_LAYERS` +controls optional hidden layers in the nonrecurrent state-conditioned target +head. An empty string means no extra hidden head layers, preserving the +historical single sigmoid head. + +# Arguments +- `s::AbstractString`: comma-separated layer widths. + +# Returns +- `Vector{Int64}`: parsed hidden widths; `Int64[]` when `s` is empty. + +# Examples +```julia +parse_layers("256, 256") == Int64[256, 256] +parse_layers("") == Int64[] +``` +""" +parse_layers(s::AbstractString) = + isempty(strip(s)) ? Int64[] : [parse(Int64, strip(x)) for x in split(s, ",") if !isempty(strip(x))] +layers = parse_layers(get(ENV, "DR_ENCODER_LAYERS", get(ENV, "DR_LAYERS", "128,128"))) +head_layers = parse_layers(get(ENV, "DR_HEAD_LAYERS", "")) +grad_clip = parse(Float32, get(ENV, "DR_GRAD_CLIP", "0")) + +function canonical_context_mode(raw_mode::AbstractString) + mode = lowercase(strip(raw_mode)) + mode in ("", "none", "off", "false") && return "" + mode in ("phase", "phase+progress") && return mode + error("DR_CONTEXT must be \"\", \"phase\", or \"phase+progress\"; got \"$raw_mode\"") +end + +function build_stage_context(mode::AbstractString, horizon::Int, period::Int) + isempty(mode) && return nothing + include_progress = mode == "phase+progress" + return DecisionRules.stage_phase_context( + horizon; + period=period, + include_progress=include_progress, + ) +end + +function context_run_tag(mode::AbstractString) + isempty(mode) && return "" + return "-ctx" * replace(mode, "+" => "p") +end + +context_mode = canonical_context_mode(get(ENV, "DR_CONTEXT", "")) +context_period = countlines(joinpath(HydroPowerModels_dir, case_name, "inflows.csv")) +stage_context = build_stage_context(context_mode, num_stages, context_period) +n_context = isnothing(stage_context) ? 0 : size(stage_context, 1) + +# ── Learning-rate schedule ─────────────────────────────────────────────────── +# lr(iter) = linear warmup from lr_init/100 over `lr_warmup` iterations, then +# cosine decay from lr_init to lr_final across the remaining budget. With the +# defaults (warmup = 0, lr_final = lr_init) this is a constant lr_init, +# reproducing the historical behavior exactly. +lr_init = parse(Float64, get(ENV, "DR_LR", "0.001")) +lr_final = parse(Float64, get(ENV, "DR_LR_FINAL", string(lr_init))) +lr_warmup = parse(Int, get(ENV, "DR_LR_WARMUP", "0")) + +""" + lr_schedule(iter, total_iters) -> Float64 + +Learning rate at one-based training iteration `iter`. + +Linear warmup from `lr_init / 100` to `lr_init` over the first `lr_warmup` +iterations, then cosine decay from `lr_init` to `lr_final`: + +```math +\\eta(k) = \\eta_f + \\tfrac{1}{2} (\\eta_0 - \\eta_f) + \\bigl(1 + \\cos(\\pi \\rho_k)\\bigr), +``` + +where ``\\rho_k`` is the post-warmup progress fraction. Constant when +`lr_warmup == 0` and `lr_final == lr_init` (the defaults). +""" +function lr_schedule(iter, total_iters) + if iter <= lr_warmup + # Warmup guards a warmstarted policy against full-size Adam steps + # taken while the optimizer's second-moment estimates are near zero. + return lr_init * (0.01 + 0.99 * iter / max(lr_warmup, 1)) + end + # Post-warmup progress in [0, 1] over the remaining iteration budget. + ρ = clamp((iter - lr_warmup) / max(total_iters - lr_warmup, 1), 0.0, 1.0) + return lr_final + 0.5 * (lr_init - lr_final) * (1 + cos(π * ρ)) +end + +optimizers = if grad_clip > 0 + [Flux.Optimisers.OptimiserChain(Flux.Optimisers.ClipGrad(grad_clip), Flux.Adam(lr_init))] +else + [Flux.Adam(lr_init)] +end +pre_trained_model = get(ENV, "DR_PRETRAINED_MODEL", nothing) +clip_tag = grad_clip > 0 ? "-clip$(Int(grad_clip))" : "" +head_tag = isempty(head_layers) ? "-Hlinear" : "-H$(join(head_layers, "_"))" +_rollout_tag = num_rollout_stages != num_stages ? "-r$(num_rollout_stages)" : "" +# Tag runs with a non-default batch size so checkpoints are distinguishable. +nt_tag = _num_train_per_batch > 1 ? "-nt$(_num_train_per_batch)" : "" +# Tag warmstarted runs: their result is a fine-tune of another checkpoint, not +# a from-scratch training (the parent checkpoint is recorded in wandb config). +warm_tag = (isnothing(pre_trained_model) || pre_trained_model == "nothing") ? "" : "-warm" +save_file = "$(case_name)-$(formulation)-h$(num_stages)$(_rollout_tag)-subproblems-strict$(clip_tag)$(head_tag)$(nt_tag)$(context_run_tag(context_mode))$(warm_tag)-$(now())" +num_eval_scenarios = parse(Int, get(ENV, "DR_NUM_EVAL_SCENARIOS", "4")) +eval_every = parse(Int, get(ENV, "DR_EVAL_EVERY", "25")) +# Checkpoint-selection metric: "training" (historical; noisy at small batch +# sizes because a lucky scenario can look like a better policy) or "rollout" +# (deficit-free mean over the fixed held-out scenarios — the deployment metric). +save_metric = lowercase(get(ENV, "DR_SAVE_METRIC", "training")) +save_metric in ("training", "rollout") || + error("DR_SAVE_METRIC must be \"training\" or \"rollout\", got $save_metric") + +# ── Build strict subproblems (no deficit, no penalty) ──────────────────────── + +# Define the DiffOpt optimizer for subproblems +diff_optimizer = + () -> DiffOpt.diff_optimizer( + optimizer_with_attributes( + Ipopt.Optimizer, + "print_level" => 0, + "linear_solver" => "mumps", + ), + ) + +subproblems, state_params_in, state_params_out, uncertainty_samples, + initial_state, max_volume, hydro_meta = build_hydropowermodels( + joinpath(HydroPowerModels_dir, case_name), + formulation_file; + num_stages=num_stages, + optimizer=diff_optimizer, + strict=true, + # Per-stage seasonal demand (bolivia/demand.csv, cyclically tiled) and the + # paper deficit cost — parity with SDDP and DecisionRulesExa (see + # build_hydropowermodels; demand_file=:auto picks up demand.csv). + load_scaler=load_scaler, + deficit_cost=deficit_cost, +) + +num_hydro = length(initial_state) + +# ── Logging ────────────────────────────────────────────────────────────────── + +lg = WandbLogger(; + project="RL", + name=save_file, + save_code=false, + config=Dict( + "layers" => layers, + "head_layers" => head_layers, + "activation" => "sigmoid (reachable)", + "optimizer" => string(optimizers), + "grad_clip" => grad_clip, + "training_method" => "subproblems-strict", + "penalty_schedule" => "none (strict)", + "num_stages" => num_stages, + "num_rollout_stages" => num_rollout_stages, + "load_scaler" => load_scaler, + "deficit_cost" => deficit_cost, + "num_epochs" => string(num_epochs), + "num_batches" => string(num_batches), + "num_train_per_batch" => string(_num_train_per_batch), + "pre_trained_model" => string(pre_trained_model), + "context_mode" => isempty(context_mode) ? "none" : context_mode, + "context_period" => context_period, + "context_horizon" => num_stages, + "n_context" => n_context, + "num_eval_scenarios" => num_eval_scenarios, + "eval_every" => eval_every, + "save_metric" => save_metric, + "lr" => lr_init, + "lr_final" => lr_final, + "lr_warmup" => lr_warmup, + ), +) + +# ── Build reachable policy ─────────────────────────────────────────────────── + +# HydroReachablePolicy: LSTM encoder over inflows + sigmoid feed-forward head +# over [encoded_inflow; reservoir_state], bounded to the one-stage reachable set. +base_model = hydro_reachable_policy( + hydro_meta, + layers; + combiner_layers=head_layers, + n_context=n_context, +) +models = isnothing(stage_context) ? base_model : ContextualPolicy(base_model, stage_context) +@info "Strict hydro policy context" context_mode=(isempty(context_mode) ? "none" : context_mode) context_period context_horizon=num_stages n_context + +# ── Load pretrained model (warmstart from non-strict training) ─────────────── + +if !isnothing(pre_trained_model) && pre_trained_model != "nothing" + model_save = JLD2.load(pre_trained_model) + model_state = model_save["model_state"] + # Load encoder/combiner weights; hydro bounds are preserved + load_policy_weights!(models, model_state) + @info "Loaded pretrained weights from $pre_trained_model" +end + +# ── Initial evaluation and callbacks ───────────────────────────────────────── + +Random.seed!(8788) +objective_values = [ + simulate_multistage( + subproblems, + state_params_in, + state_params_out, + initial_state, + DecisionRules.sample(uncertainty_samples), + models; + ) for _ in 1:2 +] +initial_training_obj = mean(objective_values) +convergence_criterium = StallingCriterium(num_epochs * num_batches, initial_training_obj, 0) + +# Fixed held-out scenarios, materialized once so every evaluation uses the same set. +# Use num_rollout_stages for evaluation (may differ from training num_stages). +Random.seed!(8789) +rollout_uncertainty = uncertainty_samples[1:num_rollout_stages] +eval_scenarios = [DecisionRules.sample(rollout_uncertainty) for _ in 1:num_eval_scenarios] +rollout_evaluation = RolloutEvaluation( + subproblems[1:num_rollout_stages], + state_params_in[1:num_rollout_stages], + state_params_out[1:num_rollout_stages], + initial_state, + eval_scenarios; + stride=eval_every, + policy_state=:realized, +) + +# Checkpoint-selection baseline. With save_metric == "rollout" the incumbent +# is the current model's held-out rollout cost, so a warmstarted run only saves +# checkpoints that genuinely improve on the loaded policy under the metric it +# is ultimately judged on. iter = eval_every satisfies the stride gate. +best_obj = if save_metric == "rollout" + rollout_evaluation(eval_every, models) + @info "Initial rollout evaluation (checkpoint baseline)" rollout_evaluation.last_objective_no_deficit rollout_evaluation.last_violation_share + rollout_evaluation.last_objective_no_deficit +else + initial_training_obj +end +model_path = joinpath(model_dir, save_file * ".jld2") +save_control = SaveBest(best_obj, model_path) + +# ── Train ──────────────────────────────────────────────────────────────────── + +# Total iteration budget, used by the learning-rate schedule. +total_iters = num_epochs * num_batches + +# No penalty schedule needed — strict mode has no deficit to penalize. +train_multistage( + models, + initial_state, + subproblems, + state_params_in, + state_params_out, + uncertainty_samples; + num_batches=total_iters, + num_train_per_batch=_num_train_per_batch, + optimizer=first(optimizers), + # Apply the learning-rate schedule through the optimizer state. With the + # default constant schedule adjust! is a no-op-equivalent every iteration. + adjust_hyperparameters=(iter, opt_state, ntpb) -> begin + Flux.Optimisers.adjust!(opt_state, lr_schedule(iter, total_iters)) + ntpb + end, + record=(sample_log, iter, model) -> begin + # In strict mode: objectives == objectives_no_deficit (no penalty term) + training_loss = mean(sample_log.objectives) + metrics = Dict( + "metrics/loss" => training_loss, + "metrics/training_loss" => training_loss, + "metrics/lr" => lr_schedule(iter, total_iters), + ) + rollout_evaluation(iter, model) + if iter % eval_every == 0 + metrics["metrics/rollout_objective_no_deficit"] = + rollout_evaluation.last_objective_no_deficit + metrics["metrics/rollout_target_violation_share"] = + rollout_evaluation.last_violation_share + end + Wandb.log(lg, metrics) + # Checkpoint selection: historical per-batch training loss, or the + # held-out rollout objective (only refreshed at eval iterations). + if save_metric == "rollout" + iter % eval_every == 0 && + save_control(iter, model, rollout_evaluation.last_objective_no_deficit) + else + save_control(iter, model, training_loss) + end + return convergence_criterium(iter, model, training_loss) + end, + penalty_schedule=nothing, +) + +# Finish the run +close(lg) diff --git a/examples/HydroPowerModels/train_dr_hydropowermodels_subproblems.jl b/examples/HydroPowerModels/train_dr_hydropowermodels_subproblems.jl deleted file mode 100644 index 7428293..0000000 --- a/examples/HydroPowerModels/train_dr_hydropowermodels_subproblems.jl +++ /dev/null @@ -1,188 +0,0 @@ -# Train HydroPowerModels using stage-wise decomposition (single shooting, Extension §2) -using DecisionRules -using Statistics -using Random -using Flux - -using Ipopt -using Wandb, Dates, Logging -using JLD2 -using DiffOpt - -HydroPowerModels_dir = dirname(@__FILE__) -include(joinpath(HydroPowerModels_dir, "load_hydropowermodels.jl")) - -# Functions - -function non_ensurance(x_out, x_in, uncertainty, max_volume) - return x_out -end - -# Parameters -case_name = "bolivia" -formulation = "ACPPowerModel" -num_stages = parse(Int, get(ENV, "DR_NUM_STAGES", "126")) -model_dir = joinpath(HydroPowerModels_dir, case_name, formulation, "models") -mkpath(model_dir) -formulation_file = formulation * ".mof.json" -num_epochs = parse(Int, get(ENV, "DR_NUM_EPOCHS", "80")) -num_batches = 100 -_num_train_per_batch = 1 -activation = sigmoid -layers = Int64[128, 128] -ensure_feasibility = non_ensurance -grad_clip = parse(Float32, get(ENV, "DR_GRAD_CLIP", "0")) -optimizers = if grad_clip > 0 - [Flux.Optimisers.OptimiserChain(Flux.Optimisers.ClipGrad(grad_clip), Flux.Adam())] -else - [Flux.Adam()] -end -pre_trained_model = nothing -penalty_l2 = :auto -penalty_l1 = :auto -penalty_schedule = get(ENV, "DR_PENALTY_SCHEDULE", "constant") == "annealed" ? :default_annealed : nothing -clip_tag = grad_clip > 0 ? "-clip$(Int(grad_clip))" : "" -sched_tag = isnothing(penalty_schedule) ? "-const" : "-anneal" -save_file = "$(case_name)-$(formulation)-h$(num_stages)-subproblems$(clip_tag)$(sched_tag)-$(now())" -num_eval_scenarios = 4 # fixed held-out scenarios for the rollout evaluation -eval_every = 25 # rollout-evaluate every eval_every batches - -# Build MSP using subproblems (not deterministic equivalent) - -# Define the DiffOpt optimizer for subproblems -diff_optimizer = - () -> DiffOpt.diff_optimizer( - optimizer_with_attributes( - Ipopt.Optimizer, - "print_level" => 0, - "linear_solver" => "mumps", - ), - ) - -subproblems, state_params_in, state_params_out, uncertainty_samples, initial_state, max_volume = build_hydropowermodels( - joinpath(HydroPowerModels_dir, case_name), - formulation_file; - num_stages=num_stages, - optimizer=diff_optimizer, - penalty_l1=penalty_l1, - penalty_l2=penalty_l2, -) - -num_hydro = length(initial_state) - -# Logging - -lg = WandbLogger(; - project="RL", - name=save_file, - save_code=false, - config=Dict( - "layers" => layers, - "activation" => string(activation), - "ensure_feasibility" => string(ensure_feasibility), - "optimizer" => string(optimizers), - "grad_clip" => grad_clip, - "training_method" => "subproblems", - "penalty_l1" => string(penalty_l1), - "penalty_l2" => string(penalty_l2), - "penalty_schedule" => string(penalty_schedule), - "num_epochs" => string(num_epochs), - "num_batches" => string(num_batches), - "num_train_per_batch" => string(_num_train_per_batch), - ), -) - -# Define Model -# Policy architecture: LSTM processes uncertainty, Dense combines with previous state -num_uncertainties = length(uncertainty_samples[1][1]) -models = state_conditioned_policy( - num_uncertainties, - num_hydro, - num_hydro, - layers; - activation=activation, - encoder_type=Flux.LSTM, -) - -# Load pretrained Model -if !isnothing(pre_trained_model) - model_save = JLD2.load(pre_trained_model) - model_state = model_save["model_state"] - Flux.loadmodel!(models, model_state) -end - -Random.seed!(8788) -objective_values = [ - simulate_multistage( - subproblems, - state_params_in, - state_params_out, - initial_state, - DecisionRules.sample(uncertainty_samples), - models; - ) for _ in 1:2 -] -best_obj = mean(objective_values) - -model_path = joinpath(model_dir, save_file * ".jld2") -save_control = SaveBest(best_obj, model_path) -convergence_criterium = StallingCriterium(num_epochs * num_batches, best_obj, 0) - -# Fixed held-out scenarios, materialized once so every evaluation uses the same set. -# The rollout evaluation executes the policy stage by stage (deployment semantics) and -# reports the operational cost (objective excluding the target-slack penalty) plus the -# target-violation share; comparisons are only trustworthy when the share is <= ~0.05. -Random.seed!(8789) -eval_scenarios = [DecisionRules.sample(uncertainty_samples) for _ in 1:num_eval_scenarios] -rollout_evaluation = RolloutEvaluation( - subproblems, - state_params_in, - state_params_out, - initial_state, - eval_scenarios; - stride=eval_every, - policy_state=:realized, -) -resolved_penalty_schedule = isnothing(penalty_schedule) ? nothing : - DecisionRules._resolve_penalty_schedule(penalty_schedule, num_epochs * num_batches) - -# Train Model using subproblems (not deterministic equivalent). -# A single call over num_epochs*num_batches batches so the penalty schedule spans the whole -# run (this also keeps one optimizer state throughout, and a `true` return from the record -# callback now stops the whole run). -train_multistage( - models, - initial_state, - subproblems, - state_params_in, - state_params_out, - uncertainty_samples; - num_batches=num_epochs * num_batches, - num_train_per_batch=_num_train_per_batch, - optimizer=first(optimizers), - record=(sample_log, iter, model) -> begin - training_loss = mean(sample_log.objectives) - metrics = Dict( - "metrics/loss" => mean(sample_log.objectives_no_deficit), - "metrics/training_loss" => training_loss, - ) - rollout_evaluation(iter, model) - if iter % eval_every == 0 - metrics["metrics/rollout_objective_no_deficit"] = - rollout_evaluation.last_objective_no_deficit - metrics["metrics/rollout_target_violation_share"] = - rollout_evaluation.last_violation_share - end - if !isnothing(resolved_penalty_schedule) - metrics["metrics/target_penalty_multiplier"] = - DecisionRules._penalty_multiplier_for(resolved_penalty_schedule, iter) - end - Wandb.log(lg, metrics) - save_control(iter, model, training_loss) - return convergence_criterium(iter, model, training_loss) - end, - penalty_schedule=penalty_schedule, -) - -# Finish the run -close(lg) diff --git a/examples/HydroPowerModels/train_dr_l2O_supervised.jl b/examples/HydroPowerModels/train_dr_l2O_supervised.jl deleted file mode 100644 index 5d9466c..0000000 --- a/examples/HydroPowerModels/train_dr_l2O_supervised.jl +++ /dev/null @@ -1,206 +0,0 @@ -using CUDA -using Wandb, Dates, Logging -using Arrow - -using JLD2 -using Statistics -using Random -using Flux -using JSON -using DataFrames -using DecisionRules - -# CUDA.set_runtime_version!(v"12.1.0") - -case_name = "case3" -formulation = "ACPPowerModel" -num_stages = 48 -batch_size = 32 -num_epochs = 10 -optimizer = Flux.RMSProp() -os = cpu # cpu, gpu - -save_file = "supervised-$(case_name)-$(formulation)-h$(num_stages)-$(now())" - -HydroPowerModels_dir = dirname(@__FILE__) -case_dir = joinpath(HydroPowerModels_dir, case_name) -model_dir = joinpath(case_dir, formulation, "models") -output_dir = joinpath(case_dir, formulation, "output") - -hydro_file = JSON.parsefile(joinpath(case_dir, "hydro.json")) - -num_hydro = length(hydro_file["Hydrogenerators"]) -stage_hours = hydro_file["stage_hours"] -volume_to_mw(volume, stage_hours; k=0.0036) = volume / (k * stage_hours) - -input_files = [ - file for file in readdir(case_dir; join=true) if ( - occursin(case_name, file) && - occursin(formulation, file) && - occursin("arrow", file) && - occursin("input", file) - ) -] - -output_files = [ - file for file in readdir(output_dir; join=true) if ( - occursin(case_name, file) && - occursin(formulation, file) && - occursin("arrow", file) && - occursin("output", file) - ) -] - -input_table = deepcopy(DataFrame(Arrow.Table(input_files))) -output_table = DataFrame(Arrow.Table(output_files)) - -for i in 1:num_hydro - input_table[:, Symbol("_inflow[$i]#1")] = - input_table[:, Symbol("_inflow[$i]#1")] .+ - volume_to_mw.(input_table[:, Symbol("_reservoir[$i]_in#1")], stage_hours) -end - -input_names = [[Symbol("_inflow[$i]#$t") for i in 1:num_hydro] for t in 1:num_stages] -output_names = [[Symbol("reservoir[$i]_out#$t") for i in 1:num_hydro] for t in 1:num_stages] - -output_table[!, vcat(output_names...)] .= - sum(Matrix(output_table[!, vcat(output_names...)]); dims=1) ./ size(output_table, 1) - -data_table = innerjoin(input_table, output_table; on=:id) -data_table = data_table -for in_name in vcat(input_names...) - data_table[!, in_name] = Vector(data_table[:, in_name]) -end -for out_name in vcat(output_names...) - data_table[!, out_name] = Vector(data_table[:, out_name]) -end - -model = os(Chain(Dense(num_hydro, 8, relu), LSTM(8, 8), Dense(8, num_hydro))) - -function train_test( - model, - data_table, - num_hydro, - num_stages, - input_names, - output_names; - loss=Flux.mse, - batch_size=32, - optimizer=Flux.Adam(0.01), - os=cpu, - record_loss=(iter, model, loss, tag) -> begin - println("tag: $tag, Iter: $iter, Loss: $loss") - return false - end, -) - num_samples = length(data_table.id) - num_batches = ceil(Int, num_samples / batch_size) - - # Initialise the optimiser for this model: - opt_state = Flux.setup(optimizer, model) - - for iter in 1:num_batches - iter_data_table = data_table[ - ((iter - 1) * batch_size + 1):min(iter * batch_size, num_samples), :, - ] - in_data = [ - [ - os([iter_data_table[s, input_names[t][i]] for i in 1:num_hydro]) for - s in 1:length(iter_data_table.id) - ] for t in 1:num_stages - ] - out_data = [ - [ - os([iter_data_table[s, output_names[t][i]] for i in 1:num_hydro]) for - s in 1:length(iter_data_table.id) - ] for t in 1:num_stages - ] - objective = 0.0 - grads = Flux.gradient(model) do m - for s in 1:length(iter_data_table.id) - Flux.reset!(m) - target_states = hcat([m(in_data[t][s]) for t in 1:num_stages]...) - optimal_states = hcat([out_data[t][s] for t in 1:num_stages]...) - objective += loss(target_states, optimal_states) - end - objective /= batch_size - return objective - end - record_loss(iter, model, objective, "metrics/batch_loss") && break - - # Update the parameters so as to reduce the objective, - # according the chosen optimisation rule: - Flux.update!(opt_state, model, grads[1]) - end -end - -model_path = joinpath(model_dir, save_file * ".jld2") - -save_control = SaveBest(100, model_path) - -lg = WandbLogger(; - project="HydroPowerModels", - name=save_file, - save_code=false, - config=Dict("Supervised" => "Yes", "optimizer" => "Adam"), -) - -function record_loss(iter, model, loss, tag) - Wandb.log(lg, Dict(tag => loss)) - return false -end - -function train_multi_epoch( - model, - data_table, - num_hydro, - num_stages, - input_names, - output_names; - loss=Flux.mse, - batch_size=32, - optimizer=Flux.Adam(0.01), - num_epochs=1, - os=cpu, - record_loss=(iter, model, loss, tag) -> begin - println("tag: $tag, Iter: $iter, Loss: $loss") - return false - end, -) - for epoch in 1:num_epochs - data_table = data_table[shuffle(1:size(data_table, 1)), :] - train_test( - model, - data_table, - num_hydro, - num_stages, - input_names, - output_names; - record_loss=record_loss, - optimizer=optimizer, - batch_size=batch_size, - loss=loss, - os=os, - ) - end -end - -train_multi_epoch( - model, - data_table, - num_hydro, - num_stages, - input_names, - output_names; - num_epochs=num_epochs, - optimizer=optimizer, - batch_size=batch_size, - os=os, - record_loss=(iter, model, loss, tag) -> begin - save_control(iter, model, loss) - return record_loss(iter, model, loss, tag) - end, -) - -# Finish the run -close(lg) diff --git a/examples/HydroPowerModels/train_ldr_hydropowermodels.jl b/examples/HydroPowerModels/train_ldr_hydropowermodels.jl deleted file mode 100644 index c296ce2..0000000 --- a/examples/HydroPowerModels/train_ldr_hydropowermodels.jl +++ /dev/null @@ -1,264 +0,0 @@ -# Train a TS-LDR (Linear Decision Rule) policy on the Bolivia LTHD problem. -# -# TS-LDR uses the same target-setting framework as TS-DDR but replaces the -# deep neural network with a linear map: -# -# x̂_t = W [w_{1:t}; x_{t-1}] + b -# -# where W, b are the trainable parameters. This is a `dense_multilayer_nn` -# with identity activation — a composition of linear layers is still linear, -# so the result is a standard linear decision rule. -# -# Training uses the Deterministic Equivalent pipeline (all stages coupled in -# one NLP), identical to train_dr_hydropowermodels.jl except for the policy -# architecture. The saved model is evaluated by evaluate_hydro_policies.jl. -# -# Usage: -# julia --project=. train_ldr_hydropowermodels.jl - -using DecisionRules -using Statistics -using Random -using Flux - -using Ipopt -using Wandb, Dates, Logging -using JLD2 -using DiffOpt -using JuMP -using MadNLP - -USE_GPU = try - using CUDA, CUDSS, MadNLPGPU - CUDA.functional() -catch - @warn "GPU packages not available — running on CPU" - false -end -@info "GPU status" USE_GPU - -HydroPowerModels_dir = dirname(@__FILE__) -include(joinpath(HydroPowerModels_dir, "load_hydropowermodels.jl")) - -function non_ensurance(x_out, x_in, uncertainty, max_volume) - return x_out -end - -# ── Parameters ─────────────────────────────────────────────────────────────── - -case_name = "bolivia" -formulation = "ACPPowerModel" -num_stages = 96 -model_dir = joinpath(HydroPowerModels_dir, case_name, formulation, "models") -mkpath(model_dir) -solver_tag = USE_GPU ? "gpu" : "cpu" -save_file = "$(case_name)-$(formulation)-h$(num_stages)-ldr-$(solver_tag)-$(now())" -formulation_file = formulation * ".mof.json" - -num_epochs = 40 -num_batches = 100 -_num_train_per_batch = 1 -activation = identity -layers = Int64[64, 64] -ensure_feasibility = non_ensurance -optimizers = [Flux.Adam()] -pre_trained_model = nothing -penalty_l2 = :auto -penalty_l1 = :auto -penalty_schedule = [ - (1, 100, 0.1), - (101, 210, 1.0), - (211, 300, 10.0), - (301, num_epochs * num_batches, 30.0), -] -num_eval_scenarios = 4 -eval_every = 25 - -# ── Build MSP: subproblems for rollout evaluation ──────────────────────────── - -diff_optimizer = - () -> DiffOpt.diff_optimizer( - optimizer_with_attributes( - Ipopt.Optimizer, - "print_level" => 0, - "linear_solver" => "mumps", - ), - ) -subproblems, state_params_in_sub, state_params_out_sub, uncertainty_samples_sub, initial_state, max_volume = build_hydropowermodels( - joinpath(HydroPowerModels_dir, case_name), - formulation_file; - num_stages=num_stages, - optimizer=diff_optimizer, - penalty_l1=penalty_l1, - penalty_l2=penalty_l2, -) - -# ── Build det-eq for training ──────────────────────────────────────────────── - -subproblems_de, state_params_in, state_params_out, uncertainty_samples, _, _ = build_hydropowermodels( - joinpath(HydroPowerModels_dir, case_name), - formulation_file; - num_stages=num_stages, - penalty_l1=penalty_l1, - penalty_l2=penalty_l2, -) - -det_equivalent = Model(MadNLP.Optimizer) - -if USE_GPU - set_optimizer_attribute(det_equivalent, "array_type", CUDA.CuArray) - set_optimizer_attribute(det_equivalent, "linear_solver", MadNLPGPU.CUDSSSolver) - set_optimizer_attribute(det_equivalent, "print_level", MadNLP.ERROR) - set_optimizer_attribute(det_equivalent, "barrier", MadNLP.LOQOUpdate()) -else - set_optimizer_attribute(det_equivalent, "print_level", MadNLP.ERROR) - set_optimizer_attribute(det_equivalent, "barrier", MadNLP.LOQOUpdate()) -end - -det_equivalent, uncertainty_samples = DecisionRules.deterministic_equivalent!( - det_equivalent, - subproblems_de, - state_params_in, - state_params_out, - initial_state, - uncertainty_samples, -) - -num_hydro = length(initial_state) - -# ── Logging ────────────────────────────────────────────────────────────────── - -lg = WandbLogger(; - project="RL", - name=save_file, - save_code=false, - config=Dict( - "layers" => layers, - "activation" => "identity (LDR)", - "policy_type" => "dense_multilayer_nn", - "ensure_feasibility" => string(ensure_feasibility), - "optimizer" => string(optimizers), - "training_method" => "deterministic_equivalent", - "solver" => USE_GPU ? "MadNLP+CUDSS (GPU)" : "MadNLP (CPU)", - "penalty_l1" => string(penalty_l1), - "penalty_l2" => string(penalty_l2), - "penalty_schedule" => string(penalty_schedule), - "num_epochs" => string(num_epochs), - "num_batches" => string(num_batches), - "num_train_per_batch" => string(_num_train_per_batch), - "num_eval_scenarios" => num_eval_scenarios, - "eval_every" => eval_every, - "use_gpu" => USE_GPU, - ), -) - -# ── Define linear policy ───────────────────────────────────────────────────── - -num_uncertainties = length(uncertainty_samples[1][1]) -num_inputs = DecisionRules.policy_input_dim(num_uncertainties, num_hydro) -models = dense_multilayer_nn( - num_inputs, num_hydro, layers; - activation=activation, -) - -if !isnothing(pre_trained_model) - model_save = JLD2.load(pre_trained_model) - model_state = model_save["model_state"] - Flux.loadmodel!(models, model_state) -end - -# ── Initial evaluation ─────────────────────────────────────────────────────── - -Random.seed!(8788) -@time objective_values = [ - simulate_multistage( - det_equivalent, - state_params_in, - state_params_out, - initial_state, - DecisionRules.sample(uncertainty_samples), - models; - ) for _ in 1:2 -] -best_obj = mean(objective_values) - -model_path = joinpath(model_dir, save_file * ".jld2") -save_control = SaveBest(best_obj, model_path) -stall_train = StallingCriterium(100, best_obj, 0) -stall_rollout = StallingCriterium(5, best_obj, 0) - -# ── Rollout evaluation (stage-wise subproblems, CPU) ───────────────────────── - -Random.seed!(8789) -eval_scenarios = [ - DecisionRules.sample(uncertainty_samples_sub) for _ in 1:num_eval_scenarios -] -rollout_evaluation = RolloutEvaluation( - subproblems, - state_params_in_sub, - state_params_out_sub, - initial_state, - eval_scenarios; - stride=eval_every, - policy_state=:target, -) -realized_rollout_evaluation = RolloutEvaluation( - subproblems, - state_params_in_sub, - state_params_out_sub, - initial_state, - eval_scenarios; - stride=eval_every, - policy_state=:realized, -) -resolved_penalty_schedule = isnothing(penalty_schedule) ? nothing : - DecisionRules._resolve_penalty_schedule(penalty_schedule, num_epochs * num_batches) - -# ── Train ──────────────────────────────────────────────────────────────────── - -train_multistage( - models, - initial_state, - det_equivalent, - state_params_in, - state_params_out, - uncertainty_samples; - num_batches=num_epochs * num_batches, - num_train_per_batch=_num_train_per_batch, - optimizer=first(optimizers), - record=(sample_log, iter, model) -> begin - training_loss = mean(sample_log.objectives) - loss_no_deficit = mean(sample_log.objectives_no_deficit) - metrics = Dict( - "metrics/loss" => loss_no_deficit, - "metrics/training_loss" => training_loss, - ) - rollout_evaluation(iter, model) - realized_rollout_evaluation(iter, model) - converged_training = stall_train(iter, model, training_loss) - converged_rollout = false - if iter % eval_every == 0 - converged_rollout = stall_rollout( - iter, model, rollout_evaluation.last_objective_no_deficit - ) - metrics["metrics/rollout_objective_no_deficit"] = - rollout_evaluation.last_objective_no_deficit - metrics["metrics/rollout_target_violation_share"] = - rollout_evaluation.last_violation_share - metrics["metrics/rollout_realized_objective_no_deficit"] = - realized_rollout_evaluation.last_objective_no_deficit - metrics["metrics/rollout_realized_target_violation_share"] = - realized_rollout_evaluation.last_violation_share - end - if !isnothing(resolved_penalty_schedule) - metrics["metrics/target_penalty_multiplier"] = - DecisionRules._penalty_multiplier_for(resolved_penalty_schedule, iter) - end - Wandb.log(lg, metrics) - save_control(iter, model, training_loss) - return converged_training && converged_rollout && isapprox(training_loss, rollout_evaluation.last_objective_no_deficit; rtol=0.01) - end, - penalty_schedule=penalty_schedule, -) - -close(lg) diff --git a/examples/README.md b/examples/README.md index 23e4d16..c0a3468 100644 --- a/examples/README.md +++ b/examples/README.md @@ -8,10 +8,8 @@ and additional experiments. | Directory | Application | Paper section | |-----------|------------|---------------| -| [`HydroPowerModels/`](HydroPowerModels/) | Bolivia Long-Term Hydrothermal Dispatching (10 hydro units, AC/SOC/DC OPF, 96 stages). Trains TS-DDR (LSTM) and TS-LDR (linear) policies. | §4, Extension §1–§4 | | [`inventory_control/`](inventory_control/) | Stochastic lot-sizing with fixed ordering costs (relaxed LP and integer MIP). Demonstrates score-function (REINFORCE) gradient mixing for integer variables. | §3 | | [`rocket_control/`](rocket_control/) | Goddard rocket altitude maximization with stochastic wind | §3 | -| [`RL/`](RL/) | Reinforcement learning baselines (REINFORCE, PPO, DDPG, TD3, SAC) on Bolivia LTHD | Beyond paper | | `Experimental/` | Work-in-progress experiments (not documented) | — | ## Utility scripts @@ -19,7 +17,6 @@ and additional experiments. | Script | Description | |--------|-------------| | `slurm.jl` | SLURM launcher: starts Distributed workers via `ClusterManagers` and includes a target script | -| `solve_dataset.jl` | Distributed batch solver for L2O dataset generation (uses [L2O.jl](https://github.com/andrewrosemberg/L2O.jl)) | ## Quick start @@ -28,24 +25,10 @@ before running: ```julia using Pkg -Pkg.activate("examples/HydroPowerModels") +Pkg.activate("examples/inventory_control") Pkg.instantiate() -include("examples/HydroPowerModels/train_dr_hydropowermodels_subproblems.jl") +include("examples/inventory_control/train_dr_inventory.jl") ``` For GPU-accelerated training on SLURM, see the `.sbatch` files in each subdirectory. - -## Training methods compared - -All three decomposition strategies from the paper can be trained on the -same problem: - -1. **Deterministic Equivalent** — single coupled NLP over all stages (Extension §1) -2. **Stage-wise / Single Shooting** — solve one subproblem per stage, backpropagate through the chain (Extension §2) -3. **Windowed / Multiple Shooting** — partition stages into windows, parallelize window solves (Extension §3) - -The HydroPowerModels directory contains a training script for each strategy, -a TS-LDR training script (linear policy baseline), and an evaluation script -(`evaluate_hydro_policies.jl`) that runs all trained policies on a common -out-of-sample scenario set. diff --git a/examples/RL/hydro_benchmark.pdf b/examples/RL/hydro_benchmark.pdf deleted file mode 100644 index 31f17d9..0000000 Binary files a/examples/RL/hydro_benchmark.pdf and /dev/null differ diff --git a/examples/RL/hydro_benchmark_warm.pdf b/examples/RL/hydro_benchmark_warm.pdf deleted file mode 100644 index 0637a8c..0000000 Binary files a/examples/RL/hydro_benchmark_warm.pdf and /dev/null differ diff --git a/examples/inventory_control/README.md b/examples/inventory_control/README.md index a4ae4be..0b97023 100644 --- a/examples/inventory_control/README.md +++ b/examples/inventory_control/README.md @@ -68,6 +68,52 @@ subproblems. Two strategies are available: For the relaxed formulation (no integer variables), `NoIntegerStrategy` is used — subproblems are solved and duals read as-is. +## Strict Mode (reachable policy, no penalty tuning) + +The `strict` and `strict_integer` variants replace the L1 target penalty with +the hard equality `s_mid == s_target` — no deficit variable, no penalty +hyperparameter, and the target-constraint dual is the pure shadow price +(the same construction as the hydro strict mode). + +Strict mode requires every target to be one-stage feasible. Here the exact +reachable set is a one-liner: with realized incoming inventory `s` and order +`q ∈ [0, Q_max]`, the order-up-to position satisfies + +``` +s_mid = s + q ∈ [s, s + Q_max] +``` + +and nothing else constrains it (`s_out` is free; the hold/backlog split is +always feasible). `InventoryReachablePolicy` maps the network output onto +exactly this interval. Three design points, each load-bearing: + +1. **Boundary attainment.** With fixed ordering cost `K`, "do not order" + (`q = 0`) is an essential decision at the interval boundary. The policy + uses `hardsigmoid` (attains 0 and 1 exactly on finite inputs) instead of + `sigmoid` (strictly interior) — a strict-sigmoid policy would be forced + to pay `K` every period. In the hydro case the boundary is economically + irrelevant and this distinction does not matter; here it is first-order. +2. **Pass-through state components.** The demand-history entries of the + state have singleton reachable sets (the observed demands): the policy + passes them through deterministically, and the stage models leave their + target parameters unconstrained. +3. **Stage-wise training only.** Strict variants train on the stage-wise + subproblems (closed loop). The target (`s_mid`, pre-demand) and the + carried state (`s_out = s_mid − d`, post-demand) are different + quantities, so the deterministic equivalent's target-feedback recursion + would hand the policy the wrong state for its reachable bounds — unlike + hydro, where target and state are the same reservoir volume and the + strict regular DE is safe by induction. + +Run them like any other variant (one tag per invocation): + +```bash +julia --project=examples/inventory_control \ + examples/inventory_control/train_dr_inventory.jl strict +julia --project=examples/inventory_control \ + examples/inventory_control/train_dr_inventory.jl strict_integer +``` + ## Score-Function Gradient Mixing `ScoreFunctionConfig` adds a REINFORCE-style correction to the dual diff --git a/examples/inventory_control/build_inventory_problem.jl b/examples/inventory_control/build_inventory_problem.jl index b6137b8..a18c579 100644 --- a/examples/inventory_control/build_inventory_problem.jl +++ b/examples/inventory_control/build_inventory_problem.jl @@ -152,9 +152,16 @@ Returns the five-tuple expected by `simulate_multistage` and - `T`, `K`, `c`, `h`, `p`, `Q_max`: problem parameters. - `I_0`: initial inventory. - `num_scenarios`: number of uncertainty samples per SGD batch. -- `penalty`: target-deficit penalty λ. +- `penalty`: target-deficit penalty λ (ignored when `strict = true`). - `seed`: RNG seed for demand sampling. - `integer`: whether to include binary setup variable z. +- `strict`: replace the L1 target penalty with the hard equality + `s_mid == s_target` (no deficit variable, no penalty hyperparameter). + Requires a policy whose targets are always one-stage reachable, i.e. + `s_target ∈ [s_in, s_in + Q_max]` — see [`InventoryReachablePolicy`](@ref). + The demand pass-through targets stay unconstrained in both modes: their + reachable sets are singletons (the observed demands), so constraining them + adds nothing and predicting them is not a decision. """ function build_inventory_subproblems(; T = INVENTORY_T, @@ -168,6 +175,7 @@ function build_inventory_subproblems(; penalty = INVENTORY_PENALTY, seed = 42, integer = true, + strict = false, ) # Fix the random seed so demand samples are reproducible. Random.seed!(seed) @@ -242,9 +250,19 @@ function build_inventory_subproblems(; # Split end-of-period inventory into holding and backlog parts. @constraint(m, inv_hold - back == s_out) - # L1 target-deficit penalty: λ · |s_mid - ŝ_target|. - _, deficit = create_deficit!(m, 1; penalty_l1=penalty) - @constraint(m, deficit[1] == s_mid - s_target) + if strict + # Strict mode: hard equality, no slack, no penalty term. The dual + # of this constraint is the pure shadow price ∂q_t/∂ŝ_target. + # Feasible iff s_target ∈ [s_in, s_in + Q_max] (exactly the + # one-stage reachable set of s_mid = s_in + q with q ∈ [0, Q_max]; + # s_out and the hold/backlog split are free, so no other + # constraint restricts s_mid). + @constraint(m, s_mid == s_target) + else + # L1 target-deficit penalty: λ · |s_mid - ŝ_target|. + _, deficit = create_deficit!(m, 1; penalty_l1=penalty) + @constraint(m, deficit[1] == s_mid - s_target) + end # Store the model and parameter mappings. subproblems[t] = m @@ -287,9 +305,21 @@ The penalty term is - `T`, `K`, `c`, `h`, `p`, `Q_max`: problem parameters. - `I_0`: initial inventory. - `num_scenarios`: number of uncertainty samples per SGD batch. -- `penalty`: target-deficit penalty ``\\lambda``. +- `penalty`: target-deficit penalty ``\\lambda`` (ignored when `strict = true`). - `seed`: RNG seed for demand sampling. - `integer`: whether to include binary setup variable z. +- `strict`: replace the L1 penalty with hard equalities + ``s^{mid}_t = \\hat{s}_t`` and drop the penalty term from the objective. + **Feasibility caveat**: unlike the hydro case, the target (order-up-to + position ``s^{mid}``) and the carried state (post-demand inventory + ``s^{out} = s^{mid} - d``) are *different quantities*, so the standard + target-feedback DE recursion hands the policy ``\\hat{s}^{mid}_{t-1}`` + where a reachable policy expects ``s^{out}_{t-1}`` — the induction + guarantee does NOT transfer naively. Either train stage-wise (what the + `strict` variants do; see `build_training_problem`) or reconstruct the + realized inventory inside the recursion as + ``s^{out}_{t-1} = \\hat{s}_{t-1} - d_{t-1}`` (target minus the demand + pass-through) before computing reachable bounds. # Examples ```julia @@ -311,6 +341,7 @@ function build_inventory_det_equivalent(; penalty = INVENTORY_PENALTY, seed = 42, integer = true, + strict = false, ) # Fix the random seed so demand samples are reproducible. Random.seed!(seed) @@ -366,22 +397,40 @@ function build_inventory_det_equivalent(; # Split end-of-period inventory into holding and backlog. @constraint(m, [t=1:T], inv_hold[t] - back[t] == s_out[t]) - # --- Target-deficit penalty via NormOneCone --- - # norm_deficit_arr[t] ≥ |s_mid[t] - s_target[t]| (L1 norm). - @variable(m, norm_deficit_arr[1:T] >= 0.0) - @variable(m, deficit_arr[1:T]) - @constraint(m, [t=1:T], deficit_arr[t] == s_mid[t] - s_target[t]) - @constraint(m, [t=1:T], [norm_deficit_arr[t]; deficit_arr[t:t]] in MOI.NormOneCone(2)) + if strict + # --- Strict targets: hard equalities, no deficit machinery --- + # Feasible for any target path with ŝ_t ∈ [s_{t-1}, s_{t-1} + Q_max] + # generated by a reachable policy: by induction, the equality pins + # s_mid[t] (hence s_out[t] = ŝ_t − d_t) to the value the policy + # planned from, so every later target stays reachable. + @constraint(m, [t=1:T], s_mid[t] == s_target[t]) - # --- Objective: operational cost + target penalty --- - if integer - @objective(m, Min, - sum(K * z[t] + c * q[t] + h * inv_hold[t] + p * back[t] for t in 1:T) + - penalty * sum(norm_deficit_arr)) + # --- Objective: pure operational cost --- + if integer + @objective(m, Min, + sum(K * z[t] + c * q[t] + h * inv_hold[t] + p * back[t] for t in 1:T)) + else + @objective(m, Min, + sum(c * q[t] + h * inv_hold[t] + p * back[t] for t in 1:T)) + end else - @objective(m, Min, - sum(c * q[t] + h * inv_hold[t] + p * back[t] for t in 1:T) + - penalty * sum(norm_deficit_arr)) + # --- Target-deficit penalty via NormOneCone --- + # norm_deficit_arr[t] ≥ |s_mid[t] - s_target[t]| (L1 norm). + @variable(m, norm_deficit_arr[1:T] >= 0.0) + @variable(m, deficit_arr[1:T]) + @constraint(m, [t=1:T], deficit_arr[t] == s_mid[t] - s_target[t]) + @constraint(m, [t=1:T], [norm_deficit_arr[t]; deficit_arr[t:t]] in MOI.NormOneCone(2)) + + # --- Objective: operational cost + target penalty --- + if integer + @objective(m, Min, + sum(K * z[t] + c * q[t] + h * inv_hold[t] + p * back[t] for t in 1:T) + + penalty * sum(norm_deficit_arr)) + else + @objective(m, Min, + sum(c * q[t] + h * inv_hold[t] + p * back[t] for t in 1:T) + + penalty * sum(norm_deficit_arr)) + end end # --- Build parameter mappings for DecisionRules interface --- @@ -623,3 +672,172 @@ function build_lstm_exante_policy(; seed=2024, hidden=16) return LSTMExAntePolicy(encoder, combiner, state) end + +# --------------------------------------------------------------------------- +# Reachable ex-ante policy (strict mode: always-feasible targets) +# --------------------------------------------------------------------------- + +@doc raw""" + InventoryReachablePolicy{E,C,S} + +Recurrent ex-ante policy whose targets are always one-stage reachable, +enabling **strict mode** (hard target equalities, no penalty hyperparameter). + +## Exact reachable set + +The only decision behind the target is the order quantity +``q \in [0, Q_{max}]`` with ``s^{mid} = s + q``, where ``s`` is the realized +incoming inventory. ``s^{mid}`` appears in no other restrictive constraint +(``s^{out}`` is free and the hold/backlog split is feasible for any sign), so +the one-stage reachable set of the target is **exactly** + +```math +\hat{s} \in [\, s,\; s + Q_{max} \,], +``` + +with no conservatism and no cross-component coupling. The binary setup +variable does not shrink this set (``z = 1`` admits every +``q \in [0, Q_{max}]``); it only reshapes the cost over it. + +## Boundary attainment (why `hardsigmoid`, not `sigmoid`) + +With a fixed ordering cost ``K > 0``, the endpoint ``q = 0`` ("do not +order") is an economically essential decision, not a measure-zero boundary. +A strict sigmoid keeps ``q = Q_{max}\,\sigma(z) > 0`` for every finite +``z``, which under strict equalities forces ``z_{setup} = 1`` and pays +``K`` every period — silently deleting the no-order action from the policy +class. The output therefore uses `hardsigmoid`, which attains 0 and 1 +exactly on finite inputs: + +```math +\hat{s} = s + Q_{max} \cdot \operatorname{hard\sigma}(z), \qquad +\operatorname{hard\sigma}(z) = \min(\max(z/6 + 1/2,\, 0),\, 1). +``` + +(Contrast with the hydro reachable policy, where the interval endpoints are +economically irrelevant and a strict sigmoid is harmless.) + +## Pass-through components + +The second and third state components (``d_{t-1}``, ``d_{t-2}`` histories) +are exogenous information states: their one-stage "reachable sets" are +singletons — the realized demand values. The policy passes them through +deterministically (no trainable parameters); the stage models leave their +target parameters unconstrained in both penalty and strict modes. + +## Information pattern and gradients + +Strictly **ex-ante**: the LSTM encoder consumes only the *lagged* demand +``d_{t-1}``; current demand ``d_t`` is never used for the order decision +(it appears in the output only as state pass-through plumbing). The bound +map ``\hat{s} = s + Q_{max} y`` is affine and exact, so — unlike the hydro +policy's physics bounds — it is left differentiable: the additive ``s`` +term carries an exact gradient path through the realized state. + +# Fields +- `encoder::E`: `Flux.LSTMCell` over the normalized lagged demand. +- `combiner::C`: `Dense` head mapping `[encoded; s/100; d_{t-2}/100]` to the + pre-activation order fraction. +- `state::S`: LSTM hidden state, threaded across stages; reset per scenario. +- `Q_max::Float32`: order capacity (the constant reachable-interval width). + +# Examples +```julia +policy = build_reachable_inventory_policy(; seed = 2024) +Flux.reset!(policy) +target = policy(Float32[d_t, inventory, d_lag1, d_lag2]) +@assert inventory <= target[1] <= inventory + INVENTORY_Q_MAX +``` +""" +mutable struct InventoryReachablePolicy{E,C,S} + encoder::E + combiner::C + state::S + Q_max::Float32 +end + +Functors.@functor InventoryReachablePolicy (encoder, combiner) + +function (policy::InventoryReachablePolicy)(x) + # Extract features from input: [d_t, inventory, d_{t-1}, d_{t-2}]. + # Only d_{t-1} (lagged) feeds the LSTM — d_t is NOT used (ex-ante). + inventory = Float32(x[2]) + last_demand = Float32(x[3]) + prev_demand = Float32(x[4]) + + # Match the element type of the LSTM state (Float32 during training). + T = eltype(first(policy.state)) + + # Feed the normalized lagged demand through the LSTM cell and thread + # the hidden state to the next stage call within this scenario. + encoded, new_state = policy.encoder(T[last_demand / 100], policy.state) + policy.state = new_state + + # Concatenate LSTM output with current inventory and prev demand. + combined = vcat(encoded, T[inventory / 100, prev_demand / 100]) + + # Map to the order fraction y ∈ [0, 1]; hardsigmoid attains both + # endpoints exactly (q = 0 and q = Q_max are real decisions). + y = Flux.hardsigmoid(policy.combiner(combined)[1]) + + # Affine map onto the exact reachable interval [s, s + Q_max], computed + # in Float64 FROM THE RAW INPUT STATE: the implied order quantity is then + # q = target − s = Q_max·y ≥ 0 bitwise. Using the Float32-cast state here + # would make the strict equality infeasible whenever y saturates at 0 and + # Float32(s) < s (the solver would need q ≈ −1e−5·s < 0) — a failure mode + # the integer variant hits constantly because the fixed cost K actively + # pushes the policy to the q = 0 boundary. + target_s_mid = Float64(x[2]) + Float64(policy.Q_max) * Float64(y) + + # Return [target_s_mid, d_t, d_{t-1}] — target + state pass-throughs. + return [target_s_mid, Float64(x[1]), Float64(last_demand)] +end + +""" + Flux.reset!(policy::InventoryReachablePolicy) -> Nothing + +Reset the LSTM hidden state to its initial value. Must be called at every +scenario boundary so demand-history memory does not leak across rollouts. +""" +function Flux.reset!(policy::InventoryReachablePolicy) + # Restore the LSTM hidden state to its fresh initial values. + policy.state = Flux.initialstates(policy.encoder) + return nothing +end + +""" + build_reachable_inventory_policy(; seed = 2024, hidden = 16, Q_max = INVENTORY_Q_MAX) + -> InventoryReachablePolicy + +Construct the reachable ex-ante policy used by the strict variants. + +Architecture matches [`build_lstm_exante_policy`](@ref) exactly — +LSTMCell(1 → hidden) encoder, Dense(hidden + 2 → 1) head — so +penalty-vs-strict comparisons isolate the output parameterization, not +model capacity. + +# Keyword Arguments +- `seed::Int`: random seed for weight initialization. +- `hidden::Int`: LSTM hidden dimension. +- `Q_max`: order capacity (reachable-interval width). + +# Examples +```julia +policy = build_reachable_inventory_policy(; seed = 2024, hidden = 16) +``` +""" +function build_reachable_inventory_policy(; seed=2024, hidden=16, Q_max=INVENTORY_Q_MAX) + # Fix the random seed for reproducible weight initialization. + Random.seed!(seed) + + # LSTM cell: 1 input (normalized lagged demand) → hidden state. + encoder = Flux.LSTMCell(1 => hidden) + + # Dense head: [LSTM output; inventory; prev_demand] → order fraction. + combiner = Dense(hidden + 2, 1) + + # Initialize the LSTM hidden state to its default zeros. + state = Flux.initialstates(encoder) + + return InventoryReachablePolicy(encoder, combiner, state, Float32(Q_max)) +end diff --git a/examples/inventory_control/compare_results.jl b/examples/inventory_control/compare_results.jl index f9d6f2e..b53671e 100644 --- a/examples/inventory_control/compare_results.jl +++ b/examples/inventory_control/compare_results.jl @@ -803,6 +803,7 @@ function relaxed_results() lstm_costs = optional_costs("relaxed_lstm", "dr") hp_costs = optional_costs("relaxed_hp", "dr") lstm_hp_costs = optional_costs("relaxed_lstm_hp", "dr") + strict_costs = optional_costs("strict", "dr") # Load scalar baseline metadata. base_stock_level = read_scalar(resolve_file("relaxed_basestock_S_star.txt")) @@ -820,6 +821,8 @@ function relaxed_results() push!(results, MethodResult("TS-DDR Relaxed (LSTM)", lstm_costs)) !isnothing(lstm_hp_costs) && push!(results, MethodResult("TS-DDR Relaxed (LSTM+HP)", lstm_hp_costs)) + !isnothing(strict_costs) && + push!(results, MethodResult("TS-DDR Strict (Reachable)", strict_costs)) # Append non-TS-DDR baselines. push!(results, MethodResult("SDDP (PAR)", sddp_costs)) @@ -834,6 +837,8 @@ function relaxed_results() push!(timing_tags, "relaxed_hp") !isnothing(resolve_file_optional("relaxed_lstm_hp_dr_timing.csv")) && push!(timing_tags, "relaxed_lstm_hp") + !isnothing(resolve_file_optional("strict_dr_timing.csv")) && + push!(timing_tags, "strict") return results, load_timing(timing_tags), base_stock_level, sddp_bound end @@ -862,6 +867,7 @@ function integer_results() hp_costs = optional_costs("integer_hp", "dr") lstm_costs = optional_costs("integer_lstm", "dr") lstm_sf_costs = optional_costs("integer_lstm_sf", "dr") + strict_integer_costs = optional_costs("strict_integer", "dr") # Load scalar baseline metadata. base_stock_level = read_scalar(resolve_file("integer_basestock_S_star.txt")) @@ -882,6 +888,8 @@ function integer_results() push!(results, MethodResult("TS-DDR (LSTM)", lstm_costs)) !isnothing(lstm_sf_costs) && push!(results, MethodResult("TS-DDR (LSTM+SF)", lstm_sf_costs)) + !isnothing(strict_integer_costs) && + push!(results, MethodResult("TS-DDR Strict (Reachable+Int)", strict_integer_costs)) # Append non-TS-DDR baselines. push!(results, MethodResult("SDDP (MIP fwd)", sddp_mip_forward_costs)) @@ -891,7 +899,7 @@ function integer_results() # Collect timing tags for all present variants. timing_tags = ["integer", "integer_cr"] - for tag in ["integer_sf", "integer_hp", "integer_lstm", "integer_lstm_sf"] + for tag in ["integer_sf", "integer_hp", "integer_lstm", "integer_lstm_sf", "strict_integer"] !isnothing(resolve_file_optional("$(tag)_dr_timing.csv")) && push!(timing_tags, tag) end diff --git a/examples/inventory_control/train_dr_inventory.jl b/examples/inventory_control/train_dr_inventory.jl index 7777e1b..bff6228 100644 --- a/examples/inventory_control/train_dr_inventory.jl +++ b/examples/inventory_control/train_dr_inventory.jl @@ -115,6 +115,23 @@ struct InventoryTrainingVariant penalty::Float64 policy_builder::Function penalty_schedule_fn::Function + # Strict mode: hard target equalities (no deficit, no penalty). Requires a + # reachable policy — see InventoryReachablePolicy and strict_variants(). + strict::Bool +end + +# Backward-compatible 11-argument constructor: every historical call site +# predates strict mode, so it defaults to the penalty formulation. +function InventoryTrainingVariant( + tag, integer, num_batches, train_per_batch, learning_rate, warmup_batches, + training_integer_strategy, score_function, penalty, policy_builder, + penalty_schedule_fn, +) + return InventoryTrainingVariant( + tag, integer, num_batches, train_per_batch, learning_rate, warmup_batches, + training_integer_strategy, score_function, penalty, policy_builder, + penalty_schedule_fn, false, + ) end function InventoryTrainingVariant( @@ -168,6 +185,20 @@ function penalty_schedule_for(variant::InventoryTrainingVariant) return [warmup_phase, full_penalty_phase] end +""" + no_penalty_schedule(variant::InventoryTrainingVariant) -> Nothing + +Return `nothing`: strict-mode models have no deficit variables, so there is +no penalty to schedule (`train_multistage` accepts +`penalty_schedule = nothing`). + +# Examples +```julia +schedule = no_penalty_schedule(variant) # nothing +``` +""" +no_penalty_schedule(::InventoryTrainingVariant) = nothing + """ method_label(variant::InventoryTrainingVariant) -> String @@ -184,6 +215,10 @@ label = method_label(variant) function method_label(variant::InventoryTrainingVariant) tag = variant.tag + # --- Strict variants (reachable policy, no penalty) --- + tag == "strict" && return "TS-DDR Strict (Reachable)" + tag == "strict_integer" && return "TS-DDR Strict (Reachable+Int)" + # --- Relaxed tuned variants --- tag == "relaxed_lstm" && return "TS-DDR Relaxed (LSTM)" tag == "relaxed_hp" && return "TS-DDR Relaxed (HighPenalty)" @@ -403,7 +438,27 @@ det_eq, state_in, state_out, sampler, initial_state = ``` """ function build_training_problem(variant::InventoryTrainingVariant) - # Training uses a deterministic equivalent so target-dual gradients are coupled. + if variant.strict + # Strict variants train STAGE-WISE (closed loop). In this problem the + # target (order-up-to position s_mid) and the carried state + # (post-demand inventory s_out = s_mid − d) are different quantities, + # so the deterministic equivalent's target-feedback recursion would + # hand the reachable policy s_mid where it expects s_out — computing + # the reachable interval from the wrong state and breaking the strict + # feasibility guarantee. Stage-wise training feeds realized states, + # for which the interval [s, s + Q_max] is exact. (Contrast with the + # hydro case, where target and carried state are the same reservoir + # volume and the strict regular DE is safe by induction.) + return build_inventory_subproblems(; + num_scenarios = N_TRAIN_SCENARIOS, + seed = 42, + integer = variant.integer, + strict = true, + ) + end + + # Penalty variants use a deterministic equivalent so target-dual gradients + # are coupled across stages. return build_inventory_det_equivalent(; num_scenarios = N_TRAIN_SCENARIOS, penalty = variant.penalty, @@ -433,6 +488,7 @@ function build_evaluation_problem(variant::InventoryTrainingVariant) penalty = variant.penalty, seed = 99, integer = variant.integer, + strict = variant.strict, ) end @@ -485,6 +541,37 @@ function estimate_initial_loss( ) end +# Stage-wise method (strict variants train on subproblems with realized-state +# feedback): rolls the policy in closed loop, matching the training semantics. +function estimate_initial_loss( + policy, + subproblems::Vector{JuMP.Model}, + state_params_in, + state_params_out, + uncertainty_sampler, + initial_state, + variant::InventoryTrainingVariant, +) + # Use a small fixed sample only to seed SaveBest with a finite baseline. + Random.seed!(111) + + return mean( + let uncertainty_sample = sample(uncertainty_sampler) + # Closed-loop rollout: each stage sees the realized state. + Flux.reset!(policy) + simulate_multistage( + subproblems, + state_params_in, + state_params_out, + initial_state, + uncertainty_sample, + policy; + integer_strategy = variant.training_integer_strategy, + ) + end for _ in 1:12 + ) +end + """ train_variant!(policy, variant, det_eq, state_params_in, state_params_out, uncertainty_sampler, initial_state, model_path, curve_path; @@ -528,7 +615,12 @@ train_variant!(policy, variant, det_eq, spi, spo, sampler, x0, function train_variant!( policy, variant::InventoryTrainingVariant, - det_eq::JuMP.Model, + # Penalty variants train on the deterministic equivalent (JuMP.Model); + # strict variants train stage-wise (Vector{JuMP.Model}, realized-state + # feedback) because the target (order-up-to position s_mid) and the + # carried state (post-demand inventory s_out) are different quantities — + # target feedback would hand the reachable policy the wrong state. + det_eq::Union{JuMP.Model,Vector{JuMP.Model}}, state_params_in, state_params_out, uncertainty_sampler, @@ -577,6 +669,12 @@ function train_variant!( # Fix optimizer randomness for repeatability. Random.seed!(2024) + # The score-function keyword exists only on the deterministic-equivalent + # overload of train_multistage; the stage-wise overload (strict variants) + # must not receive it. + score_function_kwargs = det_eq isa JuMP.Model ? + (score_function = variant.score_function,) : NamedTuple() + elapsed_seconds = @elapsed train_multistage( policy, initial_state, @@ -589,7 +687,7 @@ function train_variant!( optimizer = Flux.Adam(variant.learning_rate), integer_strategy = variant.training_integer_strategy, penalty_schedule = variant.penalty_schedule_fn(variant), - score_function = variant.score_function, + score_function_kwargs..., record = (sample_log, iteration, current_policy) -> begin loss = isempty(sample_log.objectives_no_deficit) ? NaN : @@ -1084,6 +1182,45 @@ function inventory_training_variants() ), # Variant B: LSTM with tuned score function lstm_score_function_variant(), + # --- Strict variants (hard target equalities, no penalty tuning) --- + # The reachable policy guarantees ŝ ∈ [s, s + Q_max] exactly, so the + # strict equality s_mid == ŝ is always feasible and its dual is the + # pure shadow price — no penalty hyperparameter, no annealing. + InventoryTrainingVariant( + "strict", + false, + 800, + 10, + 1.0e-3, + 120, + NoIntegerStrategy(), + nothing, + INVENTORY_PENALTY, # unused in strict mode + () -> build_reachable_inventory_policy(; seed = 2024), + no_penalty_schedule, + true, + ), + # Strict + binary setup: FixedDiscreteIntegerStrategy reads exact LP + # shadow prices at the fixed integer assignment. The K·z jump at + # ŝ = s (order/no-order switch) is invisible to that local dual; a + # mixed score-function gradient can be layered on later using + # PENALTY-mode rollout models (ScoreFunctionConfig owns its own + # subproblems), since strict rollouts would reject perturbed targets + # that leave the reachable interval. + InventoryTrainingVariant( + "strict_integer", + true, + 800, + 10, + 8.0e-4, + 120, + FixedDiscreteIntegerStrategy(), + nothing, + INVENTORY_PENALTY, # unused in strict mode + () -> build_reachable_inventory_policy(; seed = 2024), + no_penalty_schedule, + true, + ), ] end diff --git a/examples/solve_dataset.jl b/examples/solve_dataset.jl deleted file mode 100644 index dcb3554..0000000 --- a/examples/solve_dataset.jl +++ /dev/null @@ -1,96 +0,0 @@ -################################################################ -###################### Dataset Generation ###################### -################################################################ - -using Distributed -using Random - -############## -# Load Functions -############## - -@everywhere l2o_path = dirname(@__DIR__) - -@everywhere import Pkg - -@everywhere Pkg.activate(l2o_path) - -@everywhere Pkg.instantiate() - -########## SCRIPT REQUIRED PACKAGES ########## - -@everywhere using L2O -@everywhere using UUIDs -@everywhere import ParametricOptInterface as POI -@everywhere using JuMP -@everywhere using UUIDs -@everywhere using Arrow - -## SOLVER PACKAGES ## - -@everywhere using Ipopt - -@everywhere filetype = ArrowFile - -########## PARAMETERS ########## -model_file = joinpath( - l2o_path, "examples/HydroPowerModels/case3/ACPPowerModel_det_equivalent.mof.json" -) -input_file = joinpath( - l2o_path, - "examples/HydroPowerModels/case3/case3_ACPPowerModel_input_4c4e8974-040e-11ef-1398-8195139913f4", -) -state_name = ["reservoir"; "out"] -save_path = joinpath(l2o_path, "examples/HydroPowerModels/case3/ACPPowerModel/output") -case_name = String(split(split(model_file, ".mof.")[1], "/")[end]) -processed_output_files = [ - file for file in readdir(save_path; join=true) if occursin(case_name, file) -] -ids = if length(processed_output_files) == 0 - UUID[] -else - vcat([Vector(Arrow.Table(file).id) for file in processed_output_files]...) -end -batch_size = 200 - -########## SOLVE ########## - -problem_iterator_factory, num_batches = load( - model_file, input_file, filetype; batch_size=batch_size, ignore_ids=ids -) - -@sync @distributed for i in 1:num_batches - ipopt = Ipopt.Optimizer() - MOI.set(ipopt, MOI.RawOptimizerAttribute("print_level"), 0) - cached = - () -> MOI.Bridges.full_bridge_optimizer( - MOI.Utilities.CachingOptimizer( - MOI.Utilities.UniversalFallback(MOI.Utilities.Model{Float64}()), ipopt - ), - Float64, - ) - POI_cached_optimizer() = POI.Optimizer(cached()) - batch_id = uuid1() - problem_iterator = problem_iterator_factory(i) - set_optimizer(problem_iterator.model, () -> POI_cached_optimizer()) - output_file = joinpath(save_path, "$(case_name)_output_$(batch_id)") - all_vars = all_variables(problem_iterator.model) - states = all_vars[findall( - x -> all([occursin(part, name(x)) for part in state_name]), all_vars - )] - recorder = Recorder{filetype}( - output_file; - primal_variables=states, - filterfn=(model) -> true, - model=problem_iterator.model, - ) - successfull_solves = solve_batch(problem_iterator, recorder) - @info "Solved $(length(successfull_solves)) problems" - L2O.compress_batch_arrow( - save_path, - case_name; - keyword_all="output", - batch_id=string(batch_id), - keyword_any=[string(batch_id)], - ) -end diff --git a/examples/RL/Project.toml b/experimental/RL/Project.toml similarity index 100% rename from examples/RL/Project.toml rename to experimental/RL/Project.toml diff --git a/examples/RL/README.md b/experimental/RL/README.md similarity index 100% rename from examples/RL/README.md rename to experimental/RL/README.md diff --git a/examples/RL/hydro_pre_trained.jl b/experimental/RL/hydro_pre_trained.jl similarity index 100% rename from examples/RL/hydro_pre_trained.jl rename to experimental/RL/hydro_pre_trained.jl diff --git a/examples/RL/hydropowermodels_rl.jl b/experimental/RL/hydropowermodels_rl.jl similarity index 100% rename from examples/RL/hydropowermodels_rl.jl rename to experimental/RL/hydropowermodels_rl.jl diff --git a/examples/RL/test.jl b/experimental/RL/test.jl similarity index 100% rename from examples/RL/test.jl rename to experimental/RL/test.jl diff --git a/src/DecisionRules.jl b/src/DecisionRules.jl index 5f90a6a..882e934 100644 --- a/src/DecisionRules.jl +++ b/src/DecisionRules.jl @@ -17,6 +17,7 @@ export simulate_multistage, simulate_states, simulate_stage, dense_multilayer_nn, + dense_policy_head, variable_to_parameter, create_deficit!, default_annealed_schedule, @@ -32,6 +33,10 @@ export simulate_multistage, ContinuousRelaxationIntegerStrategy, StallingCriterium, policy_input_dim, + ContextualPolicy, + context_at, + stage_phase_context, + vcat_contexts, normalize_recur_state, StateConditionedPolicy, state_conditioned_policy, @@ -113,11 +118,53 @@ tests to ensure that controlled problems never silently produce zero gradients. """ struct ErrorGradientFallback <: AbstractGradientFallback end +""" + _zero_cotangents(n_in, n_out) + +Create a tuple of zero/no tangents compatible with the `get_next_state` rrule pullback signature. + +Used by [`handle_gradient_error`](@ref) to produce a safe, neutral gradient when the +solver or DiffOpt differentiation fails. The returned tuple matches the cotangent +layout expected by `ChainRulesCore.rrule` for `get_next_state`: +four `NoTangent()` entries (for the function itself and non-differentiable arguments), +followed by dense zero vectors for the state-in and state-out dimensions, and a +trailing `NoTangent()`. + +# Arguments +- `n_in::Int`: dimension of the incoming state vector. +- `n_out::Int`: dimension of the outgoing state vector. + +# Returns +A `Tuple` of `NoTangent` and `Vector{Float64}` elements that Zygote can propagate +without error. +""" _zero_cotangents(n_in, n_out) = ( NoTangent(), NoTangent(), NoTangent(), NoTangent(), zeros(n_in), zeros(n_out), NoTangent(), ) +""" + handle_gradient_error(fallback::AbstractGradientFallback, e, n_state_in, n_state_out) + +Handle an exception raised inside the `get_next_state` rrule pullback. + +This is the **rrule-level** extension point: it is called when the backward pass +through a single stage fails (e.g., the solver returned an infeasible status and +DiffOpt cannot differentiate). Concrete methods decide whether to absorb the +error or propagate it. + +# Arguments +- `fallback::AbstractGradientFallback`: dispatch tag controlling recovery behavior. +- `e`: the caught exception. +- `n_state_in::Int`: dimension of the incoming state vector (needed to build zero cotangents). +- `n_state_out::Int`: dimension of the outgoing state vector. + +# Returns +A cotangent tuple (same layout as [`_zero_cotangents`](@ref)) when the error is +absorbed, or does not return (re-throws) when the error is propagated. + +See [`AbstractGradientFallback`](@ref) for how to implement custom subtypes. +""" function handle_gradient_error(::ZeroGradientFallback, e, n_state_in, n_state_out) @warn "get_next_state pullback failed — returning zero gradients" exception=(e, catch_backtrace()) return _zero_cotangents(n_state_in, n_state_out) @@ -127,6 +174,27 @@ function handle_gradient_error(::ErrorGradientFallback, e, n_state_in, n_state_o rethrow(e) end +""" + handle_training_error(fallback::AbstractGradientFallback, e, iter) + +Handle an exception raised during a full training iteration (gradient computation +and parameter update). + +This is the **training-loop-level** extension point: it is called when +`Zygote.gradient` or the subsequent optimizer update throws (e.g., a DiffOpt +assertion error or a numerical issue in the loss computation). Unlike +[`handle_gradient_error`](@ref), which operates inside a single-stage rrule, +this handler wraps the entire forward-backward pass for one iteration. + +# Arguments +- `fallback::AbstractGradientFallback`: dispatch tag controlling recovery behavior. +- `e`: the caught exception. +- `iter::Int`: current training iteration index (used in log messages). + +# Returns +- `true` to skip this iteration and continue training. +- Does not return (re-throws) when the error should propagate. +""" function handle_training_error(::ZeroGradientFallback, e, iter) @warn "Gradient computation failed at iter $iter — skipping update" exception=(e, catch_backtrace()) return true @@ -136,6 +204,25 @@ function handle_training_error(::ErrorGradientFallback, e, iter) rethrow(e) end +""" + handle_rollout_error(fallback::AbstractGradientFallback, e, iter) + +Handle an exception raised during a rollout evaluation scenario. + +This is the **rollout-level** extension point: it is called when a single +out-of-sample scenario fails during [`RolloutEvaluation`](@ref) (e.g., solver +infeasibility on an unseen uncertainty sample). Absorbing the error skips that +scenario and lets the evaluation continue with the remaining samples. + +# Arguments +- `fallback::AbstractGradientFallback`: dispatch tag controlling recovery behavior. +- `e`: the caught exception. +- `iter::Int`: scenario index within the rollout batch. + +# Returns +- `true` to skip this scenario and continue the rollout. +- Does not return (re-throws) when the error should propagate. +""" function handle_rollout_error(::ZeroGradientFallback, e, iter) @warn "Rollout scenario failed at iter $iter — skipping" exception=(e, catch_backtrace()) return true diff --git a/src/dense_multilayer_nn.jl b/src/dense_multilayer_nn.jl index 113ffac..f19578c 100644 --- a/src/dense_multilayer_nn.jl +++ b/src/dense_multilayer_nn.jl @@ -1,17 +1,97 @@ using Functors using ChainRulesCore +raw""" + dense_policy_head(num_inputs, num_outputs, layers; activation=Flux.relu) + +Create the feed-forward target head used after recurrent uncertainty encoding. + +Unlike [`dense_multilayer_nn`](@ref), the final layer also uses `activation`. +This is useful for bounded policies where the head must emit normalized values +such as `sigmoid(z) ∈ [0, 1]`. + +Mathematically, when `layers = [h₁, …, h_L]`, the head computes + +```math +H_\theta(z) = +\sigma\left(W_{L+1} + \sigma\left(W_L \cdots \sigma(W_1 z + b_1) \cdots + b_L\right) + + b_{L+1}\right). +``` + +This helper exists so state-conditioned TS-DDR policies can make the map +`[encoded_uncertainty; state] → target` nonlinear while keeping recurrence +confined to the uncertainty encoder. + +# Arguments +- `num_inputs::Int`: number of combined features, usually `encoded_uncertainty` + concatenated with the previous state. +- `num_outputs::Int`: number of target outputs. +- `layers::AbstractVector{Int}`: hidden widths for the nonrecurrent head. +- `activation`: activation used by each hidden layer and by the output layer. + +# Returns +- A `Dense` layer when `layers` is empty, otherwise a `Chain` of dense layers. + +# Examples +```julia +head = dense_policy_head(16, 3, [32, 32]; activation=sigmoid) +``` + +See also: [`state_conditioned_policy`](@ref), [`dense_multilayer_nn`](@ref) +""" +function dense_policy_head( + num_inputs::Int, + num_outputs::Int, + layers::AbstractVector{Int}; + activation=Flux.relu, +) + isempty(layers) && return Dense(num_inputs => num_outputs, activation) + head_layers = Any[Dense(num_inputs => layers[1], activation)] + for i in 1:(length(layers) - 1) + push!(head_layers, Dense(layers[i] => layers[i + 1], activation)) + end + push!(head_layers, Dense(layers[end] => num_outputs, activation)) + return Chain(head_layers...) +end + """ dense_multilayer_nn(num_inputs, num_outputs, layers; activation=Flux.relu, dense=Dense) Create a multi-layer neural network with the specified architecture. +Given hidden layer widths ``(h_1, \\dots, h_L)`` and activation ``\\sigma``, +the resulting `Chain` computes + +```math +f(x) = W_{L+1} \\, \\sigma\\bigl(W_L \\cdots \\sigma(W_1 x + b_1) \\cdots + b_L\\bigr) + b_{L+1}, +``` + +where ``W_k \\in \\mathbb{R}^{h_k \\times h_{k-1}}``, ``h_0 = \\text{num\\_inputs}``, +and the final layer ``W_{L+1} \\in \\mathbb{R}^{\\text{num\\_outputs} \\times h_L}`` +has no activation. When `layers` is empty, there is no hidden/output +distinction: the returned single dense layer uses `activation`, preserving the +same constructor semantics as `Dense(num_inputs, num_outputs, activation)`. + +If `dense` is a recurrent type (`LSTM`, `GRU`, `RNN`), pair notation +`in => out` is used instead of `(in, out, σ)`, and the last layer omits the +activation so it can act as a linear projection. + # Arguments -- `num_inputs::Int`: Number of input features -- `num_outputs::Int`: Number of output features -- `layers::Vector{Int}`: Hidden layer sizes -- `activation`: Activation function (default: Flux.relu) -- `dense`: Layer type (Dense, LSTM, etc.) +- `num_inputs::Int`: number of input features ``h_0``. +- `num_outputs::Int`: number of output features. +- `layers::Vector{Int}`: hidden layer widths ``(h_1, \\dots, h_L)``. +- `activation`: element-wise activation ``\\sigma`` (default: `Flux.relu`). +- `dense`: layer constructor (`Dense`, `LSTM`, `GRU`, `RNN`). + +# Returns +- `Chain` (or a single layer when `layers` is empty). + +# Examples +```julia +mlp = dense_multilayer_nn(10, 3, [64, 32]) # 10 → 64 → 32 → 3 +rnn = dense_multilayer_nn(5, 2, [16]; dense=LSTM) # 5 → 16 → 2 (LSTM) +``` """ function dense_multilayer_nn( num_inputs::Int, @@ -20,9 +100,14 @@ function dense_multilayer_nn( activation=Flux.relu, dense=Dense, ) + # Recurrent layers use pair notation (in => out) and ignore activation. is_recurrent = dense in (LSTM, GRU, RNN) + + # Helper that builds one hidden layer with the appropriate constructor form. _make_layer(in_dim, out_dim) = is_recurrent ? dense(in_dim => out_dim) : dense(in_dim, out_dim, activation) + + # No hidden layers: preserve Dense(input, output, activation) semantics. if length(layers) == 0 return if is_recurrent dense(num_inputs => num_outputs) @@ -30,10 +115,17 @@ function dense_multilayer_nn( dense(num_inputs, num_outputs, activation) end end + + # Interior hidden layers: h_2 → h_3 → … → h_{L-1}. midlayers = [_make_layer(layers[i], layers[i + 1]) for i in 1:(length(layers) - 1)] + + # First hidden layer maps from the input dimension. first_layer = _make_layer(num_inputs, layers[1]) + + # Final layer omits activation so the output is an unrestricted linear map. last_layer = is_recurrent ? dense(layers[end] => num_outputs) : dense(layers[end], num_outputs) + return Chain(first_layer, midlayers..., last_layer) end @@ -42,62 +134,200 @@ end Compute the input dimension for a policy network. -Policy networks receive `[uncertainty..., previous_state...]` as input, -so the input dimension is `num_uncertainties + num_states`. +Policy networks receive ``[w_t;\\; x_{t-1}]`` as input, so the required +dimension is -This format is consistent between subproblems and deterministic equivalent -formulations, enabling warmstarting policies trained with det_eq for use +```math +d_{\\text{in}} = \\dim(w_t) + \\dim(x_{t-1}). +``` + +This format is consistent between subproblem and deterministic-equivalent +formulations, enabling warm-starting policies trained with det_eq for use with subproblems. # Arguments -- `num_uncertainties::Int`: Number of uncertainty parameters per stage -- `num_states::Int`: Number of state variables +- `num_uncertainties::Int`: dimensionality of the stage uncertainty ``w_t``. +- `num_states::Int`: dimensionality of the state ``x_{t-1}``. # Returns -- `Int`: Total input dimension for the policy network +- `Int`: total input dimension ``d_{\\text{in}}``. + +# Examples +```julia +d = policy_input_dim(5, 3) # 8 +``` """ function policy_input_dim(num_uncertainties::Int, num_states::Int) + # Input is the concatenation [w_t; x_{t-1}]. return num_uncertainties + num_states end +function policy_input_dim(num_uncertainties::Int, num_states::Int, num_context::Int) + # Input is the concatenation [context_t; w_t; x_{t-1}]. + return num_context + num_uncertainties + num_states +end + """ policy_input_dim(uncertainty_samples, initial_state) Compute the input dimension for a policy network from problem data. +Infers ``\\dim(w_t)`` from the first uncertainty sample and ``\\dim(x)`` +from the initial state vector, then delegates to +[`policy_input_dim(::Int, ::Int)`](@ref). + # Arguments -- `uncertainty_samples`: Uncertainty samples from problem construction -- `initial_state`: Initial state vector +- `uncertainty_samples::Vector`: uncertainty samples; `length(uncertainty_samples[1])` + gives ``\\dim(w_t)``. +- `initial_state::Vector`: initial state vector; `length(initial_state)` gives + ``\\dim(x)``. # Returns -- `Int`: Total input dimension for the policy network +- `Int`: total input dimension ``d_{\\text{in}}``. + +# Examples +```julia +d = policy_input_dim(uncertainty_samples, x0) +``` """ function policy_input_dim(uncertainty_samples::Vector, initial_state::Vector) + # Infer dimensions from the first sample and the initial state. num_uncertainties = length(uncertainty_samples[1]) num_states = length(initial_state) return policy_input_dim(num_uncertainties, num_states) end +""" + ContextualPolicy(policy, context) + +Wrap a stage policy so each call receives known exogenous context before the +usual policy input. The wrapped policy is called as +`policy(vcat(context_at(context, t), input))`, where `t` is advanced once per +call and reset by `Flux.reset!`. + +This keeps training and rollout loops unchanged: context is data attached to +the trajectory, while the inner policy remains the only trainable component. +Matrix contexts are interpreted as `d_context x T`; function contexts are +called as `context(t)`. +""" +mutable struct ContextualPolicy{P,C} + policy::P + context::C + t::Int +end + +ContextualPolicy(policy, context) = ContextualPolicy(policy, context, 0) + +Functors.@functor ContextualPolicy (policy,) + +""" + context_at(context, t) + +Return the context vector for one-based stage `t`. +""" +function context_at(context::AbstractMatrix, t::Integer) + 1 <= t <= size(context, 2) || + throw(BoundsError(context, (:, t))) + return view(context, :, t) +end + +context_at(context::Function, t::Integer) = context(t) + +function (m::ContextualPolicy)(input) + m.t += 1 + return m.policy(vcat(context_at(m.context, m.t), input)) +end + +function Flux.reset!(m::ContextualPolicy) + m.t = 0 + Flux.reset!(m.policy) + return nothing +end + +""" + stage_phase_context(T; period, include_progress=true) + +Build a `d x T` context matrix encoding known calendar/stage information. +Rows are `sin(2*pi*t/period)`, `cos(2*pi*t/period)`, and, when +`include_progress=true`, `t/T`. + +The sine/cosine pair represents a cyclic process without a discontinuity +between the final and first period positions. A raw index would put those +neighbors far apart; one-hot period features would be exact but high +dimensional and would not encode adjacency. The optional progress feature has +a different purpose: it tells the policy how close it is to the optimization +horizon endpoint. +""" +function stage_phase_context(T::Integer; period::Integer, include_progress::Bool=true) + T >= 1 || throw(ArgumentError("T must be positive")) + period >= 1 || throw(ArgumentError("period must be positive")) + nrows = include_progress ? 3 : 2 + ctx = Matrix{Float32}(undef, nrows, T) + for t in 1:T + θ = 2f0 * Float32(pi) * Float32(t) / Float32(period) + ctx[1, t] = sin(θ) + ctx[2, t] = cos(θ) + if include_progress + ctx[3, t] = Float32(t) / Float32(T) + end + end + return ctx +end + +""" + vcat_contexts(a, b, ...) + +Vertically concatenate context matrices after checking that they cover the +same number of stages. +""" +function vcat_contexts(contexts::AbstractMatrix...) + isempty(contexts) && return Matrix{Float32}(undef, 0, 0) + T = size(first(contexts), 2) + all(size(c, 2) == T for c in contexts) || + throw(ArgumentError("all contexts must have the same number of columns")) + return vcat(contexts...) +end + """ StateConditionedPolicy -A policy architecture that separates temporal encoding from state conditioning: -- `encoder`: a recurrent cell (`LSTMCell`/`GRUCell`/`RNNCell`, or a `Chain` of them) - that encodes only the uncertainty sequence (temporal dependencies) -- `combiner`: a `Dense` layer that combines the encoder output with the previous - state to produce the next state +A policy architecture that separates temporal encoding from state conditioning. -Flux's recurrent cells are stateless (Flux >= 0.16): each call returns -`(output, new_state)` instead of mutating an internal `Recur`. `StateConditionedPolicy` -therefore carries the encoder's recurrent state itself in `state`, threading it through -one call per stage. Call `Flux.reset!` to clear it (back to `Flux.initialstates`) at the -start of a rollout. +The encoder is a recurrent cell (`LSTMCell`/`GRUCell`/`RNNCell`, or a `Chain` +of cells) that processes only the uncertainty sequence to capture temporal +dependencies. The combiner is a feed-forward target head that merges the +encoder output with the previous state to predict the next state. + +Given uncertainty ``w_t`` and previous state ``x_{t-1}``, the forward pass is + +```math +h_t, s_t = \\text{LSTM}(w_t, s_{t-1}) \\\\ +\\hat{x}_t = f_{\\text{combine}}([h_t;\\; x_{t-1}]) +``` -Input format: [uncertainty..., previous_state...] +where ``s_t`` is the hidden recurrent state carried across stages and +``f_{\\text{combine}}`` is a `Dense` layer with activation ``\\sigma``. + +Flux's recurrent cells are stateless (Flux >= 0.16): each call returns +`(output, new_state)` instead of mutating an internal `Recur`. +`StateConditionedPolicy` therefore carries the encoder's recurrent state +itself in `state`, threading it through one call per stage. Call +`Flux.reset!` to clear it (back to `Flux.initialstates`) at the start of +a rollout. + +# Fields +- `encoder::E`: recurrent cell or `Chain` of cells encoding uncertainty. +- `combiner::C`: feed-forward head mapping ``[h_t;\\; x_{t-1}]`` to + ``\\hat{x}_t``. +- `state::S`: current recurrent state ``s_t``, carried across calls. +- `n_uncertainty::Int`: dimensionality of ``w_t``. +- `n_state::Int`: dimensionality of ``x_{t-1}``. + +Input format: `[uncertainty..., previous_state...]`. """ mutable struct StateConditionedPolicy{E,C,S} encoder::E # Recurrent cell, or Chain of cells, that processes uncertainty only - combiner::C # Dense that combines encoder output with previous state + combiner::C # Feed-forward head combining encoder output with state state::S # Encoder recurrent state, carried across calls n_uncertainty::Int # Number of uncertainty dimensions n_state::Int # Number of state dimensions @@ -108,41 +338,91 @@ end Functors.@functor StateConditionedPolicy (encoder, combiner) """ - materialize_tangent(x) - -Recursively convert ChainRulesCore tangent types (MutableTangent, Tangent) -to plain NamedTuples/Arrays that Flux.update! can handle. + materialize_tangent(x::Number) -> Number -This is needed because Zygote produces MutableTangent for mutable structs (like Flux.Recur), -but Flux.update!/Optimisers.jl expects plain NamedTuples. +Return numeric tangents unchanged (leaf values are already plain scalars). """ materialize_tangent(x::Number) = x + +""" + materialize_tangent(x::AbstractArray) -> AbstractArray + +Return array tangents unchanged (arrays are already `Flux.update!`-compatible). +""" materialize_tangent(x::AbstractArray) = x + +""" + materialize_tangent(::Nothing) -> Nothing + +Map `nothing` tangents (unused parameters) to `nothing`. +""" materialize_tangent(::Nothing) = nothing + +""" + materialize_tangent(::ChainRulesCore.NoTangent) -> Nothing + +Map `NoTangent` (structural zeros for non-differentiable fields) to `nothing`. +""" materialize_tangent(::ChainRulesCore.NoTangent) = nothing + +""" + materialize_tangent(::ChainRulesCore.ZeroTangent) -> Nothing + +Map `ZeroTangent` (additive identity in the tangent space) to `nothing`. +""" materialize_tangent(::ChainRulesCore.ZeroTangent) = nothing +""" + materialize_tangent(t::ChainRulesCore.MutableTangent) -> NamedTuple + +Unwrap a `MutableTangent` (produced by Zygote for mutable structs such as +`Flux.Recur`) by extracting its backing `NamedTuple` and recursing. +""" function materialize_tangent(t::ChainRulesCore.MutableTangent) - # MutableTangent stores values in RefValues, extract them + # MutableTangent stores values in RefValues; extract them via backing. backing = ChainRulesCore.backing(t) return materialize_tangent(backing) end +""" + materialize_tangent(t::ChainRulesCore.Tangent) -> NamedTuple + +Unwrap an immutable `Tangent` by extracting its backing and recursing. +""" function materialize_tangent(t::ChainRulesCore.Tangent) + # Tangent backing is already a NamedTuple; recurse to handle nested types. backing = ChainRulesCore.backing(t) return materialize_tangent(backing) end +""" + materialize_tangent(nt::NamedTuple{K}) -> NamedTuple{K} + +Recurse through every field of a `NamedTuple`, materializing each value. +""" function materialize_tangent(nt::NamedTuple{K}) where {K} + # Apply materialize_tangent element-wise and reconstruct the same keys. vals = map(materialize_tangent, values(nt)) return NamedTuple{K}(vals) end +""" + materialize_tangent(t::Tuple) -> Tuple + +Recurse through every element of a `Tuple`, materializing each value. +""" function materialize_tangent(t::Tuple) return map(materialize_tangent, t) end +""" + materialize_tangent(ref::Base.RefValue) + +Dereference a `RefValue` wrapper (used inside `MutableTangent` fields) +and recurse on the contained value. +""" function materialize_tangent(ref::Base.RefValue) + # RefValue wraps a single value; extract it before recursing. return materialize_tangent(ref[]) end @@ -153,6 +433,7 @@ Return the underlying recurrent cell of `layer`. `Flux.LSTM`/`GRU`/`RNN` wrap a (`LSTMCell`/`GRUCell`/`RNNCell`) in a `.cell` field; if `layer` has no such field it is already a cell and is returned unchanged. """ +# Unwrap .cell field if present (LSTM → LSTMCell); return unchanged otherwise. _as_cell(layer) = hasfield(typeof(layer), :cell) ? layer.cell : layer """ @@ -161,7 +442,9 @@ _as_cell(layer) = hasfield(typeof(layer), :cell) ? layer.cell : layer Return the initial recurrent state for `encoder`: `Flux.initialstates(encoder)` for a single cell, or a tuple of per-layer initial states for a `Chain` of cells. """ +# Single cell: return (h0, c0) or equivalent from Flux.initialstates. _init_recurrent_state(cell) = Flux.initialstates(cell) +# Chain of cells: one initial state per layer, returned as a tuple. _init_recurrent_state(chain::Chain) = map(_init_recurrent_state, chain.layers) """ @@ -171,38 +454,106 @@ Advance `encoder` by one step on input `x` from recurrent `state`, returning the output and the updated state. For a `Chain` of cells, each layer's output feeds the next and each layer's state is threaded independently. """ +# Single cell: one stateful call returns (output, new_state). _step_encoder(cell, x, state) = cell(x, state) function _step_encoder(chain::Chain, x, states::Tuple) + # Delegate to the recursive tuple-based implementation. return _step_encoder_layers(chain.layers, x, states) end +""" + _step_encoder_layers(layers, x, states) -> (output, new_states) + +Recursively advance a tuple of recurrent layers by one time step. + +Each layer receives the output of the previous layer as input and its own +independent recurrent state. The base case (`layers == ()`) returns the +input unchanged with an empty state tuple. + +# Arguments +- `layers::Tuple`: remaining recurrent cells to evaluate. +- `x`: current input (or output of the prior layer). +- `states::Tuple`: per-layer recurrent states, same length as `layers`. + +# Returns +- `output`: output of the last layer in `layers`. +- `new_states::Tuple`: updated recurrent states, one per layer. +""" _step_encoder_layers(::Tuple{}, x, ::Tuple{}) = x, () function _step_encoder_layers(layers::Tuple, x, states::Tuple) + # Advance the first layer with its own recurrent state. out, new_state = _step_encoder(first(layers), x, first(states)) + + # Recurse on remaining layers, feeding this layer's output as input. rest_out, rest_states = _step_encoder_layers(Base.tail(layers), out, Base.tail(states)) + + # Reassemble the full state tuple: this layer's state followed by the rest. return rest_out, (new_state, rest_states...) end +""" + _state_eltype(state) -> Type + +Return the scalar element type of a recurrent state. + +For nested tuple states (e.g. LSTM's `(h, c)` or a `Chain`'s tuple of +per-layer states) this recurses into the first element until it reaches an +`AbstractVector`, then returns `eltype(v)`. The result is used to cast +inputs to the encoder's precision before each step. + +# Arguments +- `state::Tuple`: nested recurrent state. +- `v::AbstractVector`: leaf state vector. + +# Returns +- `Type`: the scalar element type (e.g. `Float32`). +""" _state_eltype(state::Tuple) = _state_eltype(first(state)) _state_eltype(v::AbstractVector) = eltype(v) +""" + (m::StateConditionedPolicy)(x) -> AbstractVector + +Execute the forward pass of the state-conditioned policy. + +The input `x` is split into the uncertainty portion ``w_t`` and the previous +state ``x_{t-1}``. The forward pass computes + +```math +h_t, s_t = \\text{encoder}(w_t, s_{t-1}) \\\\ +\\hat{x}_t = f_{\\text{combine}}([h_t;\\; x_{t-1}]) +``` + +where ``s_t`` is the updated recurrent state (stored in `m.state` for the +next call) and ``f_{\\text{combine}}`` is a `Dense` layer. + +# Arguments +- `x::AbstractVector`: concatenated input `[w_t..., x_{t-1}...]` of length + `m.n_uncertainty + m.n_state`. + +# Returns +- `AbstractVector`: predicted next state ``\\hat{x}_t``. +""" function (m::StateConditionedPolicy)(x) - # Split input into uncertainty and previous state + # Split the concatenated input into uncertainty w_t and previous state x_{t-1}. uncertainty = x[1:m.n_uncertainty] prev_state = x[(m.n_uncertainty + 1):end] - # Encode uncertainty through the recurrent encoder, carrying state across calls. - # Cast to encoder precision to keep the recurrent state type stable - # (avoids a Zygote codegen bug with nested-tuple convert when solver - # feeds Float64 into a Float32 LSTM). + # Determine the encoder's scalar precision from its current recurrent state. + # Casting the input avoids a Zygote codegen bug with nested-tuple convert + # when an upstream solver feeds Float64 into a Float32 LSTM. T = _state_eltype(m.state) + + # Advance the recurrent encoder by one step: h_t, s_t = encoder(w_t, s_{t-1}). encoded, new_state = _step_encoder(m.encoder, T.(uncertainty), m.state) + + # Persist the new recurrent state so the next call starts from s_t. m.state = new_state - # Combine encoded uncertainty with previous state + # Concatenate encoder output h_t with previous state x_{t-1}. combined = vcat(encoded, prev_state) - # Output next state prediction + # Map the combined vector through the feed-forward combiner to produce x_hat_t. return m.combiner(combined) end @@ -213,29 +564,62 @@ Reset the encoder's recurrent state to `Flux.initialstates`, e.g. before startin new rollout. """ function Flux.reset!(m::StateConditionedPolicy) + # Reinitialize s_0 to the cell's default (zeros for LSTM h/c). m.state = _init_recurrent_state(m.encoder) return nothing end """ state_conditioned_policy(n_uncertainty, n_state, n_output, layers; - activation=Flux.relu, encoder_type=Flux.LSTM) + activation=Flux.relu, encoder_type=Flux.LSTM, + combiner_layers=Int[]) + +Create a [`StateConditionedPolicy`](@ref) with the specified architecture. + +The resulting policy computes + +```math +h_t, s_t = \\text{encoder}(w_t, s_{t-1}) \\\\ +\\hat{x}_t = \\sigma\\bigl(W [h_t;\\; x_{t-1}] + b\\bigr) +``` -Create a StateConditionedPolicy with the specified architecture. +where the encoder is a stack of recurrent cells of width +``(l_1, \\dots, l_L)`` and the combiner has input dimension +``l_L + n_{\\text{state}}``. `combiner_layers` adds optional hidden layers +to this nonrecurrent combiner, making the state-to-target map nonlinear while +keeping recurrence confined to the uncertainty sequence. This distinction is +important for TS-DDR hydro experiments: inflow history is recurrent, but the +current reservoir state is used only as contemporaneous conditioning. # Arguments -- `n_uncertainty::Int`: Number of uncertainty input dimensions -- `n_state::Int`: Number of state dimensions (both input and output) -- `n_output::Int`: Number of output dimensions (typically same as n_state) -- `layers::Vector{Int}`: Hidden layer sizes for the encoder -- `activation`: Activation function for dense layers (default: relu) -- `encoder_type`: Recurrent layer/cell type (`LSTM`, `GRU`, `RNN`, or their `*Cell` - variants; default: `Flux.LSTM`). Must support `Flux.initialstates` and the stateful - `(x, state) -> (output, new_state)` call (Flux >= 0.16). - -# Architecture -- Encoder: encoder_type(n_uncertainty => layers[1]) -> ... -> layers[end] -- Combiner: Dense(layers[end] + n_state => n_output) +- `n_uncertainty::Int`: dimensionality of the uncertainty input ``w_t``. +- `n_state::Int`: dimensionality of the state ``x_{t-1}`` (both input and output). +- `n_output::Int`: output dimension (typically equal to `n_state`). +- `layers::Vector{Int}`: hidden layer widths ``(l_1, \\dots, l_L)`` for the encoder. +- `activation`: activation ``\\sigma`` for the combiner `Dense` layer + (default: `Flux.relu`). +- `encoder_type`: recurrent layer/cell constructor (`LSTM`, `GRU`, `RNN`, or + their `*Cell` variants; default: `Flux.LSTM`). Must support + `Flux.initialstates` and the stateful `(x, state) -> (output, new_state)` + interface (Flux >= 0.16). +- `combiner_layers::Vector{Int}`: hidden widths for the state-conditioned + target head. The default `Int[]` preserves the original single Dense head. + +# Returns +- `StateConditionedPolicy`: ready-to-use policy with initialized recurrent state. + +# Examples +```julia +policy = state_conditioned_policy(5, 3, 3, [16, 16]) +x = randn(Float32, 8) # [uncertainty(5); state(3)] +y = policy(x) # predicted next state (length 3) + +deep_head = state_conditioned_policy( + 5, 3, 3, [16, 16]; + activation = sigmoid, + combiner_layers = [32, 32], +) +``` """ function state_conditioned_policy( n_uncertainty::Int, @@ -244,28 +628,38 @@ function state_conditioned_policy( layers::Vector{Int}; activation=Flux.relu, encoder_type=Flux.LSTM, + combiner_layers=Int[], ) - # Build encoder (stack of recurrent cells that process uncertainty) + # Build encoder: a stack of recurrent cells that process only the uncertainty + # input w_t. The number of hidden layers determines the encoder topology. if length(layers) == 0 + # No hidden layers: single cell maps uncertainty directly to n_state. encoder = _as_cell(encoder_type(n_uncertainty => n_state)) encoder_output_dim = n_state elseif length(layers) == 1 + # One hidden layer: single cell with the specified width. encoder = _as_cell(encoder_type(n_uncertainty => layers[1])) encoder_output_dim = layers[1] else + # Multiple hidden layers: chain of cells, first maps from n_uncertainty. encoder_layers = [_as_cell(encoder_type(n_uncertainty => layers[1]))] for i in 1:(length(layers) - 1) + # Each subsequent cell maps from the previous layer's width. push!(encoder_layers, _as_cell(encoder_type(layers[i] => layers[i + 1]))) end encoder = Chain(encoder_layers...) encoder_output_dim = layers[end] end - # Build combiner (Dense that combines encoder output with previous state) - # Input: [encoded_uncertainty, previous_state] - # Output: next_state - combiner = Dense(encoder_output_dim + n_state => n_output, activation) + # Build combiner: feed-forward [h_t; x_{t-1}] → x_hat_t with activation σ. + combiner = dense_policy_head( + encoder_output_dim + n_state, + n_output, + collect(Int, combiner_layers); + activation=activation, + ) + # Initialize the recurrent state to Flux.initialstates for the chosen cell(s). return StateConditionedPolicy( encoder, combiner, _init_recurrent_state(encoder), n_uncertainty, n_state ) diff --git a/src/multiple_shooting.jl b/src/multiple_shooting.jl index 322d174..5173c54 100644 --- a/src/multiple_shooting.jl +++ b/src/multiple_shooting.jl @@ -33,6 +33,16 @@ Assumptions: using Base: accumulate using Zygote: Zygote +""" + _print_window_status_and_params(window, status; context="") + +Print a diagnostic dump for a window solve that did not reach an optimal status. + +Outputs: a primal feasibility report for `window.model`, the solver `status`, +the `window.stage_range`, and a sorted listing of every JuMP parameter in the +window model with its current value. The optional `context` string is included +in the header for traceability. +""" function _print_window_status_and_params(window, status; context::AbstractString="") header = isempty(context) ? "solve_window status" : "solve_window status ($context)" println("=====") @@ -92,6 +102,13 @@ function extract_uncertainty_params(window_uncertainties) end end +""" + _param_init_value(src::JuMP.VariableRef) -> Float64 + +Return the current parameter value of `src` if it is a JuMP `MOI.Parameter`; +otherwise return `0.0`. Silently returns `0.0` if `parameter_value` throws +(e.g., when the parameter has been deleted from the model). +""" function _param_init_value(src::JuMP.VariableRef) if JuMP.is_parameter(src) try @@ -103,6 +120,13 @@ function _param_init_value(src::JuMP.VariableRef) return 0.0 end +""" + _as_float64_vec(val) -> Vector{Float64} + +Coerce `val` to a `Vector{Float64}`. If `val` is already a `Vector{Float64}`, +return it as-is; if it is another `AbstractVector`, convert element-wise; if it +is a scalar, wrap it in a single-element vector. +""" function _as_float64_vec(val) if val isa AbstractVector return val isa Vector{Float64} ? val : Float64.(val) @@ -110,6 +134,16 @@ function _as_float64_vec(val) return [Float64(val)] end +""" + _create_like_variable(m::JuMP.Model, src::JuMP.VariableRef, t::Int; + force_parameter=false) -> JuMP.VariableRef + +Create a new variable in `m` that mirrors `src`. If `src` is a JuMP parameter +(or `force_parameter` is `true`), the new variable is created as an +`MOI.Parameter` initialized to [`_param_init_value`](@ref)`(src)`; otherwise a +free decision variable is created. The variable is named via +[`var_set_name!`](@ref) with stage suffix `t`. +""" function _create_like_variable( m::JuMP.Model, src::JuMP.VariableRef, t::Int; force_parameter::Bool=false ) @@ -368,6 +402,15 @@ function solve_window( ) end +""" + _set_window_parameters!(window_state_in_params, window_state_out_params, + s_in, targets) -> Nothing + +Write numeric initial-state and target values into the JuMP `MOI.Parameter` +variables of a window model before solving. `s_in` is broadcast into +`window_state_in_params`; each element of `targets` is broadcast into the +corresponding stage's target parameters in `window_state_out_params`. +""" function _set_window_parameters!( window_state_in_params, window_state_out_params, diff --git a/src/parameter_duals.jl b/src/parameter_duals.jl index 581f8d5..21b6c58 100644 --- a/src/parameter_duals.jl +++ b/src/parameter_duals.jl @@ -33,8 +33,19 @@ model = Model(HiGHS.Optimizer) @constraint(model, con, x >= 2 * p) @objective(model, Min, 3 * x + p) optimize!(model) -dual_p = compute_parameter_dual(model, p) # Should be -2 * dual(con) + 1 +dual_p = compute_parameter_dual(model, p) # = 2 * dual(con) + 1 (constraint x - 2p >= 0 has coef -2 on p, contribution -coef*dual) +# Hand-check: at the optimum x* = 2p the objective is 7p, so d(obj)/dp = 7 = 2*3 + 1 with dual(con) = 3. ``` + +# Limitations +Only affine, quadratic, and vector-affine constraint functions are inspected: if the +parameter appears in any other constraint function type (e.g. a nonlinear +`ScalarNonlinearFunction` constraint), that contribution is skipped with a one-time +warning and is NOT captured in the returned sensitivity. + +The constraint-dual formula is validated for `MIN_SENSE` objectives; for `MAX_SENSE` +models JuMP's dual sign conventions differ and this function's constraint contribution +has not been validated. """ function compute_parameter_dual(model::JuMP.Model, param::JuMP.VariableRef) if !JuMP.is_parameter(param) @@ -73,6 +84,20 @@ function _get_dual_from_constraints(model::JuMP.Model, param::JuMP.VariableRef) dual_contribution += _get_dual_from_vector_affine_constraints( model, param, F, S ) + # Variable-in-set constraints (variable bounds, MOI.Parameter definitions) + # carry no parameter coefficient to extract: the parameter's own definition + # constraint contributes nothing here, and a parameter cannot appear inside + # another variable's bound constraint. Skip them silently. + elseif F <: JuMP.VariableRef + # Intentionally no contribution. + else + # Any other constraint function type (e.g. ScalarNonlinearFunction) is not + # inspected, so if the parameter appears there its sensitivity contribution + # is silently zero. Warn once so the gradient gap is visible, but do not + # error: constraints of these types often do not involve parameters at all. + @warn "compute_parameter_dual: constraints of type ($F, $S) are not " * + "inspected; parameter sensitivities from such constraints are not " * + "captured." maxlog = 1 end end @@ -94,15 +119,11 @@ function _get_dual_from_affine_constraints(model::JuMP.Model, param::JuMP.Variab # Check if parameter appears in this constraint coef = _get_parameter_coefficient(func, param) if !iszero(coef) - try - con_dual = JuMP.dual(con) - # The dual contribution is -coefficient * constraint_dual - # This follows from the Lagrangian: L = f(x) + λ*(g(x) - p*coef - b) - # ∂L/∂p = -λ * coef - dual_contribution -= coef * con_dual - catch - # If dual is not available, skip this constraint - end + con_dual = JuMP.dual(con) + # The dual contribution is -coefficient * constraint_dual. + # This follows from the Lagrangian: L = f(x) + λ*(g(x) - p*coef - b) + # ∂L/∂p = -λ * coef. + dual_contribution -= coef * con_dual end end @@ -132,12 +153,8 @@ function _get_dual_from_quadratic_constraints(model::JuMP.Model, param::JuMP.Var total_coef = coef + quad_coef if !iszero(total_coef) - try - con_dual = JuMP.dual(con) - dual_contribution -= total_coef * con_dual - catch - # If dual is not available, skip this constraint - end + con_dual = JuMP.dual(con) + dual_contribution -= total_coef * con_dual end end @@ -158,17 +175,12 @@ function _get_dual_from_vector_affine_constraints( con_obj = JuMP.constraint_object(con) func = con_obj.func # Vector of AffExpr - try + coefs = [_get_parameter_coefficient(expr, param) for expr in func] + if any(!iszero, coefs) con_dual = JuMP.dual(con) # Vector of duals - - for (i, expr) in enumerate(func) - coef = _get_parameter_coefficient(expr, param) - if !iszero(coef) - dual_contribution -= coef * con_dual[i] - end + for (coef, dual_entry) in zip(coefs, con_dual) + dual_contribution -= coef * dual_entry end - catch - # If dual is not available, skip this constraint end end diff --git a/src/score_function.jl b/src/score_function.jl index 120d392..b396fc0 100644 --- a/src/score_function.jl +++ b/src/score_function.jl @@ -58,6 +58,10 @@ and the mixed gradient is - `perturbation_std::Real`: Gaussian standard deviation ``\\sigma``. - `num_rollouts::Integer`: number of perturbed rollouts ``M`` per sample. - `baseline::Symbol`: either `:mean` for mean-centering costs or `:none`. + Mean-centering reduces variance but, because the baseline is computed from the + same ``M`` rollouts, it introduces a small ``O(1/M)`` bias (effectively scaling + the estimator by ``(M-1)/M``) that vanishes as `num_rollouts` grows; a + leave-one-out baseline would be exactly unbiased. # Examples ```julia @@ -509,7 +513,10 @@ function _center_rollout_costs( costs::AbstractVector{<:Real}, baseline::Symbol, ) - # A mean baseline reduces variance without changing the expected gradient. + # A mean baseline computed from the SAME rollouts reduces variance but adds a + # small O(1/M) bias (the estimator is effectively scaled by (M-1)/M); the bias + # vanishes as the rollout count grows. A leave-one-out baseline would be + # exactly unbiased; mean-centering is kept for its simplicity. baseline_value = baseline === :mean ? mean(costs) : 0.0 return Float64.(costs) .- baseline_value diff --git a/src/simulate_multistage.jl b/src/simulate_multistage.jl index a5116e7..2703b07 100644 --- a/src/simulate_multistage.jl +++ b/src/simulate_multistage.jl @@ -72,6 +72,31 @@ function simulate_stage( ) end +""" + _set_stage_parameters!(state_param_in, state_param_out, uncertainty, + state_in, state_out_target) -> Nothing + +Write MOI parameter values into a single-stage JuMP subproblem before solving. + +Three groups of parameters are set: + +1. **Incoming state** ``x_{t-1}``: each element of `state_param_in` receives + the corresponding entry of `state_in`. +2. **Uncertainty** ``w_t``: each `(parameter, value)` pair in `uncertainty` + is written directly. +3. **Outgoing target** ``\\hat{x}_t``: the first element of each tuple in + `state_param_out` (the target parameter) receives the corresponding + entry of `state_out_target`. + +After this call the subproblem is ready for `optimize!`. + +# Arguments +- `state_param_in`: JuMP parameter variables for the incoming state. +- `state_param_out`: `(target_parameter, realized_state_variable)` pairs. +- `uncertainty`: `(parameter, value)` pairs for stage uncertainty ``w_t``. +- `state_in::AbstractVector{<:Real}`: realized incoming state ``x_{t-1}``. +- `state_out_target::AbstractVector{<:Real}`: policy target ``\\hat{x}_t``. +""" function _set_stage_parameters!( state_param_in, state_param_out, @@ -79,17 +104,17 @@ function _set_stage_parameters!( state_in, state_out_target, ) - # Update state parameters + # Write the realized incoming state into the input-state parameters. for (i, state_var) in enumerate(state_param_in) set_parameter_value(state_var, state_in[i]) end - # Update uncertainty + # Write sampled exogenous values into the uncertainty parameters. for (uncertainty_param, uncertainty_value) in uncertainty set_parameter_value(uncertainty_param, uncertainty_value) end - # Update state parameters out + # Write policy targets into the output-state target parameters. for i in 1:length(state_param_out) state_var = state_param_out[i][1] set_parameter_value(state_var, state_out_target[i]) @@ -97,6 +122,27 @@ function _set_stage_parameters!( return nothing end +""" + _simulate_stage(subproblem, state_param_in, state_param_out, uncertainty, + state_in, state_out_target, integer_strategy) -> Float64 + +Forward-solve one stage of the multistage problem and return the objective. + +Sets all parameters via [`_set_stage_parameters!`](@ref), then solves +`subproblem` through [`with_sensitivity_solution`](@ref) (which applies the +`integer_strategy` for models with discrete variables). Returns the scalar +optimal objective value ``q_t(x_{t-1}, w_t; \\hat{x}_t)``. + +# Arguments +- `subproblem::JuMP.Model`: stage-``t`` JuMP model. +- `state_param_in`: incoming-state parameters. +- `state_param_out`: `(target_parameter, realized_state_variable)` pairs. +- `uncertainty`: `(parameter, value)` pairs for ``w_t``. +- `state_in`: realized incoming state ``x_{t-1}``. +- `state_out_target`: policy target ``\\hat{x}_t``. +- `integer_strategy::AbstractIntegerStrategy`: controls how discrete + variables are handled during the solve. +""" function _simulate_stage( subproblem::JuMP.Model, state_param_in, @@ -106,15 +152,57 @@ function _simulate_stage( state_out_target, integer_strategy::AbstractIntegerStrategy, ) + # Write all parameter values into the model before solving. _set_stage_parameters!( state_param_in, state_param_out, uncertainty, state_in, state_out_target ) + # Solve and extract the objective value inside the sensitivity wrapper. return with_sensitivity_solution(subproblem, integer_strategy) do sensitivity_model + # Cache the deficit-free objective while the model is clean. Integer + # strategies dirty the model on cleanup (restoring integer bounds), so + # a later logger call would otherwise find a dirty model with no cache + # and throw. Mirrors the deterministic-equivalent forward pass. + subproblem.ext[:_last_obj_no_deficit] = + get_objective_no_target_deficit(sensitivity_model) return objective_value(sensitivity_model) end end +""" + _simulate_stage_with_parameter_duals(subproblem, state_param_in, state_param_out, + uncertainty, state_in, state_out_target, + integer_strategy) + -> (objective, d_state_in, d_state_out_target) + +Forward-solve one stage and extract parameter duals for the rrule pullback. + +Like [`_simulate_stage`](@ref), this sets parameters and solves the stage +problem. In addition it reads the dual sensitivities via [`pdual`](@ref): + +```math +\\mu_t = \\frac{\\partial q_t}{\\partial x_{t-1}}, \\qquad +\\lambda_t = \\frac{\\partial q_t}{\\partial \\hat{x}_t}. +``` + +These duals are the preferred (closed-form) gradient path used by the +[`simulate_stage`](@ref) rrule when parameter duals are available from the +solver. + +# Arguments +- `subproblem`: stage-``t`` JuMP model. +- `state_param_in`: incoming-state parameters (yields ``\\mu_t``). +- `state_param_out`: target parameters (yields ``\\lambda_t``). +- `uncertainty`: `(parameter, value)` pairs for ``w_t``. +- `state_in`: realized incoming state ``x_{t-1}``. +- `state_out_target`: policy target ``\\hat{x}_t``. +- `integer_strategy::AbstractIntegerStrategy`: discrete-variable strategy. + +# Returns +- `objective::Float64`: optimal stage cost ``q_t``. +- `d_state_in::Vector{Float64}`: ``\\mu_t`` (sensitivities w.r.t. incoming state). +- `d_state_out_target::Vector{Float64}`: ``\\lambda_t`` (sensitivities w.r.t. target). +""" function _simulate_stage_with_parameter_duals( subproblem, state_param_in, @@ -124,12 +212,20 @@ function _simulate_stage_with_parameter_duals( state_out_target, integer_strategy::AbstractIntegerStrategy, ) + # Write all parameter values into the model before solving. _set_stage_parameters!( state_param_in, state_param_out, uncertainty, state_in, state_out_target ) return with_sensitivity_solution(subproblem, integer_strategy) do sensitivity_model + # Read the optimal objective value. objective = objective_value(sensitivity_model) + # Cache the deficit-free objective while the model is clean (integer + # strategies dirty the model on cleanup; see _simulate_stage). + subproblem.ext[:_last_obj_no_deficit] = + get_objective_no_target_deficit(sensitivity_model) + # Extract duals w.r.t. incoming state parameters (mu_t). d_state_in = pdual.(state_param_in) + # Extract duals w.r.t. target parameters (lambda_t). d_state_out_target = pdual.([s[1] for s in state_param_out]) return objective, d_state_in, d_state_out_target end @@ -336,29 +432,132 @@ function ChainRulesCore.rrule( return y, public_pullback end +""" + get_objective_no_target_deficit(subproblem::JuMP.Model; + norm_deficit="norm_deficit") -> Float64 + +Compute the operational cost of a solved subproblem, excluding the +target-deficit penalty. + +The full objective includes a penalty ``C_\\delta \\|\\delta_t\\|`` that +penalizes deviations between realized and target states. This function +strips those terms so that logged costs reflect true operational cost: + +```math +\\text{cost}_t = q_t - \\sum_{j \\in \\mathcal{D}} c_j \\, \\delta_j, +``` + +where ``\\mathcal{D}`` is the set of variables whose names contain +`norm_deficit`. + +If the model is dirty (parameters changed since last solve), returns the +cached value from a previous successful call (stored in +`subproblem.ext[:_last_obj_no_deficit]`). If no such value exists, or if the +objective shape is unsupported, throws instead of inventing a cost. + +# Arguments +- `subproblem::JuMP.Model`: a solved JuMP model. + +# Keywords +- `norm_deficit::AbstractString`: substring matched against variable names + to identify deficit-penalty terms. +""" function get_objective_no_target_deficit( subproblem::JuMP.Model; norm_deficit::AbstractString="norm_deficit" ) + # If parameters were changed after the last solve, return the cached value. if subproblem.is_model_dirty - return get(subproblem.ext, :_last_obj_no_deficit, 0.0) + if haskey(subproblem.ext, :_last_obj_no_deficit) + return subproblem.ext[:_last_obj_no_deficit] + end + error( + "Cannot read objective without target deficit: " * + "model is dirty and no cached value exists", + ) end - try - obj = JuMP.objective_function(subproblem) - objective_val = objective_value(subproblem) - for term in obj.terms - if occursin(norm_deficit, JuMP.name(term[1])) - objective_val -= term[2] * value(term[1]) - end + + obj = JuMP.objective_function(subproblem) + objective_val = + objective_value(subproblem) - _target_deficit_penalty_value(obj, norm_deficit) + subproblem.ext[:_last_obj_no_deficit] = objective_val + return objective_val +end + +""" + _target_deficit_penalty_value(obj, norm_deficit) -> Float64 + +Return the part of a JuMP objective expression that is attributed to target +deficit variables. A variable is treated as a target-deficit variable when its +JuMP name contains `norm_deficit`. + +Proof sketch for the affine case: if the solved objective is +`q(x) + sum_i c_i d_i`, and `d_i` are exactly the matched target-deficit +variables, then the operational cost is the solved objective value minus +`sum_i c_i value(d_i)`. + +Quadratic terms involving target-deficit variables are deliberately rejected. +For such an objective, subtracting only the affine coefficient would not remove +the whole penalty and would produce a silently biased operational cost. +""" +function _target_deficit_penalty_value( + obj::JuMP.GenericAffExpr, norm_deficit::AbstractString +) + penalty = 0.0 + for (variable, coefficient) in obj.terms + if occursin(norm_deficit, JuMP.name(variable)) + penalty += coefficient * JuMP.value(variable) end - return objective_val - catch - return get(subproblem.ext, :_last_obj_no_deficit, 0.0) end + return penalty +end + +# Quadratic objectives are allowed only when target-deficit variables appear in +# the affine part; otherwise the penalty shape is ambiguous to this helper. +function _target_deficit_penalty_value( + obj::JuMP.GenericQuadExpr, norm_deficit::AbstractString +) + for (pair, _) in obj.terms + if occursin(norm_deficit, JuMP.name(pair.a)) || + occursin(norm_deficit, JuMP.name(pair.b)) + error("Quadratic target-deficit penalty terms are unsupported") + end + end + return _target_deficit_penalty_value(obj.aff, norm_deficit) +end + +# A bare deficit variable has implicit coefficient one. +function _target_deficit_penalty_value( + obj::JuMP.VariableRef, norm_deficit::AbstractString +) + return occursin(norm_deficit, JuMP.name(obj)) ? JuMP.value(obj) : 0.0 end +_target_deficit_penalty_value(::Real, ::AbstractString) = 0.0 + +function _target_deficit_penalty_value(obj, ::AbstractString) + error("Unsupported objective type for target-deficit stripping: $(typeof(obj))") +end + +""" + get_objective_no_target_deficit(subproblems::Vector{JuMP.Model}; + norm_deficit="norm_deficit") -> Float64 + +Sum the deficit-free operational costs across all stage subproblems. + +Calls the single-model [`get_objective_no_target_deficit`](@ref) on each +element and returns the total. + +# Arguments +- `subproblems::Vector{JuMP.Model}`: one solved JuMP model per stage. + +# Keywords +- `norm_deficit::AbstractString`: substring matched against variable names + to identify deficit-penalty terms. +""" function get_objective_no_target_deficit( subproblems::Vector{JuMP.Model}; norm_deficit::AbstractString="norm_deficit" ) + # Accumulate deficit-free costs across all stages. total_objective = 0.0 for subproblem in subproblems total_objective += get_objective_no_target_deficit( @@ -368,7 +567,11 @@ function get_objective_no_target_deficit( return total_objective end -# define ChainRulesCore.rrule of get_objective_no_target_deficit +# NOTE: get_objective_no_target_deficit is intentionally NON-DIFFERENTIABLE. +# This rrule returns NoTangent() for every input, i.e. a hard-zero gradient. The +# value is a logging/metric quantity only (deficit-free operational cost read from +# an already-solved model), and it MUST NOT appear in a loss whose gradient matters: +# any dependence of the loss on the policy through this function is silently dropped. function ChainRulesCore.rrule( ::typeof(get_objective_no_target_deficit), subproblem; norm_deficit="norm_deficit" ) @@ -379,10 +582,40 @@ function ChainRulesCore.rrule( return objective_val, _pullback end +""" + apply_rule(stage::Int, decision_rule, uncertainty, state_in) -> Vector + +Apply a single (shared) policy to produce the target state for stage `stage`. + +The policy receives a concatenated input vector +``[w_t^{(1)}, \\ldots, w_t^{(n_w)}, x_{t-1}^{(1)}, \\ldots, x_{t-1}^{(n_x)}]`` +and returns the next target ``\\hat{x}_t = \\pi_\\theta(w_t, x_{t-1})``. + +# Arguments +- `stage::Int`: current stage index (unused when a single rule is shared). +- `decision_rule`: callable policy ``\\pi_\\theta``. +- `uncertainty`: `(parameter, value)` pairs for ``w_t``; values are extracted. +- `state_in`: realized incoming state ``x_{t-1}``. +""" function apply_rule(::Int, decision_rule::T, uncertainty, state_in) where {T} + # Concatenate uncertainty values and incoming state into the policy input. return decision_rule(vcat([uncertainty[i][2] for i in 1:length(uncertainty)], state_in)) end +""" + apply_rule(stage::Int, decision_rules::Vector, uncertainty, state_in) -> Vector + +Apply a stage-specific policy from a vector of per-stage decision rules. + +Dispatches to `apply_rule(stage, decision_rules[stage], uncertainty, state_in)`, +selecting the rule at index `stage`. + +# Arguments +- `stage::Int`: current stage index, used to select `decision_rules[stage]`. +- `decision_rules::Vector`: one callable policy per stage. +- `uncertainty`: `(parameter, value)` pairs for ``w_t``. +- `state_in`: realized incoming state ``x_{t-1}``. +""" function apply_rule(stage::Int, decision_rules::Vector{T}, uncertainty, state_in) where {T} return apply_rule(stage, decision_rules[stage], uncertainty, state_in) end @@ -467,6 +700,32 @@ function simulate_multistage( ) end +""" + _set_multistage_parameters!(state_params_in, state_params_out, + uncertainties, states) -> Nothing + +Write MOI parameter values into a deterministic-equivalent JuMP model +across all ``T`` stages before solving. + +For each stage ``t = 1, \\ldots, T``: + +- **Initial state** (``t = 1`` only): `state_params_in[1]` receives + `states[1]` (the initial state ``x_0``). +- **Uncertainty** ``w_t``: each `(parameter, value)` pair in + `uncertainties[t]` is written. +- **Target** ``\\hat{x}_t``: the target parameters in + `state_params_out[t]` receive `states[t + 1]`. + +Note that `state_params_in[t]` for ``t > 1`` is NOT set here because in the +deterministic equivalent the incoming state is an internal variable linked +by constraints, not a parameter. + +# Arguments +- `state_params_in`: per-stage vectors of incoming-state parameters. +- `state_params_out`: per-stage vectors of `(target_parameter, state_variable)`. +- `uncertainties`: per-stage `(parameter, value)` pairs for ``w_t``. +- `states`: length-``(T+1)`` target trajectory ``[x_0, \\hat{x}_1, \\ldots, \\hat{x}_T]``. +""" function _set_multistage_parameters!( state_params_in, state_params_out, @@ -475,19 +734,20 @@ function _set_multistage_parameters!( ) for t in 1:length(state_params_in) state = states[t] - # Update state parameters in + # Only the initial state (t=1) is set as a parameter; later incoming + # states are internal variables in the deterministic equivalent. if t == 1 for (i, state_var) in enumerate(state_params_in[t]) set_parameter_value(state_var, state[i]) end end - # Update uncertainty + # Write sampled exogenous values into this stage's uncertainty parameters. for (uncertainty_param, uncertainty_value) in uncertainties[t] set_parameter_value(uncertainty_param, uncertainty_value) end - # Update state parameters out + # Write policy targets into this stage's output-state target parameters. for i in 1:length(state_params_out[t]) state_var = state_params_out[t][i][1] set_parameter_value(state_var, states[t + 1][i]) @@ -496,6 +756,26 @@ function _set_multistage_parameters!( return nothing end +""" + _simulate_multistage_det(det_equivalent, state_params_in, state_params_out, + uncertainties, states, integer_strategy) -> Float64 + +Solve the deterministic-equivalent model for a single uncertainty trajectory +and return the optimal objective. + +Sets all parameters via [`_set_multistage_parameters!`](@ref), solves the +coupled full-horizon problem ``Q(w; \\theta)`` through +[`with_sensitivity_solution`](@ref), and caches both the full objective and +the deficit-free operational cost in `det_equivalent.ext` for logging. + +# Arguments +- `det_equivalent::JuMP.Model`: full-horizon coupled JuMP model. +- `state_params_in`: per-stage incoming-state parameters. +- `state_params_out`: per-stage `(target_parameter, state_variable)` pairs. +- `uncertainties`: per-stage `(parameter, value)` pairs for ``w_t``. +- `states`: length-``(T+1)`` target trajectory from the policy. +- `integer_strategy::AbstractIntegerStrategy`: discrete-variable strategy. +""" function _simulate_multistage_det( det_equivalent::JuMP.Model, state_params_in, @@ -504,10 +784,13 @@ function _simulate_multistage_det( states, integer_strategy::AbstractIntegerStrategy, ) + # Write the full target trajectory and uncertainty into the DE model. _set_multistage_parameters!(state_params_in, state_params_out, uncertainties, states) return with_sensitivity_solution(det_equivalent, integer_strategy) do sensitivity_model + # Read the optimal objective value after solving. obj = objective_value(sensitivity_model) + # Cache both the full and deficit-free objectives for logging. sensitivity_model.ext[:_last_obj] = obj sensitivity_model.ext[:_last_obj_no_deficit] = get_objective_no_target_deficit(sensitivity_model) @@ -515,6 +798,42 @@ function _simulate_multistage_det( end end +""" + _simulate_multistage_det_with_parameter_duals(det_equivalent, state_params_in, + state_params_out, uncertainties, + states, integer_strategy) + -> (objective, Δ_states) + +Solve the deterministic equivalent and extract parameter duals for the +rrule pullback. + +Like [`_simulate_multistage_det`](@ref), this sets parameters and solves the +full-horizon problem. In addition it reads the dual sensitivities via +[`pdual`](@ref) for each stage: + +```math +\\Delta_{\\text{states}}[1] = \\frac{\\partial Q}{\\partial x_0}, \\qquad +\\Delta_{\\text{states}}[t+1] = \\lambda_t = \\frac{\\partial Q}{\\partial \\hat{x}_t}, +\\quad t = 1, \\ldots, T. +``` + +These ``\\lambda_t`` duals are the envelope-theorem gradient used in the +TS-DDR training objective (arXiv:2405.14973, Eq. 1.2). + +# Arguments +- `det_equivalent`: full-horizon coupled JuMP model. +- `state_params_in`: per-stage incoming-state parameters. +- `state_params_out`: per-stage `(target_parameter, state_variable)` pairs. +- `uncertainties`: per-stage `(parameter, value)` pairs for ``w_t``. +- `states`: length-``(T+1)`` target trajectory from the policy. +- `integer_strategy::AbstractIntegerStrategy`: discrete-variable strategy. + +# Returns +- `objective::Float64`: optimal coupled objective ``Q(w; \\theta)``. +- `Δ_states::Vector{Vector{Float64}}`: length-``(T+1)`` vector of parameter + duals; `Δ_states[1]` holds ``\\partial Q / \\partial x_0`` and + `Δ_states[t+1]` holds ``\\lambda_t``. +""" function _simulate_multistage_det_with_parameter_duals( det_equivalent, state_params_in, @@ -523,13 +842,18 @@ function _simulate_multistage_det_with_parameter_duals( states, integer_strategy::AbstractIntegerStrategy, ) + # Write the full target trajectory and uncertainty into the DE model. _set_multistage_parameters!(state_params_in, state_params_out, uncertainties, states) return with_sensitivity_solution(det_equivalent, integer_strategy) do sensitivity_model + # Read the optimal objective value after solving. objective = objective_value(sensitivity_model) + # Cache both the full and deficit-free objectives for logging. sensitivity_model.ext[:_last_obj] = objective sensitivity_model.ext[:_last_obj_no_deficit] = get_objective_no_target_deficit(sensitivity_model) + # Build the per-stage dual vector: initial-state duals at index 1, + # target-constraint duals lambda_t at index t+1. Δ_states = similar(states) Δ_states[1] = pdual.(state_params_in[1]) for t in 1:length(state_params_out) @@ -641,7 +965,9 @@ function ChainRulesCore.rrule( integer_strategy, ) pdual_available = true - catch + catch err + # Surface the reason the fast path was skipped without altering the fallback. + @debug "pdual path failed; falling back to DiffOpt reverse differentiation" exception = (err, catch_backtrace()) y = _simulate_stage( subproblem, state_param_in, @@ -791,7 +1117,9 @@ function ChainRulesCore.rrule( integer_strategy, ) pdual_available = true - catch + catch err + # Surface the reason the fast path was skipped without altering the fallback. + @debug "pdual path failed; falling back to DiffOpt reverse differentiation" exception = (err, catch_backtrace()) y = _simulate_multistage_det( det_equivalent, state_params_in, @@ -1084,30 +1412,52 @@ Q(\theta; w) = \sum_{t=1}^{T} q_t(x_{t-1}, w_t; \hat{x}_t), ``` -where each realized ``x_t`` is read from the previous stage solve. The gradient -therefore contains both the target duals ``\lambda_t`` and the sensitivity of -later realized states with respect to earlier targets. In the notation of the -extension note, +where each realized ``x_t`` is read from the previous stage solve. In this +single-shooting rollout ``\theta`` influences later stage costs through two +couplings: the realized-state chain (the solver map +``x_t = X_t(x_{t-1}, \hat{x}_t; w_t)`` propagates earlier targets forward), +and the **policy-feedback path** (the policy input at stage ``t`` is the +realized state ``x_{t-1}``, which itself depends on earlier targets). The exact +gradient is the total-derivative recursion ```math -\nabla_\theta Q(\theta; w) +\frac{d Q}{d \theta} = \sum_{t=1}^{T} \left[ - \frac{\partial q_t}{\partial \hat{x}_t} + \frac{\partial q_t}{\partial \hat{x}_t} \frac{d \hat{x}_t}{d \theta} + - \sum_{k=t+1}^{T} - \frac{\partial q_k}{\partial x_{k-1}} - \prod_{j=t+1}^{k-1} - \frac{\partial x_j}{\partial x_{j-1}} - \frac{\partial x_t}{\partial \hat{x}_t} -\right] -\nabla_\theta \pi_\theta(w_t, x_{t-1}). + \frac{\partial q_t}{\partial x_{t-1}} \frac{d x_{t-1}}{d \theta} +\right], +``` + +with the coupled state and target recursions (and ``d x_0 / d\theta = 0``) + +```math +\frac{d x_t}{d \theta} += +\frac{\partial X_t}{\partial x_{t-1}} \frac{d x_{t-1}}{d \theta} ++ +\frac{\partial X_t}{\partial \hat{x}_t} \frac{d \hat{x}_t}{d \theta}, +\qquad +\frac{d \hat{x}_t}{d \theta} += +\nabla_\theta \pi_\theta(w_t, x_{t-1}) ++ +\frac{\partial \pi_\theta}{\partial x_{t-1}} \frac{d x_{t-1}}{d \theta}. ``` -The dual terms come from target and transition constraints; the state -sensitivities are computed through DiffOpt in the rrules for -[`simulate_stage`](@ref) and [`get_next_state`](@ref). +All derivative products must be read as **total** derivatives that include the +policy-feedback composition: a term such as +``\partial \pi_\theta / \partial x_{k-1} \cdot d x_{k-1} / d\theta`` is present +at every stage, so ``\theta`` reaches stage ``k`` not only through the +realized-state chain ``\partial x_j / \partial x_{j-1}`` but also through the +policy input ``x_{k-1}``. Reverse-mode AD (Zygote through the stage rrules) +computes exactly this full chain: the dual terms from target and transition +constraints supply ``\partial q_t / \partial \hat{x}_t`` and +``\partial q_t / \partial x_{t-1}``, while the state sensitivities are computed +through DiffOpt in the rrules for [`simulate_stage`](@ref) and +[`get_next_state`](@ref). # Arguments - `model`: differentiable Flux-compatible policy. It receives @@ -1231,9 +1581,11 @@ function train_multistage( return objective end catch e - if handle_training_error(gradient_fallback, e, iter) - nothing - end + # handle_training_error rethrows for ErrorGradientFallback and logs a + # warning + returns true (skip this iteration) for ZeroGradientFallback; + # either way no gradient is available, so the try-expression is nothing. + handle_training_error(gradient_fallback, e, iter) + nothing end record(sample_log, iter, model) && break @@ -1248,19 +1600,6 @@ function train_multistage( return model end -function sim_states(t, m, initial_state, uncertainty_sample_vec, prev_states) - # Input: [uncertainty, previous_predicted_state] - # For t=1: return initial_state (no prediction needed) - # For t>1: policy receives [uncertainty[t-1], prev_states[t-1]] - if t == 1 - return Float32.(initial_state) - else - uncertainties_t = uncertainty_sample_vec[t - 1] - prev_state = prev_states[t - 1] - return m(vcat(uncertainties_t, prev_state)) - end -end - @doc raw""" train_multistage(model, initial_state, det_equivalent::JuMP.Model, state_params_in, state_params_out, uncertainty_sampler; @@ -1487,9 +1826,11 @@ function train_multistage( return objective end catch e - if handle_training_error(gradient_fallback, e, iter) - nothing - end + # handle_training_error rethrows for ErrorGradientFallback and logs a + # warning + returns true (skip this iteration) for ZeroGradientFallback; + # either way no gradient is available, so the try-expression is nothing. + handle_training_error(gradient_fallback, e, iter) + nothing end record(sample_log, iter, model) && break diff --git a/src/utils.jl b/src/utils.jl index 6dc07e5..5d6ee1c 100644 --- a/src/utils.jl +++ b/src/utils.jl @@ -27,21 +27,48 @@ end Create deficit variables to penalize state deviations in a JuMP model. -Supports three modes: -- L1 norm only: Uses `MOI.NormOneCone` (default if no penalty specified) -- L2 squared norm only: Uses sum of squared deviations (solver-compatible alternative to SecondOrderCone) -- Both norms: Creates both constraints with separate penalties +Supports three modes controlled by the penalty keywords. Let +``d \\in \\mathbb{R}^n`` be the deficit vector (`len = n`). + +**L1 norm only** (default when no penalty keyword is given, or `penalty_l1` +alone): + +```math +\\text{norm\\_deficit} \\geq \\| d \\|_1 = \\sum_{i=1}^{n} |d_i|, +\\quad \\text{objective} \\mathrel{+}= \\lambda_1 \\cdot \\text{norm\\_deficit}. +``` + +Implemented via `MOI.NormOneCone(1 + n)`. + +**L2 squared norm only** (`penalty_l2` alone): + +```math +\\text{norm\\_deficit} \\geq \\| d \\|_2^2 = \\sum_{i=1}^{n} d_i^2, +\\quad \\text{objective} \\mathrel{+}= \\lambda_2 \\cdot \\text{norm\\_deficit}. +``` + +**Both norms** (`penalty_l1` and `penalty_l2`): + +```math +\\text{norm\\_deficit} + \\geq \\lambda_1 \\| d \\|_1 + \\lambda_2 \\| d \\|_2^2, +\\quad \\text{objective} \\mathrel{+}= 1 \\cdot \\text{norm\\_deficit}. +``` # Arguments -- `model`: The JuMP model to add deficit variables to -- `len`: Number of deficit variables (typically dimension of state) -- `penalty_l1`: Penalty coefficient for L1 norm (NormOneCone). If `nothing` and L1 is used, defaults to max objective coefficient. -- `penalty_l2`: Penalty coefficient for L2 squared norm (sum of squares). If `nothing` and L2 is used, defaults to max objective coefficient. -- `penalty`: Legacy argument. If provided and penalty_l1/penalty_l2 are both `nothing`, uses this for L1 norm only. +- `model`: The JuMP model to add deficit variables to. +- `len`: Number of deficit variables (typically dimension of state). +- `penalty_l1`: Penalty coefficient ``\\lambda_1`` for the L1 norm + (`NormOneCone`). Pass `:auto` to use `max |objective coefficients|`. +- `penalty_l2`: Penalty coefficient ``\\lambda_2`` for the L2 squared norm + (sum of squares). Pass `:auto` to use `max |objective coefficients|`. +- `penalty`: Legacy argument. If provided and `penalty_l1`/`penalty_l2` are + both `nothing`, uses this for L1 norm only. # Returns -- `norm_deficit`: Single variable representing total penalized deviation (for logging compatibility) -- `_deficit`: Vector of deficit variables for each state dimension +- `norm_deficit`: Single variable representing total penalized deviation (for + logging compatibility). +- `_deficit`: Vector of deficit variables for each state dimension. # Examples ```julia @@ -381,6 +408,14 @@ function normalize_recur_state(state) end end +""" + (callback::SaveBest)(iter, model, loss) -> Bool + +Compare `loss` against the incumbent `callback.best_loss`. When `loss` is +strictly smaller, copy `model` to CPU, normalize recurrent state via +[`normalize_recur_state`](@ref), and write the Flux state to +`callback.model_path` with JLD2. Always returns `false` (never stops training). +""" function (callback::SaveBest)(iter, model, loss) if loss < callback.best_loss m = cpu(model) @@ -392,11 +427,36 @@ function (callback::SaveBest)(iter, model, loss) return false end +""" + StallingCriterium(patience::Int, best_loss::Float64, stall_count::Int) + +Early-stopping callback that halts training when the loss stalls. + +Tracks the number of consecutive iterations without improvement. When +`stall_count` reaches `patience`, the callback returns `true` to signal that +training should stop. Use `best_loss = Inf` and `stall_count = 0` for a fresh +start. + +# Arguments +- `patience::Int`: maximum consecutive non-improving iterations before stopping. +- `best_loss::Float64`: incumbent best loss. Use `Inf` to accept the first value. +- `stall_count::Int`: current stall counter (typically initialized to `0`). +""" mutable struct StallingCriterium <: Function patience::Int best_loss::Float64 stall_count::Int end + +""" + (callback::StallingCriterium)(iter, model, loss) -> Bool + +Update the stall counter and return `true` when `stall_count >= patience`. + +If `loss < best_loss`, reset the counter to zero and update the incumbent. +Otherwise increment `stall_count`. Returns `true` (stop training) once the +patience budget is exhausted; `false` otherwise. +""" function (callback::StallingCriterium)(iter, model, loss) if loss < callback.best_loss callback.best_loss = loss @@ -448,9 +508,25 @@ function Base.empty!(sample_log::SampleLog) return sample_log end +""" + _reset_sample_log!(sample_log::SampleLog) -> SampleLog + _reset_sample_log!(sample_log) -> typeof(sample_log) + +Clear the per-batch cache of a [`SampleLog`](@ref) before the next training +batch. For a `SampleLog`, delegates to `Base.empty!`; for any other type the +call is a no-op and returns `sample_log` unchanged. +""" _reset_sample_log!(sample_log::SampleLog) = empty!(sample_log) _reset_sample_log!(sample_log) = sample_log +""" + _total_objective_value(model::JuMP.Model) -> Float64 + _total_objective_value(models::Vector{JuMP.Model}) -> Float64 + +Return the objective value of `model`, falling back to the cached value +`model.ext[:_last_obj]` (default `0.0`) when the model is dirty or +`objective_value` throws. The multi-model method sums across all models. +""" function _total_objective_value(model::JuMP.Model) if model.is_model_dirty return get(model.ext, :_last_obj, 0.0) @@ -476,6 +552,13 @@ function (sample_log::SampleLog)(s::Int, models) return nothing end +""" + _sequential_mean(values) -> Float64 + +Compute the arithmetic mean of `values` using sequential accumulation (left +fold). This preserves the same floating-point summation order as the historical +`loss += ...; loss /= n` pattern inside the training loops. +""" # Sequential accumulation keeps the same floating-point summation order as the # historical `loss += ...; loss /= n` pattern inside the training loops. function _sequential_mean(values) @@ -642,6 +725,19 @@ function RolloutEvaluation( ) end +""" + _simulate_multistage_target_feedback(subproblems, state_params_in, + state_params_out, initial_state, uncertainties, decision_rules, + integer_strategy) -> Float64 + +Run a stage-wise rollout where the **target** state (not the realized state) is +fed back into the policy at each stage, matching the deterministic-equivalent +target-generation semantics from [`simulate_states`](@ref). Each stage +subproblem is solved sequentially; the accumulated objective value (including +target-deficit penalties) is returned. + +Used by [`RolloutEvaluation`](@ref) when `policy_state == :target`. +""" function _simulate_multistage_target_feedback( subproblems::Vector{JuMP.Model}, state_params_in, @@ -684,6 +780,18 @@ function _simulate_multistage_target_feedback( return objective end +""" + (evaluation::RolloutEvaluation)(iter, model) -> Nothing + +Evaluate the policy on the held-out scenario set every `stride` iterations. + +On active iterations (`iter % stride == 0`), rolls `model` out over all fixed +scenarios using either closed-loop (`:realized`) or target-feedback (`:target`) +semantics. Prints `metrics/rollout_objective_no_deficit` and +`metrics/rollout_target_violation_share`, and caches the values in +`evaluation.last_objective_no_deficit` / `evaluation.last_violation_share`. +Scenarios that fail to solve are skipped with a warning if all fail. +""" function (evaluation::RolloutEvaluation)(iter, model) iter % evaluation.stride == 0 || return nothing total = 0.0 @@ -739,6 +847,13 @@ function (evaluation::RolloutEvaluation)(iter, model) return nothing end +""" + var_set_name!(src::JuMP.VariableRef, dest::JuMP.VariableRef, t::Int) -> Nothing + +Name `dest` after `src` with a `#t` stage suffix. If `src` has a JuMP name, the +result is `"#"`; otherwise the MOI variable index is used as fallback, +producing `"_[]#"`. +""" function var_set_name!(src::JuMP.VariableRef, dest::JuMP.VariableRef, t::Int) name = JuMP.name(src) if !isempty(name) @@ -751,6 +866,21 @@ function var_set_name!(src::JuMP.VariableRef, dest::JuMP.VariableRef, t::Int) end end +""" + add_child_model_vars!(model, subproblem, t, state_params_in, state_params_out, + initial_state, var_src_to_dest, skip_parameter_refs) + -> Dict{VariableRef,VariableRef} + +Copy decision variables from stage-`t` `subproblem` into the deterministic- +equivalent `model`, populating the source-to-destination mapping +`var_src_to_dest`. State-coupling variables (incoming parameters and outgoing +realized-state/target pairs) are handled specially: at `t == 1` they become +fresh parameters in `model`; at `t > 1` incoming state parameters are linked to +the previous stage's realized state variables. Each copied variable is renamed +via [`var_set_name!`](@ref) with a `#t` suffix. Mutates `state_params_in`, +`state_params_out`, `var_src_to_dest`, and `skip_parameter_refs` in place; +returns `var_src_to_dest`. +""" function add_child_model_vars!( model::JuMP.Model, subproblem::JuMP.Model, @@ -759,6 +889,7 @@ function add_child_model_vars!( state_params_out::Vector{Vector{Tuple{Any,VariableRef}}}, initial_state::Vector{Float64}, var_src_to_dest::Dict{VariableRef,VariableRef}, + skip_parameter_refs::Set{VariableRef}, ) allvars = all_variables(subproblem) allvars = setdiff(allvars, state_params_in[t]) @@ -799,23 +930,30 @@ function add_child_model_vars!( for (i, src) in enumerate(state_params_in[t]) if src isa VariableRef var_src_to_dest[src] = state_params_out[t - 1][i][2] + push!(skip_parameter_refs, src) end state_params_in[t][i] = state_params_out[t - 1][i][2] - # delete parameter constraint associated with src - if src isa VariableRef - for con in - JuMP.all_constraints(subproblem, VariableRef, MOI.Parameter{Float64}) - obj = JuMP.constraint_object(con) - if obj.func == src - JuMP.delete(subproblem, con) - end - end - end end end return var_src_to_dest end +""" + copy_and_replace_variables(src, map::Dict{VariableRef,VariableRef}) + +Deep-copy a JuMP expression `src`, substituting every `VariableRef` key in +`map` with its destination value. Dispatches on the concrete expression type: + +- `Vector`: element-wise recursive call. +- `Real`: returned as-is (no variables to replace). +- `VariableRef`: direct lookup in `map`. +- `GenericAffExpr`: rebuild with remapped variable keys and same coefficients. +- `GenericQuadExpr`: rebuild affine part and remapped `UnorderedPair` keys. +- `GenericNonlinearExpr`: recursively remap arguments, then reconstruct via + `@expression`. + +Throws an error for unrecognized expression types. +""" function copy_and_replace_variables( src::Vector, map::Dict{JuMP.VariableRef,JuMP.VariableRef} ) @@ -875,6 +1013,18 @@ function copy_and_replace_variables(src::Any, ::Dict{JuMP.VariableRef,JuMP.Varia ) end +""" + create_constraint(model, obj, var_src_to_dest) -> ConstraintRef + +Add a constraint to `model` whose function is `obj.func` with all `VariableRef` +keys replaced via `var_src_to_dest` (see [`copy_and_replace_variables`](@ref)). + +Four methods handle different constraint types: +- Generic `ScalarConstraint`: uses `@constraint(model, new_func in obj.set)`. +- `ScalarConstraint{NonlinearExpr, MOI.EqualTo}`: `new_func == obj.set.value`. +- `ScalarConstraint{NonlinearExpr, MOI.LessThan}`: `new_func <= obj.set.upper`. +- `ScalarConstraint{NonlinearExpr, MOI.GreaterThan}`: `new_func >= obj.set.lower`. +""" function create_constraint(model, obj, var_src_to_dest) new_func = copy_and_replace_variables(obj.func, var_src_to_dest) return @constraint(model, new_func in obj.set) @@ -901,10 +1051,26 @@ function create_constraint( return @constraint(model, new_func >= obj.set.lower) end +""" + add_child_model_exps!(model, subproblem, var_src_to_dest, skip_parameter_refs, + state_params_out, state_params_in, t) -> Dict + +Copy all constraints and the objective contribution from stage-`t` `subproblem` +into the deterministic-equivalent `model`, remapping variables through +`var_src_to_dest` via [`create_constraint`](@ref) and +[`copy_and_replace_variables`](@ref). Constraint-based state parameters and +input parameters at `t == 1` are updated to point to the new model's +constraint refs. Parameter constraints for incoming states that are linked to +the previous realized state are skipped via `skip_parameter_refs`; all other +parameter constraints are copied. The subproblem objective is added to +`model`'s existing objective. Returns a `Dict` mapping source `ConstraintRef` +to destination `ConstraintRef`. +""" function add_child_model_exps!( model::JuMP.Model, subproblem::JuMP.Model, var_src_to_dest::Dict{VariableRef,VariableRef}, + skip_parameter_refs::Set{VariableRef}, state_params_out, state_params_in, t, @@ -914,6 +1080,11 @@ function add_child_model_exps!( cons_to_cons = Dict() for con in JuMP.all_constraints(subproblem; include_variable_in_set_constraints=true) #, F, S) obj = JuMP.constraint_object(con) + if obj.func isa VariableRef && + obj.set isa MOI.Parameter && + obj.func in skip_parameter_refs + continue + end c = create_constraint(model, obj, var_src_to_dest) cons_to_cons[con] = c if (state_params_out[t][1][1] isa ConstraintRef) @@ -961,6 +1132,9 @@ stage `t` with the incoming state parameter of stage `t+1`. Returns `(model, uncertainties_new)` where `uncertainties_new` has the same format as the input but with variable refs remapped to the deterministic-equivalent model. +This function also remaps `state_params_in` and `state_params_out` in place. +Copy those arrays before calling if you need to keep the original stage-wise +references for rollout evaluation or later model construction. """ function deterministic_equivalent!( model::JuMP.Model, @@ -972,6 +1146,7 @@ function deterministic_equivalent!( ) set_objective_sense(model, objective_sense(subproblems[1])) var_src_to_dest = Dict{VariableRef,VariableRef}() + skip_parameter_refs = Set{VariableRef}() for t in 1:length(subproblems) DecisionRules.add_child_model_vars!( model, @@ -981,13 +1156,20 @@ function deterministic_equivalent!( state_params_out, initial_state, var_src_to_dest, + skip_parameter_refs, ) end cons_to_cons = Vector{Dict}(undef, length(subproblems)) for t in 1:length(subproblems) cons_to_cons[t] = DecisionRules.add_child_model_exps!( - model, subproblems[t], var_src_to_dest, state_params_out, state_params_in, t + model, + subproblems[t], + var_src_to_dest, + skip_parameter_refs, + state_params_out, + state_params_in, + t, ) end @@ -1039,6 +1221,14 @@ function _remap_uncertainties( ] end +""" + find_variables(model::JuMP.Model, variable_name_parts::Vector{<:AbstractString}) + +Return variables from `model` whose JuMP name contains **all** substrings in +`variable_name_parts`. When the initial filter yields more than one variable, +results are reordered by matching `"[i]"` for `i = 1, 2, ...` to +produce a consistently indexed vector. +""" function find_variables(model::JuMP.Model, variable_name_parts::Vector{S}) where {S} all_vars = all_variables(model) interest_vars = all_vars[findall( diff --git a/test/runtests.jl b/test/runtests.jl index 84814a4..016e25d 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -317,6 +317,13 @@ include("test_score_function.jl") uncertainty_samples = [[(uncertainty_1, [2.0])], [(uncertainty_2, [1.0])]] initial_state = [5.0] + n_param_cons_before = length( + JuMP.all_constraints(subproblem2, VariableRef, MOI.Parameter{Float64}) + ) + has_state_in_param_before = any( + con -> JuMP.constraint_object(con).func == state_in_2, + JuMP.all_constraints(subproblem2, VariableRef, MOI.Parameter{Float64}), + ) det_equivalent, uncertainty_samples = DecisionRules.deterministic_equivalent!( quiet_nonlinear_ipopt_model(), subproblems, @@ -325,6 +332,14 @@ include("test_score_function.jl") initial_state, uncertainty_samples, ) + @test length( + JuMP.all_constraints(subproblem2, VariableRef, MOI.Parameter{Float64}) + ) == n_param_cons_before + @test has_state_in_param_before + @test any( + con -> JuMP.constraint_object(con).func == state_in_2, + JuMP.all_constraints(subproblem2, VariableRef, MOI.Parameter{Float64}), + ) obj_val = DecisionRules.simulate_multistage( det_equivalent, @@ -448,6 +463,26 @@ include("test_score_function.jl") optimize!(model5) @test compute_parameter_dual(model5, state_in5) ≈ -30.0 rtol=1.0e-1 @test compute_parameter_dual(model5, state_out5) ≈ 30.0 rtol=1.0e-1 + + model6 = Model() + @variable(model6, x6) + @variable(model6, p6 in MOI.Parameter(1.0)) + @constraint(model6, x6 - p6 >= 0) + @objective(model6, Min, x6) + @test_throws Exception compute_parameter_dual(model6, p6) + + # Test 7: documented docstring example (MIN sense) + # min 3x + p s.t. x >= 2*p, x >= 0 + # At optimality x* = 2p, so the objective is 7p and ∂obj/∂p = 7. + # The constraint normalizes to x - 2p >= 0 (coef of p is -2), dual = 3: + # contribution -(-2) * 3 = 6, plus the objective coefficient 1 → 7. + model7 = quiet_ipopt_model() + @variable(model7, x7 >= 0) + @variable(model7, p7 in MOI.Parameter(1.0)) + @constraint(model7, con7, x7 >= 2 * p7) + @objective(model7, Min, 3 * x7 + p7) + optimize!(model7) + @test compute_parameter_dual(model7, p7) ≈ 7.0 rtol=1.0e-2 end @testset "create_deficit!" begin @@ -1040,6 +1075,19 @@ include("test_score_function.jl") @test policy.n_uncertainty == n_uncertainty @test policy.n_state == n_state + policy_deep_head = state_conditioned_policy( + n_uncertainty, + n_state, + n_output, + layers; + activation=sigmoid, + encoder_type=Flux.LSTM, + combiner_layers=[7, 5], + ) + @test policy_deep_head.combiner isa Flux.Chain + Flux.reset!(policy_deep_head) + @test length(policy_deep_head(rand(Float32, n_uncertainty + n_state))) == n_output + # Test forward pass Flux.reset!(policy) input = rand(Float32, n_uncertainty + n_state) @@ -2128,6 +2176,9 @@ include("test_score_function.jl") # Empty layers (single layer) m_empty = dense_multilayer_nn(3, 2, Int[]; activation=relu, dense=Dense) @test size(m_empty(rand(Float32, 3))) == (2,) + m_empty.weight .= -1 + m_empty.bias .= 0 + @test all(m_empty(ones(Float32, 3)) .== 0) # Empty layers LSTM m_empty_lstm = dense_multilayer_nn(3, 2, Int[]; dense=LSTM) @@ -2147,12 +2198,36 @@ include("test_score_function.jl") @testset "policy_input_dim" begin @test policy_input_dim(5, 3) == 8 @test policy_input_dim(0, 4) == 4 + @test policy_input_dim(5, 3, 2) == 10 uncertainty_samples = [[(nothing, [1.0, 2.0]), (nothing, [3.0])]] initial_state = [0.0, 0.0, 0.0] @test policy_input_dim(uncertainty_samples, initial_state) == 5 end + @testset "ContextualPolicy" begin + ctx = stage_phase_context(4; period=4) + @test size(ctx) == (3, 4) + @test ctx[:, 1] == context_at(ctx, 1) + @test_throws BoundsError context_at(ctx, 5) + + ctx2 = fill(Float32(2), 1, 4) + @test size(vcat_contexts(ctx, ctx2)) == (4, 4) + @test_throws ArgumentError vcat_contexts(ctx, fill(Float32(0), 1, 3)) + + seen = Vector{Float32}[] + inner = x -> (push!(seen, Float32.(x)); Float32[x[1] + x[end]]) + policy = ContextualPolicy(inner, Float32[10 20; 30 40]) + + @test policy(Float32[1, 2]) == Float32[12] + @test policy(Float32[3, 4]) == Float32[24] + @test seen[1] == Float32[10, 30, 1, 2] + @test seen[2] == Float32[20, 40, 3, 4] + Flux.reset!(policy) + @test policy.t == 0 + @test context_at(t -> Float32[t, t + 1], 3) == Float32[3, 4] + end + @testset "normalize_recur_state" begin plain = (a=1.0, b=[2.0, 3.0]) @test normalize_recur_state(plain) == plain @@ -2271,6 +2346,24 @@ include("test_score_function.jl") DecisionRules.get_objective_no_target_deficit(sp1) + DecisionRules.get_objective_no_target_deficit(sp2) @test total ≈ indiv + + quad_model = quiet_ipopt_model() + @variable(quad_model, x) + @variable(quad_model, norm_deficit >= 0) + @constraint(quad_model, x == 2) + @constraint(quad_model, norm_deficit == 3) + @objective(quad_model, Min, x^2 + 10 * norm_deficit) + optimize!(quad_model) + @test DecisionRules.get_objective_no_target_deficit(quad_model) ≈ 4.0 atol=1.0e-4 + + bad_quad = quiet_ipopt_model() + @variable(bad_quad, z) + @variable(bad_quad, norm_deficit_bad >= 0) + @constraint(bad_quad, z == 1) + @constraint(bad_quad, norm_deficit_bad == 2) + @objective(bad_quad, Min, z^2 + norm_deficit_bad^2) + optimize!(bad_quad) + @test_throws ErrorException DecisionRules.get_objective_no_target_deficit(bad_quad) end @testset "materialize_tangent edge cases" begin