Skip to content

Configuration

All runtime parameters for novomodelo run are controlled by config.json in the case directory. This page documents every section and field. Every object in config.json rejects unknown keys, so a misspelled key fails the load with a parse error that names the key.


{
"training": {
"selection": { "method": "sampled", "forward_passes": 50 },
"stopping_rules": [{ "type": "iteration_limit", "limit": 100 }]
}
}

All other sections are optional with defaults documented below.


Every config.json key down to the second level, with its type and default; each row links its section.

NameTypeRequiredDefaultUnitsDescription
trainingobjectYes——Controls the SDDP training phase. See training.
training.selectionobjectYes——Scenario-selection method of the training forward pass, sampled or enumerated; the key is required. See training.selection.
training.stopping_rulesarrayYes——Rules that stop training; the key is required. See training.stopping_rules.
training.enabledbooleanNotrue—Runs the training phase; false skips to simulation. See training.
training.tree_seedinteger | nullNonull—Seed of the opening tree; null resolves to 42. See Seed resolution.
training.stopping_modestringNo"any"—One of "any", "all". How multiple stopping rules combine. See training.stopping_mode.
training.cut_selectionobjectNo{}—Row-management pipeline; row selection is off unless selection is set. See training.cut_selection.
training.solverobjectNo{}—Per-phase LP solver profile overrides; the two retry_* keys are accepted and have no effect. See training.solver.
training.parallelismobjectNo{}—Backward-pass worker-scheduling knobs. See training.parallelism.
training.scenario_sourceobject | nullNonull—Per-class forward-pass noise source; null reads in_sample for every class. See training.scenario_source.
simulationobjectNo{}—Controls the post-training simulation phase. See simulation.
simulation.enabledbooleanNofalse—Runs the simulation phase after training. See simulation.
simulation.selectionobject | nullNonull—Scenario-selection method of the simulation phase; null resolves to 2000 sampled scenarios. See simulation.selection.
simulation.io_channel_capacityintegerNo64—Capacity of the queue between the simulation workers and the output writer. See simulation.
simulation.solverobject | nullNonull—Solver profile of the simulation phase; null keeps the built-in profile. See Solver profile fields.
simulation.scenario_sourceobject | nullNonull—Scenario source of the simulation phase; null reuses training.scenario_source. See simulation.scenario_source.
simulation.cut_setstringNo"all"—One of "all", "active". Which policy rows the simulation’s stage LPs hold. See simulation.
modelingobjectNo{}—Controls physical modeling options. See modeling.
modeling.inflow_non_negativityobjectNo{}—Treatment of negative PAR model inflow draws. See modeling.inflow_non_negativity.
modeling.cost_scale_factornumber | nullNo1000000.0—Divisor on every non-θ objective coefficient; null or absent uses the default. See modeling.cost_scale_factor.
estimationobjectNo{}—Controls the PAR(p) model estimation pipeline. See estimation.
estimation.max_orderintegerNo6—Maximum lag order considered during model fitting. See estimation.
estimation.order_selectionstringNo"pacf"—One of "pacf", "pacf_annual". Order selection criterion. See estimation.
estimation.min_observations_per_seasonintegerNo30—Recommended minimum of fully covered season occurrences per season and hydro. See estimation.
estimation.max_coefficient_magnitudenumber | nullNonull—Reduces a fit to order 0 when any coefficient exceeds this magnitude. See estimation.
estimation.correlation_targetstringNo"inflows"—One of "inflows", "residuals". Series an estimated inflow correlation is computed from. See estimation.
estimation.history_yearsobject | nullNonull—Inclusive {"from", "to"} range of inflow_history.parquet years the estimation reads; null reads every year. See estimation.
policyobjectNo{}—Controls policy persistence. See policy.
policy.pathstringNo"./policy"—Policy directory, resolved against the run’s output directory. See policy.
policy.modestringNo"fresh"—One of "fresh", "warm_start", "resume". Initialization mode. See policy.
policy.boundaryobject | nullNonull—Terminal boundary cuts loaded from another study’s checkpoint. See policy.boundary.
policy.checkpointingobjectNo{}—Periodic checkpoints during training. See policy.checkpointing.
upper_bound_evaluationobjectNo{}—Accepted; no part of the run reads it. See upper_bound_evaluation.
upper_bound_evaluation.enabledboolean | nullNonull—Accepted; has no effect. See upper_bound_evaluation.
upper_bound_evaluation.initial_iterationinteger | nullNonull—Accepted; has no effect. See upper_bound_evaluation.
upper_bound_evaluation.interval_iterationsinteger | nullNonull—Accepted; has no effect. See upper_bound_evaluation.
upper_bound_evaluation.lipschitzobjectNo{}—Accepted; has no effect. See upper_bound_evaluation.
exportsobjectNo{}—Controls which outputs are written to the results directory. See exports.
exports.statesbooleanNofalse—Stores each pool’s trial states and writes them to the policy checkpoint. See exports.
exports.stochasticbooleanNofalse—Writes stochastic preprocessing artifacts. See exports.
exports.fpha_deviation_pointsbooleanNofalse—Writes the computed-FPHA fit-deviation table. See exports.
$schemastring | nullNonull—Optional schema URI; the loader does not read it. See Full Example.

Controls the SDDP training phase.

FieldTypeDescription
selectionobjectScenario-selection method for the training forward pass — sampled{forward_passes} or enumerated{} (see training.selection below). No default: a missing training.selection is a hard load error.
stopping_rulesarrayStopping rules (see below). The key is required and the list must contain at least one iteration_limit rule; a list without one, [] included, is refused when the configuration loads. Training never runs past the largest iteration_limit in the list.

Chooses how many trajectories the training forward pass runs per iteration, or whether it walks every path of the policy graph instead of sampling. The object is internally tagged on method; each variant accepts only its own fields — pairing forward_passes with "enumerated" is a load-time error (deny_unknown_fields).

FieldTypeRequiredDescription
methodstringYesOne of "sampled", "enumerated".
forward_passesintegersampled onlyNumber of scenario trajectories per iteration (>= 1). Larger values reduce variance in each iteration’s cut but increase cost per iteration. Rejected under "enumerated".

There is no default forward-pass count: an absent training.selection is a hard load error (SchemaViolation).

Example — sampled:

{ "method": "sampled", "forward_passes": 50 }

Example — enumerated (the forward pass walks every path of the policy graph instead of drawing a fixed count):

{ "method": "enumerated" }

Under enumerated, a scenario_source class reads the node’s declared opening only when it is in_sample, or external with a scenario column the node pins. A class on out_of_sample or historical, or on external without a pinned column, draws its own realization instead, so the reported bounds are those of the declared policy graph only when every class reads the node’s opening.

On two or more MPI ranks, enumerated training admits only a policy graph whose branching is all at the last stage (a deterministic trunk ending in a terminal fan); a graph with an interior branching node stops novomodelo run before training, with exit code 1. novomodelo validate does not check it, so a passing validation does not rule it out. The error message is listed under Communication failures.

Enumerated selection, in training or in simulation, also requires every node of the policy graph to carry a single opening: it walks each path of the policy graph and does not enumerate a node’s openings. A node that pins a scenario_id carries one, and its stage declares no num_openings; any other node carries the openings its stage generates, so that stage declares num_openings: 1 in stages.json. A case with a node carrying more is refused at study setup, by novomodelo validate and by novomodelo run before training, with exit code 1.

FieldTypeDefaultDescription
enabledbooleantrueSet to false to skip training and proceed directly to simulation (requires a pre-trained policy).
tree_seedinteger | nullnullSeed of the opening tree and of the in-sample opening draws. When null, the default seed 42 is used (deterministic but arbitrary), with no warning; a negative value is used by absolute value. See Seed resolution for how it relates to scenario_source.seed.
stopping_modestring"any"One of "any", "all". How multiple stopping rules combine: "any" stops when the first rule is satisfied; "all" stops when every rule other than iteration_limit is satisfied at the same iteration, and the largest iteration_limit caps the run.
cut_selectionobject{}Row-management (cut-selection) pipeline, nested at training.cut_selection (not a root key). See cut_selection.
solverobject{}Optional per-phase LP solver profile overrides; the two retry_* keys have no effect. See training.solver.
parallelismobject{}Backward-pass worker-scheduling knobs. See parallelism.
scenario_sourceobject | nullnullPer-class forward-pass noise source for the training forward pass. See scenario_source.

For the per-class scenario_source configuration, see the scenario_source sub-section below and Scenario Generation §3.

Controls where the forward-pass noise comes from for each entity class during training. When absent, all classes default to in_sample (reusing the pre-generated opening tree).

FieldTypeDefaultDescription
seedinteger | nullnullForward seed of training’s out-of-sample draws, and of the simulation’s when simulation.scenario_source is absent; required when any class is out_of_sample or external. Historical-window and external-scenario selection use no seed. See Seed resolution.
inflowobjectin_sampleSampling scheme for hydro inflow. Object with "scheme" key.
loadobjectin_sampleSampling scheme for bus load. Object with "scheme" key.
ncsobjectin_sampleSampling scheme for NCS availability. Object with "scheme" key.
historical_yearsarray | objectauto-discoverRestrict the pool of historical windows. When absent, every year of the history is a candidate. List ([1940, 1953]) or range ({"from": 1940, "to": 2010}). Each listed year names the window whose first study stage falls in that year’s occurrence of its season; eligibility follows Historical Window Pool, and a year that fails it is dropped without a message. An empty result is the “no valid historical windows found” error (Error Codes). The same pool supplies the historical_residuals openings.
openingsobject{"source": "generated"}Backward opening-tree source. {"source": "generated"} builds the tree internally, with the optional moment_matching of training.scenario_source.openings; {"source": "file"} reads a user-supplied tree from scenarios/noise_openings.parquet (sampled selection only, and not with a policy_graph.nodes[] declared in stages.json; either combination is rejected when the case is validated). Training only. A declared file that is missing stops the run in its stochastic phase (Opening-tree file missing).

Valid values for "scheme": "in_sample", "out_of_sample", "external" for every class; "historical" for inflow only.

Admission rules (checked at load; the messages are listed under Scenario-source admission rules):

  • historical is valid for inflow only — load or ncs on historical is rejected.
  • seed is required when any class is out_of_sample or external.
  • historical_years is rejected unless some class uses historical.
  • A historical_years range must have from <= to.
  • openings is accepted under training.scenario_source only; under simulation.scenario_source it is rejected.

For a class on the "external" scheme in training, these entities take the mean and standard deviation of the external file, per entity and stage:

  • the load buses of an external load class;
  • the NCS sources of an external NCS class;
  • the hydros of an external inflow class whose inflow model has AR order 0 and no annual component.

For an external class, load_seasonal_stats.parquet and non_controllable_stats.parquet are therefore optional; a load stats file that is present keeps its own rule of a row for every bus at every study stage. scenarios/inflow_seasonal_stats.parquet still requires, when present, a row for every hydro in service at each study stage, and an AR-order-0 hydro’s rows in inflow_seasonal_stats.parquet are not used to sample. A hydro with AR order above 0 or an annual component keeps the mean, standard deviation and coefficients its files declare (or the ones estimated from inflow_history.parquet when the files omit them). An external column with σ = 0 is accepted for load, NCS and an inflow model of AR order 0 with no annual component, and rejected for an inflow model whose files declare an AR order above 0 or an annual component (see Error Codes).

Example — out-of-sample inflow with in-sample load and NCS:

{
"training": {
"tree_seed": 42,
"selection": { "method": "sampled", "forward_passes": 50 },
"stopping_rules": [{ "type": "iteration_limit", "limit": 200 }],
"scenario_source": {
"seed": 99,
"inflow": { "scheme": "out_of_sample" },
"load": { "scheme": "in_sample" },
"ncs": { "scheme": "in_sample" }
}
}
}

See Scenario Generation §3 for a full description of each scheme and of historical windows.

Where the backward opening tree comes from and how a generated tree is corrected (Scenario Generation §2.3). When openings is absent, the tree is generated with moment_matching at its default.

FieldTypeDefaultDescription
sourcestring"generated"One of "generated", "file". "generated" builds the tree from the stages’ sampling_method; "file" reads it from scenarios/noise_openings.parquet.
moment_matchingstring"per_coordinate"One of "per_coordinate", "none"; accepted with "source": "generated" only. "per_coordinate" shifts and scales the inflow openings of each generated stage so that, for every hydro, their mean is 0 and their variance is the one the stage’s correlation gives that hydro’s noise (step 4 of §2.3); "none" keeps the openings as drawn. A historical_residuals stage, a stage with one opening, and the load and NCS noise are never matched.
{
"training": {
"scenario_source": {
"openings": { "source": "generated", "moment_matching": "none" }
}
}
}

moment_matching with "source": "file", or a value outside the two, is refused when config.json loads. The in-sample forward pass and the exported stochastic/noise_openings.parquet use the matched tree; out-of-sample forward draws are not matched. training/model_provenance.json records the mode of a generated tree as inflow.opening_tree_moment_matching (Metadata Files).

Each entry in stopping_rules is a JSON object with a "type" discriminator. Each rule’s stop condition is defined in Stopping Rules.

Stop after a fixed number of training iterations.

{ "type": "iteration_limit", "limit": 200 }
FieldTypeDescription
limitintegerMaximum number of SDDP iterations to run.

Use one iteration_limit entry: on a resumed run its limit counts the iterations of the earlier runs as well (Train in slices).

Stop after a wall-clock time budget is exhausted.

{ "type": "time_limit", "seconds": 3600.0 }
FieldTypeDescription
secondsnumberMaximum training time in seconds.

The rule compares seconds with the wall-clock seconds since this run’s training started, checked after each iteration.

Stop when the relative improvement in the lower bound falls below a threshold.

{ "type": "bound_stalling", "iterations": 20, "tolerance": 0.0001 }
FieldTypeDescription
iterationsintegerWindow size: the number of most recent recorded lower bounds compared.
tolerancenumberRelative improvement threshold. Training stops when the improvement over the window is below this value.

The rule cannot trigger before iterations bounds have been recorded; a resumed run continues the lower-bound series of its checkpoint, and a warm start begins with an empty series. With a positive tolerance, a window of 1 compares the bound with itself and triggers at the first iteration.

Stop when the exact upper bound has closed to within tolerance of the lower bound. Requires an enumerated training forward pass, so the upper bound being compared is exact rather than a statistical estimate.

{ "type": "gap", "tolerance": 1000.0, "relative_tolerance": 0.01 }
FieldTypeDescription
tolerancenumberOptional. Absolute gap tolerance, in the units of the reported bounds.
relative_tolerancenumberOptional. Relative gap tolerance in percent — 0.01 means 0.01%, compared against 100 · gap / max(1, |lower_bound|).

At least one of tolerance / relative_tolerance must be present; a gap rule with neither field is rejected when the configuration is validated: novomodelo validate reports it as ConfigValidationError, and novomodelo run prints the same message and exits 1. When both are present, the two arms combine by disjunction — training stops as soon as either arm is satisfied, not both. The gap itself is max(0, upper_bound − lower_bound).

Admissibility — the gap rule is accepted only when both hold:

  • training.selection.method is "enumerated" (the forward pass walks every path of the policy graph, so the upper bound is exact rather than a sampled estimate). Enumerated selection also requires every node of the policy graph to carry a single opening.
  • The risk measure is uniform across every stage: either risk_measure: "expectation" at every stage, or the same cvar measure (identical lambda and alpha) at every stage in stages.json (a cvar with lambda: 0 is expectation-equivalent). Under a uniform cvar the exact upper bound is computed as a nested, time-consistent risk recursion over the enumerated tree, so it still brackets the risk-averse lower bound.

Under sampled selection, with more than one opening on any node, or with a stage-varying measure (the risk measure differs across stages), the gap rule is rejected at study setup, by novomodelo validate and by novomodelo run before training (exit 1). The exact-bound comparison the rule depends on is unavailable in those cases.

When multiple stopping rules are listed, stopping_mode controls how they combine:

  • "any" (default): stop when any one rule is satisfied.
  • "all": stop when every rule other than iteration_limit is satisfied at the same iteration; the largest iteration_limit caps the run, and a smaller one has no effect.
{
"training": {
"selection": { "method": "sampled", "forward_passes": 50 },
"stopping_mode": "all",
"stopping_rules": [
{ "type": "iteration_limit", "limit": 500 },
{ "type": "bound_stalling", "iterations": 20, "tolerance": 0.0001 }
]
}
}

Groups the result-preserving worker-scheduling knobs that shape how backward-pass work is distributed across workers, alongside the algorithm-semantics fields at the training root.

backward_scheduler selects how backward-pass work units are claimed by workers. It is tagged on method; supplying a field that does not belong to the selected method is a load-time error (deny_unknown_fields), not a silently ignored key.

  • "by_scenario" (default) — each parallel work unit is one whole trial point.

    { "method": "by_scenario" }
  • "by_node" — each parallel work unit is one (trial point, opening block) pair, claimed dynamically off a shared counter.

    FieldTypeDefaultDescription
    block_sizeinteger | nullnullOpenings per block. Absent resolves per stage to ⌈|Ω_s|/2⌉ (half the openings, rounded up); a set value is silently clamped to min(|Ω_s|, block_size) — no error, no warning.

    Two configurations are load-time errors, not silently accepted:

    • block_size supplied under "by_scenario" — rejected (deny_unknown_fields).
    • block_size: 0 — rejected (minimum 1).

Within a stage, opening-blocks are claimed hardest-first: blocks are ranked by the previous iteration’s mean simplex-pivot cost per (stage, block), descending (ties broken by ascending block index; the first iteration, and any block with no prior data, sort last). This claim order changes only which worker processes which block, and when — it is result-neutral: the produced cut set and the training lower bound are identical to canonical-order claiming.

Example — default (by_scenario; no parallelism block needed):

{
"training": {
"selection": { "method": "sampled", "forward_passes": 50 },
"stopping_rules": [{ "type": "iteration_limit", "limit": 100 }]
}
}

Example — by_node with an explicit block_size:

{
"training": {
"selection": { "method": "sampled", "forward_passes": 50 },
"stopping_rules": [{ "type": "iteration_limit", "limit": 100 }],
"parallelism": {
"backward_scheduler": { "method": "by_node", "block_size": 4 }
}
}
}

For the backward pass this schedules work within, see SDDP Algorithm §3.4.


Controls the row-management pipeline for the row pool of each stage. The pipeline has up to two passes: a selection method and a per-stage cap on active rows. Deactivating a row removes it from the stage LPs and keeps it in the pool. For a detailed explanation of each pass, see Performance Accelerators and, for the selection methods themselves, Cut Management.

The block has two always-on knobs at the top level plus a selection sub-object that chooses the method and carries only that method’s parameters. Omitting selection (or setting it to null) disables row selection — that is the default.

FieldTypeDefaultDescription
row_activity_tolerancenumber1e-6Binding threshold for activity tracking: a row counts as binding at a solution point when its dual multiplier is strictly greater than this value (a signed comparison). The multipliers of a stage’s pool rows sum to at most that stage’s discount factor, so the threshold is dimensionless. The recorded activity is read only by max_active_per_stage and by the dynamic method’s seed_window, and it is recorded, and written to the policy checkpoint, only when one of them is configured. Must be >= 0; null is a parse error. 0 counts a multiplier at solver rounding level as binding.
max_active_per_stageintegernullCap on the active rows the current run has added to the pool of each stage strictly between the first and the last; each node’s pool is capped separately. Rows loaded from a policy neither count nor are evicted, and rows of the current iteration count but are never evicted, so a pool can hold more active rows than the cap. Applied every iteration, after the selection pass. The excess is evicted in ascending order of the iteration in which a row last bound, then of the number of solves in which it bound, then of its pool position. null = no cap. Refused with the dynamic method and with an enumerated training.selection.
selectionobjectnullThe active selection method and its parameters (see below). null (the default) disables row selection.

A cap below training.selection.forward_passes is accepted with a warning: a pool that receives that many rows per iteration then evicts, at every iteration, every row the run added in an earlier one.

selection.method is the discriminator; each method exposes only its own parameters. Supplying a parameter that belongs to a different method is a config load error, a misspelled method is rejected with the list of valid methods, and a selection given as an array is a parse error. A count parameter set to 0 is a parse error naming its key path, for example training.cut_selection.selection.check_frequency must be >= 1 (got 0).

  • "level1" — Level 1 selection over the pool of each stage strictly between the first and the last. Each such pool stores the trial state of every row the run adds. At each stored state the row with the highest value owns the state, among the pool’s scored rows, active or not, and its other loaded rows that are active; of rows whose values are exactly equal, the one at the lowest pool position owns it. Every check_frequency iterations a scored row is deactivated when it owns no stored state and reactivated when it is inactive and owns one. Values are compared exactly, and a row of the current iteration is judged like any other. A loaded row is scored when the policy records it so (its writing run stored its trial state, under level1 or exports.states); a loaded row that is not scored keeps the activity it was loaded with.

    FieldTypeDefaultDescription
    check_frequencyinteger5Iterations between selection passes. Must be >= 1.
    lookback_iterationsintegernullIterations of the current run whose rows keep their trial states. null keeps every state, and memory grows with the row count. A value w drops the states of rows older than the last w iterations, never a row: a row whose state was dropped stays in the pool and competes at the states that remain. A state loaded under warm_start counts as one from before the run’s first iteration. Memory per pool is then bounded by (lookback_iterations + check_frequency) times the most rows the run can add to that pool in one iteration, times the state dimension, times 8 bytes, plus the loaded states. Must be >= 1 and >= check_frequency.
  • "dynamic" — a per-solve lazy loop, Novomodelo’s own lazy row generation. From start_iteration on, each training solve starts with the seed rows, adds the candidate rows its solution violates, at most max_added_per_round per round, and solves again; it returns when no candidate is violated. After a fixed number of rounds the per-round limit is lifted. A simulation solve starts with every active row, so seed_window and candidate_recency apply to training only. The method never deactivates a row. It is refused under an enumerated training.selection at study setup, by novomodelo validate and by novomodelo run (exit 1).

    FieldTypeDefaultDescription
    start_iterationinteger2First 1-based iteration at which the lazy loop becomes active. Must be >= 1.
    seed_windowinteger5A solve starts with the active rows whose last binding was at most seed_window iterations ago (a row that has not bound counts from the iteration that added it), plus the rows of the current iteration. 0 seeds the rows of the current iteration and those that bound in it. A row loaded under warm_start, or from policy.boundary, counts from the start of the run.
    candidate_recencyintegernullnull: every active row is a candidate and a solve returns the optimum over them. A value n (must be >= 1) restricts the candidates to the rows added in the last n iterations and loaded rows; the result is then the optimum over those rows together with the seed rows. Under resume a reloaded row is a loaded row only when the run that wrote the checkpoint loaded it.
    max_added_per_roundinteger10Maximum rows added per lazy-solve round. Must be >= 1.
    violation_tolerancenumbernullA relative factor: a candidate row is added when its value exceeds the future-cost value by more than the factor times the larger of the two magnitudes. null: each phase uses the primal feasibility tolerance of its solver profile. A value must be finite, > 0, < 1, and at least the primal feasibility tolerance of every phase’s solver profile.

The two methods are exclusive by construction: the tagged selection block names one. A run that sets dynamic and simulates under the default simulation.cut_set "all" is refused at load when the policy it loads, or the policy.boundary rows, hold a row that "all" includes and that is not active.

Example with the dynamic method:

{
"training": {
"cut_selection": {
"row_activity_tolerance": 1e-6,
"selection": {
"method": "dynamic",
"start_iteration": 2,
"seed_window": 5,
"max_added_per_round": 10
}
}
}
}

Example with the level1 method and a per-stage cap:

{
"training": {
"cut_selection": {
"row_activity_tolerance": 1e-6,
"max_active_per_stage": 500,
"selection": {
"method": "level1",
"check_frequency": 5,
"lookback_iterations": 20
}
}
}
}

For the performance-tuning treatment of the same profiles, see Per-Phase Solver Profiles.

The two retry_* keys have no effect (Inert keys); backward and forward are optional per-phase LP solver profile overrides.

FieldTypeDefaultDescription
retry_max_attemptsinteger5Maximum solver retry attempts before propagating a hard error. No effect; see Inert keys.
retry_time_budget_secondsnumber30.0Total time budget in seconds across all retry attempts for one solve. No effect; see Inert keys.
backwardobject | nullnullPer-phase LP solver profile override applied during the backward pass.
forwardobject | nullnullPer-phase LP solver profile override applied during the forward pass.

simulation.solver (see simulation below) is a third, independent sibling that takes the identical shape — training.solver.backward, training.solver.forward, and simulation.solver all resolve against one shared set of solver-profile fields, documented once below.

Every field is optional and defaults to null. An absent field leaves the corresponding option at the phase’s built-in tuned profile — not the underlying solver’s own default profile; the two differ (for example, all three phase profiles set price to "row_hyper_sparse", while HiGHS’s own default pricing is "row"). Resolution happens once at setup — before any LP template is built — and every rank resolves the same profile from the broadcast configuration.

FieldType / values
dual_edge_weight"devex" | "steepest_edge" | "dantzig"
scale"off" | "solver_scaling"
price"row" | "row_hyper_sparse"
presolve"on" | "off" | "choose"
primal_feasibility_tolerancenumber
dual_feasibility_tolerancenumber
simplex_update_limitinteger
cost_perturbationnumber
factor_pivot_thresholdnumber
use_warm_startboolean
steepest_edge_devex_fallback_thresholdnumber
  • presolve affects only a genuinely cold solve — a warm-started solve skips presolve regardless of the setting.
  • use_warm_start chooses whether a phase’s HiGHS solves start from the stored basis. The built-in profiles set it to true for training.solver.forward and training.solver.backward, and to false for simulation.solver. Under false, HiGHS ignores the stored basis and solves cold, with presolve (on in every built-in profile). Set "use_warm_start": true in simulation.solver to warm-start the simulation; on a large LP a warm simulation can be slower than a cold one, because a warm solve skips presolve. A cold solve can stop at a different, equally optimal vertex than a warm-started one: the same objective value, possibly different duals. HiGHS retry escalation keeps the phase’s use_warm_start at every retry level. The CLP backend has no such setting: every phase starts from the stored basis when one exists. How the basis store feeds each phase is in the LP Warm-Start implementation notes.
  • dual_edge_weight: "steepest_edge" is a request, not a guarantee — HiGHS silently falls back to Devex pricing once the dual steepest-edge weight log-error exceeds steepest_edge_devex_fallback_threshold.

Six fields are range-checked; a value outside its range is rejected at study setup, by novomodelo validate and by novomodelo run (exit 1), with an error naming the phase and the offending field:

  • primal_feasibility_tolerance — must be finite.
  • dual_feasibility_tolerance — must be finite and >= 1e-10.
  • simplex_update_limit — must be <= 2147483647 (i32::MAX).
  • cost_perturbation — must be finite and >= 0.
  • factor_pivot_threshold — must be in [8e-4, 0.5].
  • steepest_edge_devex_fallback_threshold — must be finite and >= 1.0.

The closed enums (dual_edge_weight, scale, price, presolve) and use_warm_start are unconditionally valid — every variant is supported.

Per-phase solver-profile overrides are HiGHS-only. On the CLP backend, any field set under backward, forward, or simulation.solver is rejected at setup — deterministically, on every rank, before any LP template is built — with a named error identifying the phase and the field. An empty override block (for example "solver": {} or "backward": {}) and an absent block are both legal on CLP; only a field that is actually set triggers rejection. CLP starts the solves of every phase from a stored basis when one is available. See Installation — Choosing a Backend for backend selection and CLP’s other limitations.

Example — training.solver.backward with two overrides:

{
"training": {
"solver": {
"retry_max_attempts": 5,
"retry_time_budget_seconds": 30.0,
"backward": {
"dual_edge_weight": "steepest_edge",
"factor_pivot_threshold": 0.05
}
}
}
}

Controls the optional post-training simulation phase.

FieldTypeDefaultDescription
enabledbooleanfalseEnable the simulation phase after training.
selectionobject | nullnullScenario-selection method for the simulation phase — sampled{num_scenarios} or enumerated{} (see simulation.selection below). Absent resolves to a sampled count of 2000.
io_channel_capacityinteger64Capacity of the queue between the simulation workers and the output writer; 0 behaves as 1.
solverobject | nullnullSolver profile of the simulation phase, with the same fields as a training.solver phase profile (see training.solver). Absent leaves the phase’s built-in profile.
scenario_sourceobject | nullnullScenario source of the simulation phase; absent reuses training.scenario_source (see simulation.scenario_source).
cut_setstring"all"One of "all", "active". Which rows of each stage’s row pool the simulation loads into the stage LP (see Simulation cut set below).

"all" loads every row a training run added to the pool, including rows the selection method deactivated and rows max_active_per_stage evicted, so a simulation LP can be larger than the training LPs. "active" loads only the rows active when training ended.

A run with training disabled loads each row of the policy with the role it had in the run that wrote it, so "all" loads what that run’s "all" held and "active" the rows active when it ended; a resume does the same. Under warm_start and for policy.boundary rows, "all" loads a row the policy records as scored (its writing run stored the row’s trial state, under exports.states or level1) whatever its active flag, and any other loaded row only when that flag is set. The exported is_active flag records the last selection.

A run with the dynamic method that simulates under "all" is refused at load when it would hold a row that "all" includes and that is not active, in the policy it loads under warm_start or resume or with training disabled, or in the policy.boundary rows; set "active", or use the level1 method.

Chooses how many trajectories the post-training simulation runs, or whether it walks every path of the policy graph instead of sampling. Internally tagged on method, mirroring training.selection above. Unlike training.selection, this field is optional: an absent simulation.selection resolves to a sampled count of 2000.

FieldTypeRequiredDescription
methodstringYes (if present)One of "sampled", "enumerated".
num_scenariosintegersampled onlyNumber of independent Monte Carlo simulation scenarios to evaluate. Rejected under "enumerated".

When simulation.enabled is false, or the sampled num_scenarios count resolves to 0, the simulation phase is skipped entirely.

Under enumerated, the classes read the node’s opening as in training.selection: a class that does not read it draws its own realization instead. The single-opening requirement of training.selection applies here as well. When exactly one of training and simulation is enumerated, novomodelo run logs a setup warning naming the statistic the other phase lacks: with enumerated training and sampled simulation, the exact lower bound is available but the weighted census simulation statistics are not. The warning is advisory and the run proceeds; set both selections to enumerated for a census simulation.

Example:

{
"simulation": {
"enabled": true,
"selection": { "method": "sampled", "num_scenarios": 1000 }
}
}

Controls where the forward-pass noise comes from during the simulation phase. When absent, simulation falls back to the scheme configured under training.scenario_source. This allows you to train with in-sample noise and simulate with a different scheme (for example, out-of-sample or historical) without changing the training schemes. For which seed each draw uses, and the admission rule for the simulation seed, see Seed resolution.

The fields are those of training.scenario_source except openings, which is training-only. When simulation.scenario_source is present it replaces the training source as a whole — a class it omits defaults to in_sample, not to the training value:

FieldTypeDefaultDescription
seedinteger | nullnullForward seed of the simulation’s out-of-sample draws; required when a class of simulation.scenario_source is out_of_sample or external. See Seed resolution.
inflowobjectin_sampleSampling scheme for hydro inflow. Object with "scheme" key.
loadobjectin_sampleSampling scheme for bus load. Object with "scheme" key.
ncsobjectin_sampleSampling scheme for NCS availability. Object with "scheme" key.
historical_yearsarray | objectauto-discoverRestrict the pool of historical windows. List ([1940, 1953]) or range ({"from": 1940, "to": 2010}); each listed year is read as under training.scenario_source. Takes effect only when the training inflow scheme is not historical: when training is also historical, the simulation replays the training pool and this key has no effect.

The scheme values and admission rules are those of training.scenario_source; openings is rejected here.

A worked configuration is under Out-of-sample simulation.


Three seeds in config.json drive the random draws: training.tree_seed, training.scenario_source.seed and simulation.scenario_source.seed. The forward-pass selection of historical windows and external scenarios uses no seed.

  • training.tree_seed seeds the opening tree and the in-sample opening draws. When it is a non-null integer, Novomodelo uses |seed| (unsigned absolute value) as the base seed for deterministic SipHash-1-3 noise generation, so a negative seed -n acts as n. When it is absent or null, the seed is 42 and no warning is printed. Set it explicitly to make the choice intentional and visible to other users of the case directory.
  • training.scenario_source.seed is the forward seed of the out-of-sample draws. Novomodelo applies the same absolute-value rule: it uses |seed|. Inflow draws from it directly; load and NCS each derive their own stream from it, so the three classes draw independent noise. It is required whenever any class is out_of_sample or external.
  • The simulation’s in-sample draws use training.tree_seed, and its out-of-sample draws use simulation.scenario_source.seed, or training.scenario_source.seed when simulation.scenario_source is absent; simulation.scenario_source.seed is required when a class of simulation.scenario_source is out_of_sample or external.
  • A historical trajectory’s window and an external trajectory’s scenario are chosen by a deterministic hash of the iteration and trajectory indices that takes no seed.
  • The window each historical_residuals opening reads is part of the opening tree and follows training.tree_seed.

With the same seeds and inputs, the draws are identical across runs.


Controls physical modeling options.

FieldTypeDefaultDescription
inflow_non_negativityobject{}Strategy for handling negative PAR model inflow draws.
cost_scale_factornumber | null1000000.0Divisor on every non-θ objective coefficient (objective conditioning; does not alter the model, unlike this section’s other fields). See below.
FieldTypeDefaultDescription
methodstring"truncation_with_penalty"One of "none", "penalty", "truncation", or "truncation_with_penalty".

Under every method a hydro’s incremental inflow keeps the value the inflow model gives it, which may be negative, and the inflow lags of later stages are built from that value (aggregated over the lag’s period when the period spans several stages). The methods differ in the water a slack column may add to it in the hydro’s water balance:

  • "none" — no slack; a negative inflow can make a stage infeasible.
  • "penalty" — any non-negative amount, priced at the hydro’s inflow_nonnegativity_cost times the stage hours; the study-wide default of the cost is penalties.json::hydro.inflow_nonnegativity_cost (default 1000.0).
  • "truncation" — exactly max(-inflow, 0), at no cost, so the water balance receives max(inflow, 0). The amount is computed at every solve from that solve’s inflow lags.
  • "truncation_with_penalty" — any amount from 0 to max(-inflow, 0), priced as under "penalty".

Under "truncation" and "truncation_with_penalty" the lower bound can exceed the upper bound, and a gap stopping rule (admitted only under enumerated forward selection) can then report convergence that has not occurred.

The simulation output reports the incremental inflow as incremental_inflow_m3s and the slack as inflow_nonnegativity_slack_m3s (simulation/hydros/). The four methods are defined in Inflow Non-Negativity Solution Methods.

Example — the uncapped "penalty" slack in place of the default:

{
"modeling": {
"inflow_non_negativity": {
"method": "penalty"
}
}
}

Divisor applied to every non-θ objective coefficient at LP template build time; every cost-domain output (objective value, duals, cut coefficients) is multiplied back by the same factor at every reporting boundary. This is objective conditioning, not a physical modeling choice — unlike inflow_non_negativity above, results are identical in exact arithmetic; changing it never alters the model.

Defaults to 1000000.0 when absent or null. Must be finite and > 0; a value outside [1.0, 1e12] is accepted but logs an advisory warning — it is not rejected.

Example:

{
"modeling": {
"cost_scale_factor": 1000000.0
}
}

For the methodology, see LP Layout and Scaling §2.1.


Controls the PAR(p) model estimation pipeline of PAR(p) Inflow Model. When the case provides inflow_history.parquet, Novomodelo can automatically estimate AR coefficients instead of requiring pre-computed inflow_ar_coefficients.parquet.

FieldTypeDefaultDescription
max_orderinteger6Maximum lag order considered during autoregressive model fitting.
order_selectionstring"pacf"One of "pacf", "pacf_annual". Order selection criterion: PACF-based, or PACF with an annual component.
min_observations_per_seasoninteger30Recommended minimum number of fully covered occurrences of each season, per hydro: the samples the estimation fits from. An occurrence is one period of the season in season_definitions, inside or outside the study horizon; it counts only when the rows of inflow_history.parquet cover all of it and, with history_years set, only when it starts in one of those years. When estimation runs, a (hydro, season) group with at least one such occurrence but fewer than this draws a ModelQuality warning naming the hydro and the season, and estimation proceeds.
max_coefficient_magnitudenumber | nullnullSafety net: reduce to order 0 if any coefficient exceeds this magnitude.
correlation_targetstring"inflows"One of "inflows", "residuals". Series the spatial inflow correlation is estimated from when the inflow model is fitted, in whole or in part, from inflow_history.parquet and the case supplies no scenarios/correlation.json: the standardized inflows ("inflows") or the residuals of the fitted autoregression ("residuals"); see PAR(p) Inflow Model §6.1. training/model_provenance.json records it as inflow.correlation_target.
history_yearsobject | nullnullInclusive {"from": 1931, "to": 2024} range of the inflow_history.parquet years the estimation reads: a sample is read when the season occurrence it belongs to starts in a year of the range. The range limits the seasonal statistics, the autoregressive coefficients, the annual component and the estimated correlation; it restricts no other reader of the file: the derived inflow-lag seed, the windows of the historical scheme (which historical_years restricts) and the historical_residuals openings. null reads every year. from after to is refused when config.json loads, and, when the run estimates from inflow_history.parquet, so is a range reaching before the first or past the last year of the file (Estimation history years outside the history).

Example:

{
"estimation": {
"max_order": 6,
"order_selection": "pacf",
"min_observations_per_season": 30
}
}

Setting "order_selection": "pacf_annual" activates the annual component extension. When enabled, the estimation pipeline performs four additional steps beyond the classical PAR path: (1) the Yule-Walker system is extended to include a cross-correlation term between the current-season inflow and the rolling 12-month average; (2) per-season sample statistics (mean and standard deviation) of that rolling average are computed for each hydro plant; (3) the coefficient, mean, and standard deviation are written to inflow_annual_component.parquet under output/stochastic/ when exports.stochastic is true; and (4) the lag stride used when building the LP noise columns is widened to accommodate the extra annual term. Use this option when your inflow series shows persistence that extends beyond the standard seasonal lag window.


Controls policy persistence (checkpoint saving and warm-start loading).

FieldTypeDefaultDescription
pathstring"./policy"Policy directory, resolved against the run’s output directory (<case>/output by default); training writes the checkpoint there and warm-start, resume and simulation-only read it. An empty path, ., .. or a path with no named component is refused when the configuration loads; after resolution, and through a symbolic link’s target, a path that is the output directory or one of its ancestors, that names or contains a directory whose files a run replaces (such as simulation/solver or training/solver), or that lies inside one a run removes whole (such as simulation/costs) is refused. This directory holds only whole checkpoints: a run whose training ends in an error writes its policy to the sibling <path>.partial, replacing one already there, and leaves this directory as the last whole checkpoint left it. A run reads the sibling only when policy.path names it, and a resume of it is refused. The checkpoint’s files are listed under Policy Checkpoint.
modestring"fresh"One of "fresh", "warm_start", "resume". Initialization mode. "fresh" starts from scratch; "warm_start" loads cuts from a previous run; "resume" continues an interrupted run as it would have continued, restoring the iteration numbering, each row’s role, binding record and stored trial state, and each scenario’s LP basis. A resume is refused when the checkpoint cannot continue the run identically (Resume); a warm_start is not refused for those reasons.
boundaryobject | nullnullTerminal boundary cut configuration for coupling with an outer model’s FCF. See below.

enabled, initial_iteration and interval_iterations schedule periodic checkpoints (Policy Management — Checkpointing Configuration); store_basis and compress have no effect (Inert keys).

FieldTypeDefaultDescription
enabledboolean | nullnulltrue turns periodic checkpoints on; null or false leaves them off.
initial_iterationinteger | nullnullFirst iteration to write a checkpoint, in absolute iteration numbers; null means interval_iterations.
interval_iterationsinteger | nullnullIterations between checkpoints; required and at least 1 when enabled is true.
store_basisboolean | nullnullReserved and not read: a checkpoint holds the LP bases of the run’s scenarios whatever its value. See Inert keys.
compressboolean | nullnullReserved and not read: checkpoint files are written uncompressed whatever its value. See Inert keys.

Optional configuration for loading terminal-stage boundary cuts from a different Novomodelo policy checkpoint. When present, the solver loads cuts from the source checkpoint and injects them as fixed boundary conditions at the terminal stage of the current study. The imported cuts are not updated by training — they remain fixed throughout.

This enables Novomodelo-to-Novomodelo model coupling: an upstream study produces a policy checkpoint, and a chained study imports one pool of that checkpoint as its fixed terminal function (Post-Study Boundary & Chained Studies §5).

The source pool is selected automatically by the current study’s terminal boundary date (the last non-negative stage’s end_date) — there is no stage-index knob. strict governs a source that prices more than this study models.

FieldTypeDefaultDescription
pathstring—Path to the source checkpoint directory, resolved against this case directory (an absolute path is used as is), so a sibling study’s checkpoint is ../<study>/output/policy.
strictbooleanfalseReject the load when the source prices an entity or commitment this study does not model. false drops the surplus (recorded in the reconciliation report) and loads.

Example — load an upstream study’s policy as the terminal boundary:

{
"policy": {
"mode": "fresh",
"boundary": {
"path": "../upstream_study/output/policy",
"strict": false
}
}
}

Running novomodelo validate --json on a case that configures a boundary and trains emits the selected date and the per-family reconciliation report as one object — the success shape carries configured, boundary_date, and report. The boundary is reconciled only when the run trains, so a case with training disabled reports configured: false:

{
"configured": true,
"boundary_date": "2027-12-01",
"report": {
"reconciled": true,
"storage": { "copy": 44, "fan_out": 0, "straddling": 0, "filled_from_storage": 0, "default_zero": 0, "dropped_source": 0 },
"inflow_lag": { "copy": 44, "fan_out": 0, "straddling": 0, "filled_from_storage": 0, "default_zero": 0, "dropped_source": 0 },
"transit_bucket": { "copy": 6, "fan_out": 0, "straddling": 0, "filled_from_storage": 0, "default_zero": 0, "dropped_source": 0 },
"anticipated": { "copy": 3, "fan_out": 0, "straddling": 0, "filled_from_storage": 0, "default_zero": 0, "dropped_source": 1 },
"anticipated_coverage": { "source_interval_count": 4 },
"other_identity": { "copy": 0, "fan_out": 0, "straddling": 0, "filled_from_storage": 0, "default_zero": 0, "dropped_source": 0 },
"dropped_source_slots": [
{ "family": "anticipated", "entity_id": 17, "subindex": 0, "interval": ["2028-01-01", "2028-02-01"], "reference_date": null }
],
"straddling_slots": [],
"filled_from_storage_slots": []
}
}

Here one anticipated-commitment slot the source priced (plant 17, delivering in January 2028) is not modelled by this study, so it is dropped and counted under anticipated.dropped_source; with strict: true that same drop would reject the load instead.

See Policy Management — Boundary Cuts for a full explanation of the coupling workflow, and Compatibility requirements for the date-selection and subset rejects.


The loader accepts the block and checks its keys and value types; no part of the run reads it, so its fields have no effect (Inert keys).

NameTypeRequiredDefaultUnitsDescription
upper_bound_evaluation.enabledboolean | nullNonull—Accepted; has no effect. Enabled flag.
upper_bound_evaluation.initial_iterationinteger | nullNonull—Accepted; has no effect. Initial iteration.
upper_bound_evaluation.interval_iterationsinteger | nullNonull—Accepted; has no effect. Interval, in iterations.
upper_bound_evaluation.lipschitz.modestring | nullNonull—Accepted; has no effect. Lipschitz mode; any string is accepted.
upper_bound_evaluation.lipschitz.fallback_valuenumber | nullNonull—Accepted; has no effect. Lipschitz fallback value.
upper_bound_evaluation.lipschitz.scale_factornumber | nullNonull—Accepted; has no effect. Lipschitz scale factor.

No config.json key sets the temporal resolution: each stage’s resolution comes from its dates and season_id in stages.json. Multi-Resolution Studies explains how stages of different lengths share noise, aggregate history and change lag resolution; Post-Study Boundary & Chained Studies couples two studies, and Block Formulation Variants gives weekly dispatch inside a monthly stage through chronological blocks.

  • Stages share a noise group when they have the same season_id and their start dates fall in the same calendar year. The opening tree copies a group’s openings only between adjacent stages of the group; an out_of_sample forward class gives every stage of the group the same draw, adjacent or not. A later stage of the group may have fewer openings than the group’s first stage, and then copies the first of them; one with more is refused (Noise-group opening count).
  • When stages move from monthly to quarterly, the lag rebuild takes each monthly stage’s month from its season’s month_start and averages the monthly values over calendar quarters (January-March, April-June, July-September, October-December), whatever months the quarterly seasons declare. The rebuild runs at the first stage whose season spans a calendar quarter right after a stage whose season spans a calendar month, by the spans the seasons declare: that stage reads the monthly lags, and the averaged quarterly lags are first read by the stage after it.
  • Under a custom season map whose seasons overlap (monthly and quarterly seasons covering the same months), an observation dated inside a stage of stages.json (a study stage, or a pre-study stage with a season_id) goes to that stage’s season, and one dated outside every such stage goes to the lowest-id season that covers its date; a season that never has the lowest id therefore receives observations only from inside the stages.json stages of that season.
  • A cut on the inflow-lag components reads the stage’s outgoing inflow lags (Multi-Resolution Studies §2.1). On a stage that does not close its lag period, such as a weekly stage inside a month, those are the incoming lags. On a stage that closes a period begun at an earlier stage or before the study, lag 1 is the period’s duration-weighted mean, the stage’s own inflow included, and every later lag ℓ is incoming lag ℓ − 1. On the stage that runs the monthly-to-quarterly rebuild, the outgoing lags are the averaged quarterly lags, but the cut maps lag 1 to the stage’s own inflow and every later lag ℓ to incoming lag ℓ − 1, as at a single-resolution stage, and the study setup logs one warning: stage <stage_id>: the inflow lags step from months to quarters here; cuts at this stage evaluate inflow lags as at a single-resolution stage.
  • With such stages and a PAR order of 1 or more, the cuts are exact only where the partial inflow of every open lag period is the same on every path, as when the only period split over stages begins before the study and closes at its first stage. Elsewhere the lower bound is not guaranteed to stay below the upper bound, even with inflow lags in the cut projection (stages[].state_variables), and no warning flags such a study.
  • Each sampled forward trajectory accumulates its own lag periods, so training results do not depend on --threads or on the MPI rank count.

Controls which outputs are written to the results directory.

FieldTypeDefaultDescription
statesbooleanfalseStore the trial state of each row the run adds, under every selection method, and write the stored states to the policy checkpoint (policy/states/<pool>.bin). Each pool that receives rows stores its own rows’ states: the first stage’s pool keeps every state, and the pool of each stage strictly between the first and the last keeps, under level1 with lookback_iterations, only the states inside the window. A level1 run stores and writes the states of the pools it selects whether or not this is set. Storing the states changes no result; the policy then marks its rows scored, which a later level1 run that loads it selects like its own rows.
stochasticbooleanfalseExport stochastic preprocessing artifacts to output/stochastic/.
fpha_deviation_pointsbooleanfalseExport the per-grid-point computed-FPHA fit-deviation table to output/hydro_models/fpha_deviation_points.parquet. Opt-in because it emits one row per (hydro, stage, V, Q) sample point at spillage = 0.

These keys are accepted when config.json loads — their names and value types are checked — and no part of a run reads them, so setting them changes nothing.

NameDefaultWhat a run does instead
policy.checkpointing.store_basisnullA checkpoint holds the LP bases of the run’s scenarios.
policy.checkpointing.compressnullCheckpoint files are written uncompressed.
training.solver.retry_max_attempts5A solve that does not reach optimality escalates through the solver’s built-in retry sequence, not this setting (Solver Safeguards).
training.solver.retry_time_budget_seconds30.0A solve that does not reach optimality escalates through the solver’s built-in retry sequence, not this setting (Solver Safeguards).
upper_bound_evaluation{}Nothing reads the block: every key in it, the lipschitz keys included, has no effect.

Each recipe is a config.json excerpt that merges into a case: a key in the excerpt replaces the same key in the case, an array included. The rules behind its keys live in the sections it links.

Train with an enumerated forward pass and stop when the exact gap closes. relative_tolerance is a percent: 0.01 stops at a 0.01% gap. The iteration_limit entry ends the run if the gap does not close first; a sampled simulation after it logs an advisory setup warning (simulation.selection). The gap rule is admitted only under enumerated selection with the same risk measure at every stage (the default expectation qualifies), and every stage declares a single opening (num_openings: 1 in stages.json), because enumerated selection requires it (training.selection).

{
"training": {
"selection": { "method": "enumerated" },
"stopping_rules": [
{ "type": "gap", "relative_tolerance": 0.01 },
{ "type": "iteration_limit", "limit": 50 }
]
}
}

Bound a run by wall-clock time. Under the default stopping_mode ("any"), training stops at the first rule that is satisfied, so pair time_limit with an iteration_limit above what the time allows: training never runs past the largest iteration_limit in the set.

{
"training": {
"stopping_rules": [
{ "type": "time_limit", "seconds": 600.0 },
{ "type": "iteration_limit", "limit": 1000 }
]
}
}

Train with in-sample noise and simulate with out-of-sample inflow. The simulation.scenario_source.seed (77) drives the simulation’s out-of-sample draws (Seed resolution). The simulation.scenario_source fields are listed under simulation.scenario_source.

{
"training": {
"selection": { "method": "sampled", "forward_passes": 50 },
"stopping_rules": [{ "type": "iteration_limit", "limit": 200 }],
"scenario_source": { "seed": 77 }
},
"simulation": {
"enabled": true,
"selection": { "method": "sampled", "num_scenarios": 2000 },
"scenario_source": {
"seed": 77,
"inflow": { "scheme": "out_of_sample" },
"load": { "scheme": "in_sample" },
"ncs": { "scheme": "in_sample" }
}
}
}

{
"$schema": "https://docs.modelossetoreletrico.org.br/schemas/config.schema.json",
"training": {
"tree_seed": 42,
"selection": { "method": "sampled", "forward_passes": 50 },
"stopping_rules": [
{ "type": "iteration_limit", "limit": 200 },
{ "type": "bound_stalling", "iterations": 20, "tolerance": 0.0001 }
],
"stopping_mode": "any",
"scenario_source": {
"seed": 99,
"inflow": { "scheme": "out_of_sample" },
"load": { "scheme": "in_sample" },
"ncs": { "scheme": "in_sample" }
},
"cut_selection": {
"row_activity_tolerance": 1e-6,
"max_active_per_stage": null,
"selection": {
"method": "level1",
"check_frequency": 5
}
}
},
"modeling": {
"inflow_non_negativity": {
"method": "truncation_with_penalty"
}
},
"simulation": {
"enabled": true,
"selection": { "method": "sampled", "num_scenarios": 2000 }
},
"policy": {
"path": "./policy",
"mode": "fresh"
},
"exports": {
"states": false,
"stochastic": false
}
}