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/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