lumix.analysis.scenario.LXScenarioAnalyzer

class lumix.analysis.scenario.LXScenarioAnalyzer(base_model, optimizer, include_baseline=True)

Scenario analysis for optimization models.

Allows running multiple what-if scenarios on a base model and comparing the results to understand how different assumptions affect outcomes.

Examples

Create analyzer and add scenarios:

analyzer = LXScenarioAnalyzer(base_model, optimizer)

# Add scenarios
analyzer.add_scenario(
    LXScenario[Product]("high_capacity")
    .modify_constraint_rhs("capacity", multiply=1.5)
)

analyzer.add_scenario(
    LXScenario[Product]("low_capacity")
    .modify_constraint_rhs("capacity", multiply=0.8)
)

# Run all scenarios
results = analyzer.run_all_scenarios()

# Compare results
print(analyzer.compare_scenarios())

# Get specific result
high_cap_solution = analyzer.get_result("high_capacity")

Parameters:

• base_model (LXModel[TModel])

• optimizer (LXOptimizer[TModel])

• include_baseline (bool)

__init__(base_model, optimizer, include_baseline=True)

Initialize scenario analyzer.

Parameters:

• base_model (LXModel[TypeVar(TModel)]) – Base optimization model

• optimizer (LXOptimizer[TypeVar(TModel)]) – Optimizer to use for solving scenarios

• include_baseline (bool) – Whether to include baseline (unmodified) scenario

Methods

__init__(base_model, optimizer[, ...])	Initialize scenario analyzer.
add_scenario(scenario)	Add scenario to analyze.
add_scenarios(*scenarios)	Add multiple scenarios.
compare_scenarios([scenario_names, ...])	Compare scenario results.
get_best_scenario([maximize])	Get name of best scenario by objective value.
get_result(scenario_name)	Get result for specific scenario.
run_all_scenarios([include_baseline])	Run all scenarios.
run_scenario(scenario_name)	Run single scenario.
sensitivity_to_parameter(parameter_name, values)	Analyze sensitivity to a single parameter across multiple values.
visualize()	Create interactive visualization for scenario comparison.

__init__(base_model, optimizer, include_baseline=True)

Initialize scenario analyzer.

Parameters:

• base_model (LXModel[TypeVar(TModel)]) – Base optimization model

• optimizer (LXOptimizer[TypeVar(TModel)]) – Optimizer to use for solving scenarios

• include_baseline (bool) – Whether to include baseline (unmodified) scenario

add_scenario(scenario)

Add scenario to analyze.

Parameters:

scenario (LXScenario[TypeVar(TModel)]) – Scenario to add

Return type:

Self

Returns:

Self for chaining

add_scenarios(*scenarios)

Add multiple scenarios.

Parameters:

*scenarios (LXScenario[TypeVar(TModel)]) – Scenarios to add

Return type:

Self

Returns:

Self for chaining

run_scenario(scenario_name)

Run single scenario.

Parameters:

scenario_name (str) – Name of scenario to run

Return type:

LXSolution[TypeVar(TModel)]

Returns:

Solution for the scenario

Raises:

KeyError – If scenario not found

run_all_scenarios(include_baseline=None)

Run all scenarios.

Parameters:

include_baseline (Optional[bool]) – Override include_baseline setting

Return type:

Dict[str, LXSolution[TypeVar(TModel)]]

Returns:

Dictionary mapping scenario names to solutions

get_result(scenario_name)

Get result for specific scenario.

Parameters:

scenario_name (str) – Name of scenario

Return type:

Optional[LXSolution[TypeVar(TModel)]]

Returns:

Solution if available, None otherwise

compare_scenarios(scenario_names=None, include_baseline=True, sort_by_objective=True)

Compare scenario results.

Parameters:

• scenario_names (Optional[List[str]]) – Scenarios to compare (None = all)

• include_baseline (bool) – Include baseline in comparison

• sort_by_objective (bool) – Sort results by objective value

Return type:

str

Returns:

Formatted comparison report

get_best_scenario(maximize=True)

Get name of best scenario by objective value.

Parameters:

maximize (bool) – True if objective is maximization, False for minimization

Return type:

Optional[str]

Returns:

Name of best scenario, or None if no results

sensitivity_to_parameter(parameter_name, values, modification_type='rhs_multiply', target_type='constraint')

Analyze sensitivity to a single parameter across multiple values.

Parameters:

• parameter_name (str) – Name of parameter to vary

• values (List[float]) – List of values to test

• modification_type (str) – Type of modification

• target_type (str) – Type of target (“constraint” or “variable”)

Return type:

Dict[float, LXSolution[TypeVar(TModel)]]

Returns:

Dictionary mapping parameter values to solutions

Examples

Analyze sensitivity to capacity multiplier:

results = analyzer.sensitivity_to_parameter(
    "capacity",
    values=[0.8, 0.9, 1.0, 1.1, 1.2, 1.3],
    modification_type="rhs_multiply"
)

for multiplier, solution in results.items():
    print(f"Capacity × {multiplier}: ${solution.objective_value:,.2f}")

visualize()

Create interactive visualization for scenario comparison.

Requires the visualization extra: pip install lumix-opt[viz]

Return type:

LXScenarioCompare[TypeVar(TModel)]

Returns:

LXScenarioCompare instance

Examples

Basic usage:

analyzer = LXScenarioAnalyzer(model, optimizer)
analyzer.add_scenario(scenario1)
analyzer.add_scenario(scenario2)
analyzer.run_all_scenarios()
analyzer.visualize().show()

Comparison chart:

analyzer.visualize().plot_comparison().show()

Export to HTML:

analyzer.visualize().to_html("scenarios.html")