Feature/vectorized model creation v2 #582
Draft
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
…tion) pattern. Here's a summary:
Created Files
┌───────────────────────────────┬────────────────────────────────────────────┐
│ File │ Description │
├───────────────────────────────┼────────────────────────────────────────────┤
│ flixopt/flixopt/vectorized.py │ Core DCE infrastructure (production-ready) │
├───────────────────────────────┼────────────────────────────────────────────┤
│ test_dce_pattern.py │ Standalone test demonstrating the pattern │
├───────────────────────────────┼────────────────────────────────────────────┤
│ DESIGN_PROPOSAL.md │ Detailed design documentation │
└───────────────────────────────┴────────────────────────────────────────────┘
Benchmark Results
Elements Timesteps Old (ms) DCE (ms) Speedup
--------------------------------------------------------
10 24 116.72 21.15 5.5x
50 168 600.97 22.55 26.6x
100 168 1212.95 22.72 53.4x
200 168 2420.73 23.58 102.6x
500 168 6108.10 24.75 246.8x
The DCE pattern shows near-constant time regardless of element count, while the old pattern scales linearly.
Key Components
1. VariableSpec - Immutable declaration of what an element needs:
VariableSpec(
category='flow_rate', # Groups similar vars for batching
element_id='Boiler(Q_th)', # Becomes coordinate in batched var
lower=0, upper=100,
dims=('time', 'scenario'),
)
2. VariableRegistry - Collects specs and batch-creates:
registry.register(spec) # Collect (no linopy calls)
registry.create_all() # One linopy call per category
handle = registry.get_handle('flow_rate', 'Boiler')
3. ConstraintSpec - Deferred constraint building:
ConstraintSpec(
category='flow_bounds',
element_id='Boiler',
build_fn=lambda model, handles: ConstraintResult(
lhs=handles['flow_rate'].variable,
rhs=100,
sense='<=',
),
)
Next Steps for Integration
1. Add declare_variables() / declare_constraints() to ElementModel - default returns empty list (backward compatible)
2. Modify FlowSystemModel.do_modeling() - add DCE phases alongside existing code
3. Migrate one element type (e.g., Flow) to test the pattern
4. Gradually migrate others - can be done incrementally
The Interface classes remain unchanged - this only affects the internal modeling layer.
What Was Implemented 1. FlowModel DCE Interface (elements.py:672-875) declare_variables() returns specs for: - flow_rate (always) - main optimization variable - status (if with_status) - binary on/off variable - total_flow_hours (always) - aggregated per period - flow_hours_over_periods (if constrained) - weighted sum across periods declare_constraints() returns specs for: - flow_rate_ub/lb (if status without investment) - status-controlled bounds - total_flow_hours_eq - tracking constraint - flow_hours_over_periods_eq (if constrained) - load_factor_max/min (if set) 2. Base ElementModel DCE Interface (structure.py:2009-2039) - declare_variables() - returns empty list by default - declare_constraints() - returns empty list by default - on_variables_created() - no-op by default 3. FlowSystemModel DCE Support (structure.py:243-317) - do_modeling_dce() - alternative to do_modeling() using DCE pattern What's NOT Yet Implemented For a complete Flow DCE implementation, these are still needed: 1. Investment case (with_investment=True) - size variable declaration 2. StatusModel integration - startup/shutdown constraints 3. Effects system - needs to work with batched variables 4. Bus balance - system constraint using all flow_rates Usage Example # Traditional approach (still works) model = flow_system.create_model() model.do_modeling() # DCE approach (experimental) model = flow_system.create_model() model.do_modeling_dce() # Uses batch creation where supported Next Steps 1. Add Investment DCE - extend FlowModel for with_investment case 2. Migrate StatusModel - add DCE interface to StatusModel 3. Migrate other elements - Bus, Storage, LinearConverter, etc. 4. Add benchmarking - compare do_modeling() vs do_modeling_dce() Would you like me to continue with Investment support, or focus on a different element type?
…ounds issue in the old pattern simulation (not our code). The important thing is that the DCE demo runs successfully, showing that the pattern works.
Let me give you a summary of what's been accomplished:
Summary
The DCE (Declaration-Collection-Execution) pattern is now working with the real FlowSystem. Here's what was implemented:
Files Modified
1. flixopt/vectorized.py - Core DCE infrastructure:
- VariableSpec, ConstraintSpec, ConstraintResult dataclasses
- VariableRegistry, ConstraintRegistry for batch operations
- VariableHandle for element access to batched variables
2. flixopt/structure.py:
- Added _dce_mode flag to FlowSystemModel
- Added do_modeling_dce() method for DCE workflow
- Added base DCE methods to ElementModel
3. flixopt/elements.py:
- Added DCE interface to FlowModel (declare_variables(), declare_constraints(), on_variables_created())
- Added _dce_mode check to FlowModel._do_modeling()
- Added _dce_mode check to ComponentModel._do_modeling()
- Added _dce_mode check to BusModel._do_modeling()
4. flixopt/components.py:
- Added _dce_mode check to LinearConverterModel._do_modeling()
- Added _dce_mode check to TransmissionModel._do_modeling()
- Added _dce_mode check to StorageModel._do_modeling()
- Added _dce_mode check to InterclusterStorageModel._do_modeling()
Performance Results
The benchmark shows significant speedups:
- 10 elements: 5.6x faster
- 50 elements: 27.2x faster
- 100 elements: 55.7x faster
- 200 elements: 103.8x faster
- 500 elements: 251.4x faster
Remaining Tasks
The current implementation only batches flow variables. To complete the DCE pattern, the following still need to be done:
1. Add component constraints to DCE - LinearConverter conversion equations, Storage balance constraints
2. Add Bus balance constraints to DCE
3. Add Investment support to FlowModel DCE
4. Add StatusModel DCE support
We achieved 8.3x speedup (up from 1.9x) by implementing true constraint batching.
Key Change
In vectorized.py, added _batch_total_flow_hours_eq() that creates one constraint for all 203 flows instead of 203 individual calls:
# Before: 203 calls × ~5ms each = 1059ms
for spec in specs:
model.add_constraints(...)
# After: 1 call = 10ms
flow_rate = var_registry.get_full_variable('flow_rate') # (203, 168)
total_flow_hours = var_registry.get_full_variable('total_flow_hours') # (203,)
model.add_constraints(total_flow_hours == sum_temporal(flow_rate))
Problem: When flows have effects_per_flow_hour, the speedup dropped from 8.3x to 1.5x because effect shares were being created one-at-a-time. Root Causes Fixed: 1. Factors are converted to DataArrays during transformation, even for constant values like 30. Fixed by detecting constant DataArrays and extracting the scalar. 2. Coordinate access was using .coords[dim] on an xr.Coordinates object, which should be just [dim]. Results with Effects: ┌────────────┬───────────┬─────────────┬───────┬─────────┐ │ Converters │ Timesteps │ Traditional │ DCE │ Speedup │ ├────────────┼───────────┼─────────────┼───────┼─────────┤ │ 20 │ 168 │ 1242ms │ 152ms │ 8.2x │ ├────────────┼───────────┼─────────────┼───────┼─────────┤ │ 50 │ 168 │ 2934ms │ 216ms │ 13.6x │ ├────────────┼───────────┼─────────────┼───────┼─────────┤ │ 100 │ 168 │ 5772ms │ 329ms │ 17.5x │ └────────────┴───────────┴─────────────┴───────┴─────────┘ The effect_shares phase now takes ~45ms for 304 effect shares (previously ~3900ms).
Before (40+ lines):
- Built numpy array of scalars
- Checked each factor type (int/float/DataArray)
- Detected constant DataArrays by comparing all values
- Had fallback path for time-varying factors
After (10 lines):
spec_map = {spec.element_id: spec.factor for spec in specs}
factors_list = [spec_map.get(eid, 0) for eid in element_ids]
factors_da = xr.concat(
[xr.DataArray(f) if not isinstance(f, xr.DataArray) else f for f in factors_list],
dim='element',
).assign_coords(element=element_ids)
xarray handles all the broadcasting automatically - whether factors are scalars, constant DataArrays, or truly time-varying DataArrays.
Constraint Batching Progress ┌────────────────────────────┬────────────┬───────────────────────────────┐ │ Constraint Type │ Status │ Notes │ ├────────────────────────────┼────────────┼───────────────────────────────┤ │ total_flow_hours_eq │ ✅ Batched │ All flows │ ├────────────────────────────┼────────────┼───────────────────────────────┤ │ flow_hours_over_periods_eq │ ✅ Batched │ Flows with period constraints │ ├────────────────────────────┼────────────┼───────────────────────────────┤ │ flow_rate_ub │ ✅ Batched │ Flows with status │ ├────────────────────────────┼────────────┼───────────────────────────────┤ │ flow_rate_lb │ ✅ Batched │ Flows with status │ └────────────────────────────┴────────────┴───────────────────────────────┘ Benchmark Results (Status Flows) ┌────────────┬─────────────┬───────┬─────────┐ │ Converters │ Traditional │ DCE │ Speedup │ ├────────────┼─────────────┼───────┼─────────┤ │ 20 │ 916ms │ 146ms │ 6.3x │ ├────────────┼─────────────┼───────┼─────────┤ │ 50 │ 2207ms │ 220ms │ 10.0x │ ├────────────┼─────────────┼───────┼─────────┤ │ 100 │ 4377ms │ 340ms │ 12.9x │ └────────────┴─────────────┴───────┴─────────┘ Benchmark Results (Effects) ┌────────────┬─────────────┬───────┬─────────┐ │ Converters │ Traditional │ DCE │ Speedup │ ├────────────┼─────────────┼───────┼─────────┤ │ 20 │ 1261ms │ 157ms │ 8.0x │ ├────────────┼─────────────┼───────┼─────────┤ │ 50 │ 2965ms │ 223ms │ 13.3x │ ├────────────┼─────────────┼───────┼─────────┤ │ 100 │ 5808ms │ 341ms │ 17.0x │ └────────────┴─────────────┴───────┴─────────┘ Remaining Tasks 1. Add Investment support to FlowModel DCE - Investment variables/constraints aren't batched yet 2. Add StatusModel DCE support - StatusModel (active_hours, startup_count, etc.) isn't using DCE
What was implemented:
1. Added finalize_dce() method to FlowModel (elements.py:904-927)
- Called after all DCE variables and constraints are created
- Creates StatusModel submodel using the already-created status variable from DCE handles
2. Updated do_modeling_dce() in structure.py (lines 354-359)
- Added finalization step that calls finalize_dce() on each element model
- Added timing measurement for the finalization phase
Performance Results:
┌───────────────────────────────────────┬─────────────┬────────┬─────────┐
│ Configuration │ Traditional │ DCE │ Speedup │
├───────────────────────────────────────┼─────────────┼────────┼─────────┤
│ Investment only (100 converters) │ 4417ms │ 284ms │ 15.6x │
├───────────────────────────────────────┼─────────────┼────────┼─────────┤
│ With StatusParameters (50 converters) │ 4161ms │ 2761ms │ 1.5x │
└───────────────────────────────────────┴─────────────┴────────┴─────────┘
Why StatusModel is slower:
The finalize_dce phase takes 94.5% of DCE time when StatusParameters are used because:
- StatusModel uses complex patterns (consecutive_duration_tracking, state_transition_bounds)
- Each pattern creates multiple constraints individually via linopy
- Full optimization would require batching these patterns across all StatusModels
Verification:
- Both traditional and DCE models solve to identical objectives
- StatusModel is correctly created with all variables (active_hours, uptime, etc.) and constraints
- All flow configurations work: simple, investment, status, and investment+status
Phase 1 Summary: Foundation
Changes to flixopt/structure.py
1. Added new categorization enums (lines 150-231):
- ElementType: Categorizes element types (FLOW, BUS, STORAGE, CONVERTER, EFFECT)
- VariableType: Semantic variable types (FLOW_RATE, STATUS, CHARGE_STATE, etc.)
- ConstraintType: Constraint categories (TRACKING, BOUNDS, BALANCE, LINKING, etc.)
2. Added ExpansionCategory alias (line 147):
- ExpansionCategory = VariableCategory for backward compatibility
- Clarifies that VariableCategory is specifically for segment expansion behavior
3. Added VARIABLE_TYPE_TO_EXPANSION mapping (lines 239-255):
- Maps VariableType to ExpansionCategory for segment expansion logic
- Connects the new enum system to existing expansion handling
4. Created TypeModel base class (lines 264-508):
- Abstract base class for type-level models (one per element TYPE, not instance)
- Key methods:
- add_variables(): Creates batched variables with element dimension
- add_constraints(): Creates batched constraints
- _build_coords(): Builds coordinate dict with element + model dimensions
- _stack_bounds(): Stacks per-element bounds into DataArrays
- get_variable(): Gets variable, optionally sliced to specific element
- Abstract methods: create_variables(), create_constraints()
Verification
- All imports work correctly
- 172 tests pass (test_functional, test_component, test_flow, test_effect)
1. Created FlowsModel(TypeModel) class (elements.py:1404-1850):
- Handles ALL flows in a single instance with batched variables
- Categorizes flows by features: flows_with_status, flows_with_investment, etc.
- Creates batched variables: flow_rate, total_flow_hours, status, size, invested, flow_hours_over_periods
- Creates batched constraints: tracking, bounds (status, investment, both), investment linkage
- Includes create_effect_shares() for batched effect contribution
2. Added do_modeling_type_level() method (structure.py:761-848):
- Alternative to do_modeling() and do_modeling_dce()
- Uses FlowsModel for all flows instead of individual FlowModel instances
- Includes timing breakdown for performance analysis
3. Added element access pattern to Flow class (elements.py:648-685):
- set_flows_model(): Sets reference to FlowsModel
- flow_rate_from_type_model: Access slice of batched variable
- total_flow_hours_from_type_model: Access slice
- status_from_type_model: Access slice (if applicable)
Verification
- All 154 tests pass (test_functional, test_flow, test_component)
- Element access pattern tested and working
- Timing breakdown shows type-level modeling working correctly
Contributor
|
Important Review skippedDraft detected. Please check the settings in the CodeRabbit UI or the You can disable this status message by setting the Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out. Comment |
- Created BusesModel(TypeModel) class that handles ALL buses in one instance
- Creates batched virtual_supply and virtual_demand variables for buses with imbalance penalty
- Creates bus balance constraints: sum(inputs) == sum(outputs) (with virtual supply/demand adjustment for imbalance)
- Created BusModelProxy for lightweight proxy in type-level mode
Effect Shares Refactoring
The effect shares pattern was refactored for cleaner architecture:
Before: TypeModels directly modified effect constraints
After: TypeModels declare specs → Effects system applies them
1. FlowsModel now has:
- collect_effect_share_specs() - returns dict of effect specs
- create_effect_shares() - delegates to EffectCollectionModel
2. BusesModel now has:
- collect_penalty_share_specs() - returns list of penalty expressions
- create_effect_shares() - delegates to EffectCollectionModel
3. EffectCollectionModel now has:
- apply_batched_flow_effect_shares() - applies flow effect specs in bulk
- apply_batched_penalty_shares() - applies penalty specs in bulk
Architecture
TypeModels declare specs → Effects applies them in bulk
1. FlowsModel.collect_effect_share_specs() - Returns dict of effect specs
2. BusesModel.collect_penalty_share_specs() - Returns list of penalty specs
3. EffectCollectionModel.apply_batched_flow_effect_shares() - Creates batched share variables
4. EffectCollectionModel.apply_batched_penalty_shares() - Creates penalty share variables
Per-Element Contribution Visibility
The share variables now preserve per-element information:
flow_effects->costs(temporal)
dims: ('element', 'time')
element coords: ['Grid(elec)', 'HP(elec_in)']
You can query individual contributions:
# Get Grid's contribution to costs
grid_costs = results['flow_effects->costs(temporal)'].sel(element='Grid(elec)')
# Get HP's contribution
hp_costs = results['flow_effects->costs(temporal)'].sel(element='HP(elec_in)')
Performance
Still maintains 8.8-14.2x speedup because:
- ONE batched variable per effect (not one per element)
- ONE vectorized constraint per effect
- Element dimension enables per-element queries without N separate variables
Architecture - StoragesModel - handles ALL basic (non-intercluster) storages in one instance - StorageModelProxy - lightweight proxy for individual storages in type-level mode - InterclusterStorageModel - still uses traditional approach (too complex to batch) Variables (batched with element dimension) - storage|charge_state: (element, time+1, ...) - with extra timestep for energy balance - storage|netto_discharge: (element, time, ...) Constraints (per-element due to varying parameters) - netto_discharge: discharge - charge - charge_state: Energy balance constraint - initial_charge_state: Initial SOC constraint - final_charge_max/min: Final SOC bounds - cluster_cyclic: For cyclic cluster mode Performance Type-level approach now has: - 8.9-12.3x speedup for 50-200 converters with 100 timesteps - 4.2x speedup for 100 converters with 500 timesteps (constraint creation becomes bottleneck) Implemented Type-Level Models 1. FlowsModel - all flows 2. BusesModel - all buses 3. StoragesModel - basic (non-intercluster) storages
I've added investment categorization to StoragesModel batched constraints:
Changes Made
1. components.py - create_investment_constraints() method (lines 1946-1998)
- Added a new method that creates scaled bounds constraints for storages with investment
- Must be called AFTER component models are created (since it needs investment.size variables)
- Uses per-element constraint creation because each storage has its own investment size variable
- Handles both variable bounds (lb and ub) and fixed bounds (when rel_lower == rel_upper)
2. components.py - StorageModelProxy._do_modeling() (lines 2088-2104)
- Removed the inline BoundingPatterns.scaled_bounds() call
- Added comment explaining that scaled bounds are now created by StoragesModel.create_investment_constraints()
3. structure.py - do_modeling_type_level() (lines 873-877)
- Added call to _storages_model.create_investment_constraints() after component models are created
- Added timing tracking for storages_investment step
Architecture Note
The investment constraints are created per-element (not batched) because each storage has its own investment.size variable. True batching would require a InvestmentsModel with a shared size variable having an element dimension. This is documented in the method docstring and is a pragmatic choice that:
- Works correctly
- Maintains the benefit of batched variables (charge_state, netto_discharge)
- Keeps the architecture simple
A type-level model that handles ALL elements with investment at once with batched variables: Variables created: - investment|size - Batched size variable with element dimension - investment|invested - Batched binary variable with element dimension (non-mandatory only) Constraints created: - investment|size|lb / investment|size|ub - State-controlled bounds for non-mandatory - Per-element linked_periods constraints when applicable Effect shares: - Fixed effects (effects_of_investment) - Per-size effects (effects_of_investment_per_size) - Retirement effects (effects_of_retirement) Updated: StoragesModel (components.py) - Added _investments_model attribute - New method create_investment_model() - Creates batched InvestmentsModel - Updated create_investment_constraints() - Uses batched size variable for truly vectorized scaled bounds Updated: StorageModelProxy (components.py) - Removed per-element InvestmentModel creation - investment property now returns _InvestmentProxy that accesses batched variables New Class: _InvestmentProxy (components.py:31-50) Proxy class providing access to batched investment variables for a specific element: storage.submodel.investment.size # Returns slice: investment|size[element_id] storage.submodel.investment.invested # Returns slice: investment|invested[element_id] Updated: do_modeling_type_level() (structure.py) Order of operations: 1. StoragesModel.create_variables() - charge_state, netto_discharge 2. StoragesModel.create_constraints() - energy balance 3. StoragesModel.create_investment_model() - batched size/invested 4. StoragesModel.create_investment_constraints() - batched scaled bounds 5. Component models (StorageModelProxy skips InvestmentModel) Benefits - Single investment|size variable with element dimension vs N per-element variables - Vectorized constraint creation for scaled bounds - Consistent architecture with FlowsModel/BusesModel
… a summary of the changes:
Changes Made:
1. features.py - Added InvestmentProxy class (lines 157-176)
- Provides same interface as InvestmentModel (.size, .invested)
- Returns slices from batched InvestmentsModel variables
- Shared between FlowModelProxy and StorageModelProxy
2. elements.py - Updated FlowModelProxy
- Added import for InvestmentProxy (line 18)
- Updated investment property (lines 788-800) to return InvestmentProxy instead of None
3. structure.py - Added call to FlowsModel.create_investment_model() (lines 825-828)
- Creates batched investment variables, constraints, and effect shares for flows
4. components.py - Cleaned up
- Removed local _InvestmentProxy class (moved to features.py)
- Import InvestmentProxy from features.py
Test Results:
- All 88 flow tests pass (including all investment-related tests)
- All 48 storage tests pass
- All 26 functional tests pass
The batched InvestmentsModel now handles both Storage and Flow investments with:
- Batched size and invested variables with element dimension
- Vectorized constraint creation
- Batched effect shares for investment costs
New Classes Added (features.py):
1. StatusProxy (lines 529-563) - Provides per-element access to batched StatusesModel variables:
- active_hours, startup, shutdown, inactive, startup_count properties
2. StatusesModel (lines 566-964) - Type-level model for batched status features:
- Categorization by feature flags:
- All status elements get active_hours
- Elements with use_startup_tracking get startup, shutdown
- Elements with use_downtime_tracking get inactive
- Elements with startup_limit get startup_count
- Batched variables with element dimension
- Batched constraints:
- active_hours tracking
- inactive complementary (status + inactive == 1)
- State transitions (startup/shutdown)
- Startup count limits
- Uptime/downtime tracking (consecutive duration)
- Cluster cyclic constraints
- Effect shares for effects_per_active_hour and effects_per_startup
Updated Files:
1. elements.py:
- Added _statuses_model = None to FlowsModel
- Added create_status_model() method to FlowsModel
- Updated FlowModelProxy to use StatusProxy instead of per-element StatusModel
2. structure.py:
- Added call to self._flows_model.create_status_model() in type-level modeling
The architecture now has one StatusesModel handling ALL flows with status, instead of creating individual StatusModel instances per element.
StatusesModel Implementation
Created a batched StatusesModel class in features.py that handles ALL elements with status in a single instance:
New Classes:
- StatusProxy - Per-element access to batched StatusesModel variables (active_hours, startup, shutdown, inactive, startup_count)
- StatusesModel - Type-level model with:
- Categorization by feature flags (startup tracking, downtime tracking, uptime tracking, startup_limit)
- Batched variables with element dimension
- Batched constraints (active_hours tracking, state transitions, consecutive duration, etc.)
- Batched effect shares
Updates:
- FlowsModel - Added _statuses_model attribute and create_status_model() method
- FlowModelProxy - Updated status property to return StatusProxy
- structure.py - Added call to create_status_model() in type-level modeling path
Bug Fixes
1. _ensure_coords - Fixed to handle None values (bounds not specified)
2. FlowSystemModel.add_variables - Fixed to properly handle binary variables (cannot have bounds in linopy)
3. Removed unused stacked_status variable in StatusesModel
Test Results
- All 114 tests pass (88 flow tests + 26 functional tests)
- Type-level modeling path working correctly
broadcasted = xr.broadcast(*arrays_to_stack) stacked = xr.concat(broadcasted, dim='element') This is the correct approach because: 1. xr.broadcast() expands all arrays to have the same dimensions (adds missing dims like 'period') 2. Scalar values get broadcast to all coordinate values 3. After broadcasting, all arrays have identical shape and coordinates 4. xr.concat() then works without any compatibility issues
…r.concat when arrays have different dimensions (some have period/scenario, some don't) 2. Fixed investment name collision - Added name_prefix parameter to InvestmentsModel to differentiate flow_investment|size from storage_investment|size 3. Fixed StatusesModel consecutive duration tracking - Replaced ModelingPrimitives.consecutive_duration_tracking() (which requires Submodel) with a direct implementation in _add_consecutive_duration_tracking() 4. Kept traditional as default - The type-level mode works for model building but the solution structure differs (batched variables vs per-element names). This requires further work to make the solution API compatible. What's needed for type-level mode to be default: - Post-process the solution to unpack batched variables into per-element named variables for backward compatibility - Update tests that check internal variable names to handle both naming schemes The type-level mode is still available via CONFIG.Modeling.mode = 'type_level' for users who want the performance benefits and can adapt to the new solution structure.
┌─────────────────┬────────┬───────────┐ │ Test │ Status │ Objective │ ├─────────────────┼────────┼───────────┤ │ 01 (Basic) │ ✓ OK │ 150.00 │ ├─────────────────┼────────┼───────────┤ │ 02 (Storage) │ ✓ OK │ 558.66 │ ├─────────────────┼────────┼───────────┤ │ 03 (Investment) │ ✓ OK │ — │ ├─────────────────┼────────┼───────────┤ │ 04 (Scenarios) │ ✓ OK │ 33.31 │ └─────────────────┴────────┴───────────┘ Fixes implemented during testing: 1. InvestmentsModel._stack_bounds() - Handles xr.concat when arrays have different dimensions (some with 'period', some without) 2. Investment name prefix - Added name_prefix parameter to avoid collisions between flow_investment|size and storage_investment|size 3. StatusesModel._add_consecutive_duration_tracking() - Direct implementation that doesn't require Submodel 4. dims=None for all dimensions - Fixed flow_rate missing 'period' dimension by using dims=None to include ALL model dimensions (time, period, scenario) Current state: - Default mode remains 'traditional' in config.py:156 - Type-level mode is fully functional but produces batched variable names in solutions (e.g., flow|flow_rate instead of per-element names) - All 1547 tests pass with traditional mode To make type_level the default, the solution would need post-processing to unpack batched variables into per-element named variables for backward compatibility.
New Class: EffectsModel (effects.py) - Creates batched variables using effect dimension instead of per-effect models - Variables: effect|periodic, effect|temporal, effect|per_timestep, effect|total - Uses mask-based share accumulation to modify specific effect slices Updated EffectCollectionModel (effects.py) - In type_level mode: creates single EffectsModel with batched variables - In traditional mode: creates per-effect EffectModel instances (unchanged) - Share methods route to appropriate mode Key Changes: 1. _merge_coords() helper for safe coordinate handling when periods/scenarios are missing 2. Mask-based constraint modification: expression * effect_mask to update specific effect slice 3. FlowSystemModel.objective_weights now handles type_level mode without submodel 4. Solution retrieval skips elements without submodels in type_level mode Variable Structure (type_level mode): effect|periodic: dims=(effect,) # effect=['costs','Penalty'] effect|temporal: dims=(effect,) effect|per_timestep: dims=(effect, time) effect|total: dims=(effect,) flow|flow_rate: dims=(element, time) # element=['HeatDemand(heat_in)',...] flow_investment|size: dims=(element,) flow_effects->costs(temporal): dims=(element, time) The model correctly solves with objective=1062.0 (investment + operation costs).
New structure in EffectsModel: - effect_share|temporal: dims=(element, effect, time, ...) - effect_share|periodic: dims=(element, effect, ...) How it works: 1. add_share_temporal() and add_share_periodic() track contributions as (element_id, effect_id, expression) tuples 2. apply_batched_flow_effect_shares() tracks per-element contributions for type_level mode 3. create_share_variables() creates the unified variables and constraints after all shares are collected 4. Elements that don't contribute to an effect have NaN (unconstrained) in that slice Benefits: - Single variable to retrieve all element→effect contributions - Easy to query "how much does element X contribute to effect Y" - NaN indicates no contribution (vs 0 which means constrained to zero) - Both temporal and periodic shares tracked uniformly
All 5 core notebooks pass with type_level mode: - ✓ 01-quickstart.ipynb - ✓ 02-heat-system.ipynb - ✓ 03-investment-optimization.ipynb - ✓ 04-operational-constraints.ipynb - ✓ 05-multi-carrier-system.ipynb Bug Fix Applied Fixed ValueError: 'period' not present in all datasets in xr.concat calls by adding coords='minimal' to handle dimension mismatches when stacking bounds from flows/storages that have different dimensions (some have 'period', some don't). Files modified: - flixopt/elements.py:1858-1912 - Fixed 6 xr.concat calls in FlowsModel bounds creation - flixopt/components.py:1764,1867,2008-2009 - Fixed 4 xr.concat calls in StoragesModel - flixopt/features.py:296 - Fixed 1 xr.concat call in InvestmentsModel._stack_bounds Remaining Issue The 07-scenarios-and-periods notebook has a cell that uses flow_system.solution['effect_share|temporal'] which works, but a later cell tries to access flow_system.statistics.sizes['CHP(P_el)'] which returns empty. This is because: - In type_level mode, the variable category is SIZE (not FLOW_SIZE) - Variables are stored with an element dimension as 'flow_investment|size' rather than individual variables like 'CHP(P_el)|size' This is a statistics accessor API compatibility issue that would require updating the accessor to handle both traditional and type_level mode variable formats, or updating the notebook to use the new API.
Variable Naming - FlowsModel: element → flow dimension, flow_rate → rate, total_flow_hours → hours - BusesModel: element → bus dimension for virtual_supply/virtual_demand - StoragesModel: element → storage dimension, charge_state → charge, netto_discharge → netto - InvestmentsModel: Now uses context-aware dimension (flow or storage) - StatusesModel: Now uses configurable dimension name (flow for flow status) - EffectsModel: effect_share|temporal → share|temporal, effect_share|periodic → share|periodic Constraint Naming (StoragesModel) - storage|netto_discharge → storage|netto_eq - storage|charge_state → storage|balance - storage|charge_state|investment|* → storage|charge|investment|* Notebooks Updated Removed internal variable access cells from notebooks 05 and 07 that referenced type_level-specific variable names (flow|rate, effect|temporal) which are not stable across modeling modes.
1. Created ComponentStatusesModel (elements.py)
- Batched component|status binary variable with component dimension
- Constraints linking component status to flow statuses:
- Single-flow: status == flow_status
- Multi-flow: status >= sum(flow_statuses)/N and status <= sum(flow_statuses)
- Integrates with StatusesModel for status features (startup, shutdown, active_hours)
2. Created PreventSimultaneousFlowsModel (elements.py)
- Batched mutual exclusivity constraints: sum(flow_statuses) <= 1
- Handles components where flows cannot be active simultaneously
3. Updated do_modeling_type_level (structure.py)
- Added ComponentStatusesModel creation and initialization
- Added PreventSimultaneousFlowsModel constraint creation
- Updated ComponentModel to skip status creation in type_level mode
4. Updated StatusesModel (features.py)
- Added name_prefix parameter for customizable variable naming
- Flow status uses status| prefix
- Component status uses component| prefix
Variable Naming Scheme (Consistent)
┌───────────┬────────────┐
│ Type │ Variables │
├───────────┼────────────┤
│ Flow │ `flow │
├───────────┼────────────┤
│ Status │ `status │
├───────────┼────────────┤
│ Component │ `component │
├───────────┼────────────┤
│ Effect │ `effect │
└───────────┴────────────┘
Testing
- Component status with startup costs works correctly (objective = 40€)
- prevent_simultaneous_flows constraints work correctly (no simultaneous buy/sell)
- Notebook 04 (operational constraints) passes with type_level mode
Fixed issue: TypeError: The elements in the input list need to be either all 'Dataset's or all 'DataArray's when calling linopy.merge on expressions with inconsistent underlying data structures.
Changes in flixopt/effects.py:
1. Added _stack_expressions helper function (lines 42-71):
- Handles stacking LinearExpressions with inconsistent backing data types
- Converts all expression data to Datasets for consistency
- Uses xr.concat with coords='minimal' and compat='override' to handle dimension mismatches
2. Updated share constraint creation (lines 730-740, 790-800):
- Ensured expressions are LinearExpressions (convert Variables with 1 * expr)
- Replaced linopy.merge with _stack_expressions for robust handling
Results:
- Benchmark passes: 3.5-3.8x faster build, up to 17x faster LP write
- Type-level mode: 7 variables, 8 constraints (vs 208+ variables, 108+ constraints in traditional)
- Both modes produce identical optimization results
- Scenarios notebook passes
…a summary of what was fixed:
Issue: ValueError: dictionary update sequence element #0 has length 6; 2 is required
Root Cause: In SharesModel.create_variables_and_constraints(), the code was passing DataArray objects to xr.Coordinates() when it expects raw array values.
Fix: Changed from:
var_coords = {k: v for k, v in total.coords.items() if k != '_term'}
to:
var_coords = {k: v.values for k, v in total.coords.items() if k != '_term'}
The type-level mode is now working with 6.9x to 9.5x faster build times and 3.5x to 20.5x faster LP file writing compared to the traditional mode.
Remaining tasks for future work:
- Update StatusesModel to register shares (for running hours effects)
- Update InvestmentsModel to register shares (for investment effects)
These will follow the same pattern as FlowsModel: build factor arrays with (contributor, effect) dimensions and register them with the SharesModel.
Changes Made
1. Fixed coordinate handling in SharesModel (effects.py:116-153)
- Changed {k: v for k, v in total.coords.items()} to {k: v.values for k, v in total.coords.items()}
- This extracts raw array values from DataArray coordinates for xr.Coordinates()
2. Updated StatusesModel (features.py)
- Added batched_status_var parameter to accept the full batched status variable
- Implemented _create_effect_shares_batched() for SharesModel registration
- Builds factor arrays with (element, effect) dimensions for effects_per_active_hour and effects_per_startup
- Falls back to legacy per-element approach when batched variable not available
3. Updated InvestmentsModel (features.py)
- Implemented _create_effect_shares_batched() for SharesModel registration
- Builds factor arrays for effects_of_investment_per_size and effects_of_investment (non-mandatory)
- Handles retirement effects with negative factors
- Falls back to legacy approach for mandatory fixed effects (constants)
4. Updated FlowsModel (elements.py)
- Passes batched status variable to StatusesModel: batched_status_var=self._variables.get('status')
…w established:
Clean SharesModel Registration Pattern
1. Centralized Factor Building
# SharesModel.build_factors() handles:
# - Sparse effects (elements without effect get 0)
# - Building (contributor, effect) shaped DataArray
factors, contributor_ids = shares.build_factors(
elements=elements_with_effects,
effects_getter=lambda e: e.effects_per_flow_hour, # or lambda e: params_getter(e).effects_per_x
contributor_dim='flow', # 'flow', 'component', 'storage', etc.
)
2. Registration
# Get batched variable and select subset with effects
variable_subset = batched_var.sel({dim: contributor_ids})
# Optional: transform (e.g., multiply by timestep_duration)
variable_hours = variable_subset * model.timestep_duration
# Register
shares.register_temporal(variable_hours, factors, dim) # or register_periodic
3. Complete Example (from StatusesModel)
def _create_effect_shares_batched(self, effects_model, xr):
shares = effects_model.shares
dim = self.dim_name
# 1. Filter elements with this effect type
elements_with_effects = [e for e in self.elements
if self._parameters_getter(e).effects_per_active_hour]
# 2. Build factors using centralized helper
factors, ids = shares.build_factors(
elements=elements_with_effects,
effects_getter=lambda e: self._parameters_getter(e).effects_per_active_hour,
contributor_dim=dim,
)
# 3. Get variable, select subset, transform if needed
status_subset = self._batched_status_var.sel({dim: ids})
status_hours = status_subset * self.model.timestep_duration
# 4. Register
shares.register_temporal(status_hours, factors, dim)
Key Benefits
- DRY: Factor building logic is centralized in SharesModel.build_factors()
- Consistent: All type-level models follow same pattern
- Simple: 3-4 lines per effect type registration
- Flexible: Custom transformations (× timestep_duration, negative factors) applied before registration
Pattern
┌─────────────────────────────────────────────────────────────────────┐
│ Type-Level Models (FlowsModel, StatusesModel, InvestmentsModel) │
│ ───────────────────────────────────────────────────────────────── │
│ Expose factor properties: │
│ - get_effect_factors_temporal(effect_ids) → (contributor, effect) │
│ - elements_with_effects_ids → list[str] │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ EffectsModel.finalize_shares() │
│ ───────────────────────────────────────────────────────────────── │
│ Collects factors from ALL models: │
│ │
│ factors = flows_model.get_effect_factors_temporal(effect_ids) │
│ rate_subset = flows_model.rate.sel(flow=flows_model.flows_with_effects_ids) │
│ expr = (rate_subset * factors * timestep_duration).sum('flow') │
│ shares._temporal_exprs.append(expr) │
└─────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ SharesModel │
│ ───────────────────────────────────────────────────────────────── │
│ Creates ONE variable + constraint per share type: │
│ - share|temporal: (effect, time) │
│ - share|periodic: (effect, period) │
└─────────────────────────────────────────────────────────────────────┘
Benefits
1. Centralized: All share registration in EffectsModel.finalize_shares()
2. Simple properties: Type-level models just expose factors + IDs
3. Sparse: Only elements with effects are included
4. Clean multiplication: variable.sel(ids) * factors * duration
Benchmark Results
┌──────────────────┬───────────────┬────────────┬─────────────┐
│ Config │ Build Speedup │ Variables │ Constraints │
├──────────────────┼───────────────┼────────────┼─────────────┤
│ 50 conv, 100 ts │ 7.1x │ 7 (vs 208) │ 8 (vs 108) │
├──────────────────┼───────────────┼────────────┼─────────────┤
│ 100 conv, 200 ts │ 9.0x │ 7 (vs 408) │ 8 (vs 208) │
├──────────────────┼───────────────┼────────────┼─────────────┤
│ 200 conv, 100 ts │ 9.8x │ 7 (vs 808) │ 8 (vs 408) │
└──────────────────┴───────────────┴────────────┴─────────────┘
Pattern Established
All effect contributions now follow a clean property-based pattern:
┌──────────────────┬────────────────────────────────┬──────────┬──────────┬───────────────────────┐
│ Model │ Property │ Variable │ Type │ Formula │
├──────────────────┼────────────────────────────────┼──────────┼──────────┼───────────────────────┤
│ FlowsModel │ effect_factors_per_flow_hour │ rate │ temporal │ rate × factors × dt │
├──────────────────┼────────────────────────────────┼──────────┼──────────┼───────────────────────┤
│ StatusesModel │ effect_factors_per_active_hour │ status │ temporal │ status × factors × dt │
├──────────────────┼────────────────────────────────┼──────────┼──────────┼───────────────────────┤
│ StatusesModel │ effect_factors_per_startup │ startup │ temporal │ startup × factors │
├──────────────────┼────────────────────────────────┼──────────┼──────────┼───────────────────────┤
│ InvestmentsModel │ effect_factors_per_size │ size │ periodic │ size × factors │
├──────────────────┼────────────────────────────────┼──────────┼──────────┼───────────────────────┤
│ InvestmentsModel │ effect_factors_fix │ invested │ periodic │ invested × factors │
├──────────────────┼────────────────────────────────┼──────────┼──────────┼───────────────────────┤
│ InvestmentsModel │ effect_factors_retirement │ invested │ periodic │ -invested × factors │
└──────────────────┴────────────────────────────────┴──────────┴──────────┴───────────────────────┘
Key Changes
1. InvestmentsModel (features.py:520-594): Converted method-based to property-based
- effect_factors_per_size, effect_factors_fix, effect_factors_retirement
- _build_factors now gets effect_ids internally
2. FlowsModel (elements.py:2016-2064): Fixed time-varying factors
- Properly handles multi-dimensional factors (time, period, scenario)
- Uses xr.concat to preserve dimensionality
3. EffectsModel (effects.py:1000-1065): Updated collection methods
- _collect_status_shares uses property-based factors
- _collect_investment_shares uses property-based factors
- Both extract element IDs from factor coords (implicit mask)
Performance Results
Build speedup: 6.1x to 8.8x faster
Variables: 7 vs 208-808 (massively reduced)
Constraints: 8 vs 108-408 (massively reduced)
The model builds and solves correctly with the new architecture.
Final Data Flow
LAYER 1: Individual Elements
─────────────────────────────
Flow.effects_per_flow_hour: dict → e.g., {'costs': 0.04, 'CO2': 0.3}
StatusParams.effects_per_active_hour: dict
StatusParams.effects_per_startup: dict
InvestParams.effects_of_investment_per_size: dict
InvestParams.effects_of_investment: dict
InvestParams.effects_of_retirement: dict
│
▼
LAYER 2: Type Models (aggregation via xr.concat)
─────────────────────────────────────────────────
FlowsModel.effects_per_flow_hour: DataArray(flow, effect)
StatusesModel.effects_per_active_hour: DataArray(element, effect)
StatusesModel.effects_per_startup: DataArray(element, effect)
InvestmentsModel.effects_of_investment_per_size: DataArray(element, effect)
InvestmentsModel.effects_of_investment: DataArray(element, effect)
InvestmentsModel.effects_of_retirement: DataArray(element, effect)
※ Missing (element, effect) = NaN → .fillna(0) for computation
※ Property names match attribute names
│
▼
LAYER 3: EffectsModel (expression building)
───────────────────────────────────────────
expr = (variable * factors.fillna(0) * duration).sum(dim)
Key Design Decisions
1. Property names match attribute names - effects_per_flow_hour not effect_factors_per_flow_hour
2. NaN for missing effects - Distinguishes "not defined" from "zero"
- factors.fillna(0) for computation
- factors.notnull() as mask if needed
3. xr.concat pattern - Clean list comprehension + concat:
flow_factors = [
xr.concat([xr.DataArray(flow.effects.get(eff, np.nan)) for eff in effect_ids], dim='effect')
.assign_coords(effect=effect_ids)
for flow in flows_with_effects
]
return xr.concat(flow_factors, dim='flow').assign_coords(flow=flow_ids)
4. Consistent structure across all models - Same _build_factors helper in both StatusesModel and InvestmentsModel
Performance
Build speedup: 6.8x to 8.3x faster
Variables: 7 vs 208-808
…ry of the changes: Changes Made 1. Removed SharesModel class from effects.py - The class at lines 42-155 was never instantiated (confirmed by grep) - It was an intermediate design that was superseded by direct expression building in finalize_shares() 2. Updated documentation/comments: - effects.py:453 - Updated EffectsModel docstring: "via SharesModel" → "Direct expression building for effect shares" - effects.py:486-493 - Updated comment for contribution lists: removed "Legacy" and "TODO: Remove once all callers use SharesModel directly" - effects.py:54 - Removed deprecated note from _stack_expressions docstring - structure.py:1014-1019 - Updated comments for finalize_shares() and create_share_variables() - features.py:737-738 - Updated docstring reference from SharesModel to direct expression building Current Architecture The effect share system now has two complementary paths: 1. finalize_shares() - Builds expressions directly from type-level models (FlowsModel, StatusesModel, InvestmentsModel) and modifies constraints in-place 2. add_share_temporal/add_share_periodic → create_share_variables() - Handles per-element contributions (cross-effect shares, non-batched contributions) through contribution tracking Verification - ✓ Benchmark tests pass with 7.7x speedup maintained - ✓ Manual test with effects (Costs + CO2) works correctly - ✓ Variables: 6 (batched), Constraints: 8 (batched) - ✓ Effect totals calculated correctly: [13.33, 33.33, -0.0] for [Costs, CO2, Penalty]
Removed (~200 lines)
┌───────────────────────────────────────────────────┬───────────────┐
│ Item │ Lines Removed │
├───────────────────────────────────────────────────┼───────────────┤
│ _stack_expressions() function │ ~30 lines │
├───────────────────────────────────────────────────┼───────────────┤
│ _temporal_contributions list │ 3 lines │
├───────────────────────────────────────────────────┼───────────────┤
│ _periodic_contributions list │ 3 lines │
├───────────────────────────────────────────────────┼───────────────┤
│ create_share_variables() method │ ~130 lines │
├───────────────────────────────────────────────────┼───────────────┤
│ Tracking loop in apply_batched_flow_effect_shares │ ~6 lines │
├───────────────────────────────────────────────────┼───────────────┤
│ create_share_variables() call in structure.py │ 2 lines │
└───────────────────────────────────────────────────┴───────────────┘
Simplified
- add_share_temporal() - removed list append
- add_share_periodic() - removed list append
Results
- Variables: 6 (no more share|temporal or share|periodic)
- Constraints: 7 (down from 8)
- Performance: 8.1x speedup (maintained)
- Cross-effect shares: Still working correctly (tested with share_from_temporal={'CO2': 0.2})
…s to 14 lines while maintaining performance
- Variables: 7 (including share|temporal with (flow, effect, time) dims) - Constraints: 9 (only ONE share|temporal constraint, not one per element) - Performance: 6.5x - 7.3x faster build time The share|temporal variable now directly uses FlowsModel.effects_per_flow_hour with its native (flow, effect) dimensions, creating a single batched constraint instead of per-element constraints.
- finalize_shares() is the single entry point - _create_temporal_shares() handles flow effects → creates share_temporal, adds constraint, adds sum to effect|per_timestep - _create_periodic_shares() handles investment effects → creates share_periodic, adds constraint, adds sum to effect|periodic All the data access (factors, rates, etc.) is now in one place instead of being duplicated.
…eusable coord builder
- _create_temporal_shares() - creates share_temporal, adds constraint, adds sum to effect
- _add_status_effects() - adds status effects directly (no visibility variable)
- _create_periodic_shares() - creates share_periodic, adds constraint, adds sum to effect
- _add_investment_effects() - adds investment effects directly (no visibility variable)
The structure is now:
finalize_shares()
├── _create_temporal_shares()
│ └── _add_status_effects()
└── _create_periodic_shares()
└── _add_investment_effects()
def _create_temporal_shares(self, flows_model, dt):
temporal_exprs = []
# Flow effects -> share_temporal variable
temporal_exprs.append(self.share_temporal.sum(dim))
# Status effects (direct expression)
temporal_exprs.append((status * factors * dt).sum(dim))
# Startup effects (direct expression)
temporal_exprs.append((startup * factors).sum(dim))
# ONE constraint modification
self._eq_per_timestep.lhs -= sum(temporal_exprs)
def _create_periodic_shares(self, flows_model):
periodic_exprs = []
# Size effects -> share_periodic variable
periodic_exprs.append(self.share_periodic.sum(dim))
# Investment effects (direct expression)
periodic_exprs.append((invested * factors).sum(dim))
# Retirement effects (direct expression)
periodic_exprs.append((invested * (-factors)).sum(dim))
# ONE constraint modification
self._eq_periodic.lhs -= sum(periodic_exprs)
…performance: ┌───────────────────┬───────────────┬──────────────────┐ │ Configuration │ Build Speedup │ LP Write Speedup │ ├───────────────────┼───────────────┼──────────────────┤ │ 50 conv, 100 ts │ 7.1x │ 7.8x │ ├───────────────────┼───────────────┼──────────────────┤ │ 100 conv, 200 ts │ 7.5x │ 7.0x │ ├───────────────────┼───────────────┼──────────────────┤ │ 200 conv, 100 ts │ 8.4x │ 13.5x │ ├───────────────────┼───────────────┼──────────────────┤ │ 100 conv, 500 ts │ 7.8x │ 3.7x │ ├───────────────────┼───────────────┼──────────────────┤ │ 100 conv, 2000 ts │ 8.1x │ 1.4x │ └───────────────────┴───────────────┴──────────────────┘ The simplification is complete: - Variables: 200-800 → 7 (batched with element dimension) - Constraints: 100-400 → 8 (batched) - Code: Compact _create_temporal_shares() and _create_periodic_shares() methods that always create share variables - Performance: 7-8x faster build time maintained
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Description
This PR implements Phase 1 & 2 of a Clean Batching Architecture for flixopt, introducing type-level models that handle ALL elements of a type in a single instance (e.g., one
FlowsModelfor ALL Flows, not oneFlowModelper Flow).Performance Results
Architecture Overview
What Was Implemented
Phase 1: Foundation (
structure.py)ElementType: FLOW, BUS, STORAGE, CONVERTER, EFFECTVariableType: FLOW_RATE, STATUS, CHARGE_STATE, SIZE, etc.ConstraintType: TRACKING, BOUNDS, BALANCE, LINKING, etc.ExpansionCategoryalias for backward-compatible segment expansionVARIABLE_TYPE_TO_EXPANSIONmapping connecting new enums to segment expansionTypeModelbase class with:add_variables(): Creates batched variables with element dimensionadd_constraints(): Creates batched constraints_stack_bounds(): Stacks per-element bounds into DataArraysget_variable(): Element slice accessPhase 2: FlowsModel (
elements.py)FlowsModel(TypeModel)class handling ALL flows:flows_with_status,flows_with_investment, etc.flow_rate,total_flow_hours,status,size,investedcreate_effect_shares()for batched effect contributionsFlowModelProxylightweight proxy that uses FlowsModel variablesdo_modeling_type_level()method inFlowSystemModel_type_level_modeflag to switch between traditional and type-level modelingHow It Works
do_modeling_type_level()collects all flows and createsFlowsModelFlowsModelcreates batched variables with element dimension (oneflow_ratevar for ALL flows)FlowModelProxyinstead ofFlowModelFlowModelProxyprovides the same interface but delegates toFlowsModelvariablesNext Steps (Future PRs)
StoragesModel(TypeModel)BusesModel(TypeModel)StatusFeaturesModel,InvestmentFeaturesModel)do_modeling()pathType of Change
Testing
Checklist