flixOpt.commons
This module makes the commonly used classes and functions available in the flixOpt framework.
Classes
AggregationParameters
AggregationParameters(hours_per_period: float, nr_of_periods: int, fix_storage_flows: bool, aggregate_data_and_fix_non_binary_vars: bool, percentage_of_period_freedom: float = 0, penalty_of_period_freedom: float = 0, time_series_for_high_peaks: List[TimeSeriesData] = None, time_series_for_low_peaks: List[TimeSeriesData] = None)
Initializes aggregation parameters for time series data
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
hours_per_period
|
float
|
Duration of each period in hours. |
required |
nr_of_periods
|
int
|
Number of typical periods to use in the aggregation. |
required |
fix_storage_flows
|
bool
|
Whether to aggregate storage flows (load/unload); if other flows are fixed, fixing storage flows is usually not required. |
required |
aggregate_data_and_fix_non_binary_vars
|
bool
|
Whether to aggregate all time series data, which allows to fix all time series variables (like flow_rate), or only fix binary variables. If False non time_series data is changed!! If True, the mathematical Problem is simplified even further. |
required |
percentage_of_period_freedom
|
float
|
Specifies the maximum percentage (0–100) of binary values within each period that can deviate as "free variables", chosen by the solver (default is 0). This allows binary variables to be 'partly equated' between aggregated periods. |
0
|
penalty_of_period_freedom
|
float
|
The penalty associated with each "free variable"; defaults to 0. Added to Penalty |
0
|
time_series_for_high_peaks
|
list of TimeSeriesData
|
List of time series to use for explicitly selecting periods with high values. |
None
|
time_series_for_low_peaks
|
list of TimeSeriesData
|
List of time series to use for explicitly selecting periods with low values. |
None
|
Functions
AggregatedCalculation
AggregatedCalculation(name, flow_system: FlowSystem, aggregation_parameters: AggregationParameters, components_to_clusterize: Optional[List[Component]] = None, modeling_language: Literal['pyomo', 'cvxpy'] = 'pyomo', time_indices: Optional[Union[range, List[int]]] = None)
Bases: Calculation
class for defined way of solving a flow_system optimization
Class for Optimizing the FLowSystem including: 1. Aggregating TimeSeriesData via typical periods using tsam. 2. Equalizing variables of typical periods.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
name
|
str
|
name of calculation |
required |
aggregation_parameters
|
AggregationParameters
|
Parameters for aggregation. See documentation of AggregationParameters class. |
required |
components_to_clusterize
|
Optional[List[Component]]
|
List of Components to perform aggregation on. If None, then all components are aggregated. This means, teh variables in the components are equalized to each other, according to the typical periods computed in the DataAggregation |
None
|
flow_system
|
FlowSystem
|
flow_system which should be calculated |
required |
modeling_language
|
'pyomo','cvxpy' (not implemeted yet)
|
choose optimization modeling language |
'pyomo'
|
time_indices
|
List[int] or None
|
list with indices, which should be used for calculation. If None, then all timesteps are used. |
None
|
Functions
FullCalculation
FullCalculation(name, flow_system: FlowSystem, modeling_language: Literal['pyomo', 'cvxpy'] = 'pyomo', time_indices: Optional[Union[range, List[int]]] = None)
Bases: Calculation
class for defined way of solving a flow_system optimization
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
name
|
str
|
name of calculation |
required |
flow_system
|
FlowSystem
|
flow_system which should be calculated |
required |
modeling_language
|
'pyomo','cvxpy' (not implemeted yet)
|
choose optimization modeling language |
'pyomo'
|
time_indices
|
List[int] or None
|
list with indices, which should be used for calculation. If None, then all timesteps are used. |
None
|
Functions
SegmentedCalculation
SegmentedCalculation(name, flow_system: FlowSystem, segment_length: int, overlap_length: int, modeling_language: Literal['pyomo', 'cvxpy'] = 'pyomo', time_indices: Optional[Union[range, list[int]]] = None)
Bases: Calculation
Dividing and Modeling the problem in (overlapping) segments. The final values of each Segment are recognized by the following segment, effectively coupling charge_states and flow_rates between segments. Because of this intersection, both modeling and solving is done in one step
Take care: Parameters like InvestParameters, sum_of_flow_hours and other restrictions over the total time_series don't really work in this Calculation. Lower bounds to such SUMS can lead to weird results. This is NOT yet explicitly checked for...
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
name
|
str
|
name of calculation |
required |
flow_system
|
FlowSystem
|
flow_system which should be calculated |
required |
segment_length
|
int
|
The number of time_steps per individual segment (without the overlap) |
required |
overlap_length
|
int
|
The number of time_steps that are added to each individual model. Used for better results of storages) |
required |
modeling_language
|
'pyomo', 'cvxpy' (not implemeted yet)
|
choose optimization modeling language |
'pyomo'
|
time_indices
|
List[int] or None
|
list with indices, which should be used for calculation. If None, then all timesteps are used. |
None
|
Attributes
start_values_of_segments
property
Gives an overview of the start values of all Segments
Functions
results
results(combined_arrays: bool = False, combined_scalars: bool = False, individual_results: bool = False) -> Dict[str, Union[Numeric, Dict[str, Numeric]]]
Retrieving the results of a Segmented Calculation is not as straight forward as with other Calculation types. You have 3 options: 1. combined_arrays: Retrieve the combined array Results of all Segments as 'combined_arrays'. All result arrays ar concatenated, taking care of removing the overlap. These results can be directly compared to other Calculation results. Unfortunately, Scalar values like the total of effects can not be combined in a deterministic way. Rather convert the time series effect results to a sum yourself. 2. combined_scalars: Retrieve the combined scalar Results of all Segments. All Scalar Values like the total of effects are combined and stored in a List. Take care that the total of multiple Segment is not equivalent to the total of the total timeSeries, as it includes the Overlap! 3. individual_results: Retrieve the individual results of each Segment
LinearConverter
LinearConverter(label: str, inputs: List[Flow], outputs: List[Flow], on_off_parameters: OnOffParameters = None, conversion_factors: List[Dict[Flow, Numeric_TS]] = None, segmented_conversion_factors: Dict[Flow, List[Tuple[Numeric_TS, Numeric_TS]]] = None, meta_data: Optional[Dict] = None)
Bases: Component
Converts one FLow into another via linear conversion factors
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
label
|
str
|
name. |
required |
meta_data
|
Optional[Dict]
|
used to store more information about the element. Is not used internally, but saved in the results |
None
|
inputs
|
input flows.
|
|
required |
outputs
|
output flows.
|
|
required |
on_off_parameters
|
OnOffParameters
|
|
None
|
conversion_factors
|
linear relation between flows.
|
Either 'conversion_factors' or 'segmented_conversion_factors' can be used! example heat pump: |
None
|
segmented_conversion_factors
|
Segmented linear relation between flows.
|
Each Flow gets a List of Segments assigned. If FLows need to be 0 (or Off), include a "Zero-Segment" "(0, 0)", or use on_off_parameters Either 'segmented_conversion_factors' or 'conversion_factors' can be used! --> "gaps" can be expressed by a segment not starting at the end of the prior segment : [(1,3), (4,5)] --> "points" can expressed as segment with same begin and end : [(3,3), (4,4)] |
None
|
Sink
Source
SourceAndSink
SourceAndSink(label: str, source: Flow, sink: Flow, prevent_simultaneous_flows: bool = True, meta_data: Optional[Dict] = None)
Bases: Component
class for source (output-flow) and sink (input-flow) in one commponent
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
label
|
str
|
name of sourceAndSink |
required |
meta_data
|
Optional[Dict]
|
used to store more information about the element. Is not used internally, but saved in the results |
None
|
source
|
Flow
|
output-flow of this component |
required |
sink
|
Flow
|
input-flow of this component |
required |
prevent_simultaneous_flows
|
bool
|
True: inflow and outflow are not allowed to be both non-zero at same timestep. False: inflow and outflow are working independently. |
True
|
Storage
Storage(label: str, charging: Flow, discharging: Flow, capacity_in_flow_hours: Union[Skalar, InvestParameters], relative_minimum_charge_state: Numeric = 0, relative_maximum_charge_state: Numeric = 1, initial_charge_state: Optional[Union[Skalar, Literal['lastValueOfSim']]] = 0, minimal_final_charge_state: Optional[Skalar] = None, maximal_final_charge_state: Optional[Skalar] = None, eta_charge: Numeric = 1, eta_discharge: Numeric = 1, relative_loss_per_hour: Numeric = 0, prevent_simultaneous_charge_and_discharge: bool = True, meta_data: Optional[Dict] = None)
Bases: Component
Klasse Storage
constructor of storage
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
label
|
str
|
description. |
required |
meta_data
|
Optional[Dict]
|
used to store more information about the element. Is not used internally, but saved in the results |
None
|
charging
|
Flow
|
ingoing flow. |
required |
discharging
|
Flow
|
outgoing flow. |
required |
capacity_in_flow_hours
|
Skalar or InvestParameter
|
nominal capacity of the storage |
required |
relative_minimum_charge_state
|
float or TS
|
minimum relative charge state. The default is 0. |
0
|
relative_maximum_charge_state
|
float or TS
|
maximum relative charge state. The default is 1. |
1
|
initial_charge_state
|
None, float (0...1), 'lastValueOfSim', optional
|
storage charge_state at the beginning. The default is 0. float: defined charge_state at start of first timestep None: free to choose by optimizer 'lastValueOfSim': chargeState0 is equal to chargestate of last timestep ("closed simulation") |
0
|
minimal_final_charge_state
|
float or None
|
minimal value of chargeState at the end of timeseries. |
None
|
maximal_final_charge_state
|
float or None
|
maximal value of chargeState at the end of timeseries. |
None
|
eta_charge
|
float
|
efficiency factor of charging/loading. The default is 1. |
1
|
eta_discharge
|
TYPE
|
efficiency factor of uncharging/unloading. The default is 1. |
1
|
relative_loss_per_hour
|
float or optional
|
loss per chargeState-Unit per hour. The default is 0. |
0
|
prevent_simultaneous_charge_and_discharge
|
boolean
|
should simultaneously Loading and Unloading be avoided? (Attention, Performance maybe becomes worse with avoidInAndOutAtOnce=True). The default is True. |
True
|
Transmission
Transmission(label: str, in1: Flow, out1: Flow, in2: Optional[Flow] = None, out2: Optional[Flow] = None, relative_losses: Optional[Numeric_TS] = None, absolute_losses: Optional[Numeric_TS] = None, on_off_parameters: OnOffParameters = None, prevent_simultaneous_flows_in_both_directions: bool = True)
Bases: Component
Initializes a Transmission component (Pipe, cable, ...) that models the flows between two sides with potential losses.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
label
|
str
|
The name of the transmission component. |
required |
in1
|
Flow
|
The inflow at side A. Pass InvestmentParameters here. |
required |
out1
|
Flow
|
The outflow at side B. |
required |
in2
|
Optional[Flow]
|
The optional inflow at side B. If in1 got Investmentparameters, the size of this Flow will be equal to in1 (with no extra effects!) |
None
|
out2
|
Optional[Flow]
|
The optional outflow at side A. |
None
|
relative_losses
|
Optional[Numeric_TS]
|
The relative loss between inflow and outflow, e.g., 0.02 for 2% loss. |
None
|
absolute_losses
|
Optional[Numeric_TS]
|
The absolute loss, occur only when the Flow is on. Induces the creation of the ON-Variable |
None
|
on_off_parameters
|
OnOffParameters
|
Parameters defining the on/off behavior of the component. |
None
|
prevent_simultaneous_flows_in_both_directions
|
bool
|
If True, prevents simultaneous flows in both directions. |
True
|
CONFIG
A configuration class that stores global configuration values as class attributes.
Functions
load_config
classmethod
Initialize configuration using defaults or user-specified file.
TimeSeriesData
timeseries class for transmit timeseries AND special characteristics of timeseries, i.g. to define weights needed in calculation_type 'aggregated' EXAMPLE solar: you have several solar timeseries. These should not be overweighted compared to the remaining timeseries (i.g. heat load, price)! fixed_relative_profile_solar1 = TimeSeriesData(sol_array_1, type = 'solar') fixed_relative_profile_solar2 = TimeSeriesData(sol_array_2, type = 'solar') fixed_relative_profile_solar3 = TimeSeriesData(sol_array_3, type = 'solar') --> this 3 series of same type share one weight, i.e. internally assigned each weight = 1/3 (instead of standard weight = 1)
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
data
|
Union[int, float, ndarray]
|
The timeseries data, which can be a scalar, array, or numpy array. |
required |
agg_group
|
str
|
The group this TimeSeriesData is a part of. agg_weight is split between members of a group. Default is None. |
None
|
agg_weight
|
float
|
The weight for calculation_type 'aggregated', should be between 0 and 1. Default is None. |
None
|
Raises:
| Type | Description |
|---|---|
Exception
|
If both agg_group and agg_weight are set, an exception is raised. |
Functions
Effect
Effect(label: str, unit: str, description: str, meta_data: Optional[Dict] = None, is_standard: bool = False, is_objective: bool = False, specific_share_to_other_effects_operation: EffectValues = None, specific_share_to_other_effects_invest: EffectValuesInvest = None, minimum_operation: Optional[Skalar] = None, maximum_operation: Optional[Skalar] = None, minimum_invest: Optional[Skalar] = None, maximum_invest: Optional[Skalar] = None, minimum_operation_per_hour: Optional[Numeric_TS] = None, maximum_operation_per_hour: Optional[Numeric_TS] = None, minimum_total: Optional[Skalar] = None, maximum_total: Optional[Skalar] = None)
Bases: Element
Effect, i.g. costs, CO2 emissions, area, ... Components, FLows, and so on can contribute to an Effect. One Effect is chosen as the Objective of the Optimization
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
label
|
str
|
name |
required |
unit
|
str
|
unit of effect, i.g. €, kg_CO2, kWh_primaryEnergy |
required |
description
|
str
|
long name |
required |
meta_data
|
Optional[Dict]
|
used to store more information about the element. Is not used internally, but saved in the results |
None
|
is_standard
|
boolean
|
true, if Standard-Effect (for direct input of value without effect (alternatively to dict)) , else false |
False
|
is_objective
|
boolean
|
true, if optimization target |
False
|
specific_share_to_other_effects_operation
|
effectType: TS, ...}, i.g. 180 €/t_CO2, input as {costs: 180
|
share to other effects (only operation) |
effectType: TS
|
specific_share_to_other_effects_invest
|
effectType: TS, ...}, i.g. 180 €/t_CO2, input as {costs: 180
|
share to other effects (only invest). |
effectType: TS
|
minimum_operation
|
scalar
|
minimal sum (only operation) of the effect |
None
|
maximum_operation
|
scalar
|
maximal sum (nur operation) of the effect. |
None
|
minimum_operation_per_hour
|
scalar or TS
|
maximum value per hour (only operation) of effect (=sum of all effect-shares) for each timestep! |
None
|
maximum_operation_per_hour
|
scalar or TS
|
minimum value per hour (only operation) of effect (=sum of all effect-shares) for each timestep! |
None
|
minimum_invest
|
scalar
|
minimal sum (only invest) of the effect |
None
|
maximum_invest
|
scalar
|
maximal sum (only invest) of the effect |
None
|
minimum_total
|
sclalar
|
min sum of effect (invest+operation). |
None
|
maximum_total
|
scalar
|
max sum of effect (invest+operation). |
None
|
**kwargs
|
TYPE
|
DESCRIPTION. |
required |
Returns:
| Type | Description |
|---|---|
None.
|
|
Functions
infos
Generate a dictionary representation of the object's constructor arguments. Excludes default values and empty dictionaries and lists. Converts data to be compatible with JSON.
Parameters:
use_numpy bool:
Whether to convert NumPy arrays to lists. Defaults to True.
If True, numeric numpy arrays (np.ndarray) are preserved as-is.
If False, they are converted to lists.
use_element_label bool:
Whether to use the element label instead of the infos of the element. Defaults to False.
Note that Elements used as keys in dictionaries are always converted to their labels.
Returns: Dict: A dictionary representation of the object's constructor arguments.
Bus
Bus(label: str, excess_penalty_per_flow_hour: Optional[Numeric_TS] = 100000.0, meta_data: Optional[Dict] = None)
Bases: Element
realizing balance of all linked flows (penalty flow is excess can be activated)
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
label
|
str
|
name. |
required |
meta_data
|
Optional[Dict]
|
used to store more information about the element. Is not used internally, but saved in the results |
None
|
excess_penalty_per_flow_hour
|
(none or scalar, array or TimeSeriesData)
|
excess costs / penalty costs (bus balance compensation) (none/ 0 -> no penalty). The default is 1e5. (Take care: if you use a timeseries (no scalar), timeseries is aggregated if calculation_type = aggregated!) |
100000.0
|
Functions
infos
Generate a dictionary representation of the object's constructor arguments. Excludes default values and empty dictionaries and lists. Converts data to be compatible with JSON.
Parameters:
use_numpy bool:
Whether to convert NumPy arrays to lists. Defaults to True.
If True, numeric numpy arrays (np.ndarray) are preserved as-is.
If False, they are converted to lists.
use_element_label bool:
Whether to use the element label instead of the infos of the element. Defaults to False.
Note that Elements used as keys in dictionaries are always converted to their labels.
Returns: Dict: A dictionary representation of the object's constructor arguments.
Flow
Flow(label: str, bus: Bus, size: Union[Skalar, InvestParameters] = None, fixed_relative_profile: Optional[Numeric_TS] = None, relative_minimum: Numeric_TS = 0, relative_maximum: Numeric_TS = 1, effects_per_flow_hour: EffectValues = None, on_off_parameters: Optional[OnOffParameters] = None, flow_hours_total_max: Optional[Skalar] = None, flow_hours_total_min: Optional[Skalar] = None, load_factor_min: Optional[Skalar] = None, load_factor_max: Optional[Skalar] = None, previous_flow_rate: Optional[Numeric] = None, meta_data: Optional[Dict] = None)
Bases: Element
flows are inputs and outputs of components
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
label
|
str
|
name of flow |
required |
meta_data
|
Optional[Dict]
|
used to store more information about the element. Is not used internally, but saved in the results |
None
|
bus
|
Bus
|
bus to which flow is linked |
required |
size
|
(scalar, InvestmentParameters)
|
size of the flow. If InvestmentParameters is used, size is optimized. If size is None, a default value is used. |
None
|
relative_minimum
|
(scalar, array, TimeSeriesData)
|
min value is relative_minimum multiplied by size |
0
|
relative_maximum
|
(scalar, array, TimeSeriesData)
|
max value is relative_maximum multiplied by size. If size = max then relative_maximum=1 |
1
|
load_factor_min
|
scalar
|
minimal load factor general: avg Flow per nominalVal/investSize
(e.g. boiler, kW/kWh=h; solarthermal: kW/m²;
def: :math: |
None
|
load_factor_max
|
scalar
|
maximal load factor (see minimal load factor) |
None
|
effects_per_flow_hour
|
(scalar, array, TimeSeriesData)
|
operational costs, costs per flow-"work" |
None
|
on_off_parameters
|
OnOffParameters
|
If present, flow can be "off", i.e. be zero (only relevant if relative_minimum > 0) Therefore a binary var "on" is used. Further, several other restrictions and effects can be modeled through this On/Off State (See OnOffParameters) |
None
|
flow_hours_total_max
|
TYPE
|
maximum flow-hours ("flow-work") (if size is not const, maybe load_factor_max fits better for you!) |
None
|
flow_hours_total_min
|
TYPE
|
minimum flow-hours ("flow-work") (if size is not const, maybe load_factor_min fits better for you!) |
None
|
fixed_relative_profile
|
(scalar, array, TimeSeriesData)
|
fixed relative values for flow (if given). val(t) := fixed_relative_profile(t) * size(t) With this value, the flow_rate is no opt-variable anymore; (relative_minimum u. relative_maximum are making sense anymore) used for fixed load profiles, i.g. heat demand, wind-power, solarthermal If the load-profile is just an upper limit, use relative_maximum instead. |
None
|
previous_flow_rate
|
(scalar, array)
|
previous flow rate of the component. |
None
|
FlowSystem
FlowSystem(time_series: ndarray[datetime64], last_time_step_hours: Optional[Union[int, float]] = None, previous_dt_in_hours: Optional[Union[int, float, ndarray]] = None)
A FlowSystem organizes the high level Elements (Components & Effects).
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
time_series
|
np.ndarray of datetime64
|
timeseries of the data. Must be in datetime64 format. Don't use precisions below 'us'. !np.datetime64[ns]! |
required |
last_time_step_hours
|
Optional[Union[int, float]]
|
The duration of last time step. Storages needs this time-duration for calculation of charge state after last time step. If None, then last time increment of time_series is used. |
None
|
previous_dt_in_hours
|
Union[int, float, ndarray]
|
The duration of previous time steps. If None, the first time increment of time_series is used. This is needed to calculate previous durations (for example consecutive_on_hours). If you use an array, take care that its long enough to cover all previous values! |
None
|
Functions
add_elements
add all modeling elements, like storages, boilers, heatpumps, buses, ...
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
*args
|
childs of Element like Boiler, HeatPump, Bus,...
|
modeling Elements |
()
|
to_json
Saves the flow system to a json file. This not meant to be reloaded and recreate the object, but rather used to document or compare the object.
Parameters:
path : Union[str, pathlib.Path] The path to the json file.
visualize_network
visualize_network(path: Union[bool, str, Path] = 'flow_system.html', controls: Union[bool, List[Literal['nodes', 'edges', 'layout', 'interaction', 'manipulation', 'physics', 'selection', 'renderer']]] = True, show: bool = True) -> Optional[pyvis.network.Network]
Visualizes the network structure of a FlowSystem using PyVis, saving it as an interactive HTML file.
Parameters:
- path (Union[bool, str, pathlib.Path], default='flow_system.html'):
Path to save the HTML visualization.
- False: Visualization is created but not saved.
- str or Path: Specifies file path (default: 'flow_system.html').
-
controls (Union[bool, List[str]], default=True): UI controls to add to the visualization.
True: Enables all available controls.List: Specify controls, e.g., ['nodes', 'layout'].- Options: 'nodes', 'edges', 'layout', 'interaction', 'manipulation', 'physics', 'selection', 'renderer'.
-
show (bool, default=True): Whether to open the visualization in the web browser.
Returns:
- Optional[pyvis.network.Network]: The Network instance representing the visualization, or None if pyvis is not installed.
Usage: - Visualize and open the network with default options:
self.visualize_network()
-
Save the visualization without opening:
self.visualize_network(show=False)
-
Visualize with custom controls and path:
self.visualize_network(path='output/custom_network.html', controls=['nodes', 'layout'])
Notes:
- This function requires pyvis. If not installed, the function prints a warning and returns None.
- Nodes are styled based on type (e.g., circles for buses, boxes for components) and annotated with node information.
get_time_data_from_indices
get_time_data_from_indices(time_indices: Optional[Union[List[int], range]] = None) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.float64]
Computes time series data based on the provided time indices.
Args: time_indices: A list of indices or a range object indicating which time steps to extract. If None, the entire time series is used.
Returns: A tuple containing: - Extracted time series - Time series with the "end time" appended - Differences between consecutive timestamps in hours - Total time in hours
InvestParameters
InvestParameters(fixed_size: Optional[Union[int, float]] = None, minimum_size: Union[int, float] = 0, maximum_size: Optional[Union[int, float]] = None, optional: bool = True, fix_effects: Union[Dict, int, float] = None, specific_effects: Union[Dict, int, float] = None, effects_in_segments: Optional[Tuple[List[Tuple[Skalar, Skalar]], Dict[Effect, List[Tuple[Skalar, Skalar]]]]] = None, divest_effects: Union[Dict, int, float] = None)
Bases: Interface
collects arguments for invest-stuff
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
fix_effects
|
None or scalar
|
Fixed investment costs if invested. (Attention: Annualize costs to chosen period!) |
None
|
divest_effects
|
None or scalar
|
Fixed divestment costs (if not invested, e.g., demolition costs or contractual penalty). |
None
|
fixed_size
|
(int, float)
|
Determines if the investment size is fixed. |
None
|
optional
|
bool
|
If True, investment is not forced. |
True
|
specific_effects
|
scalar or Dict[Effect: Union[int, float, np.ndarray]
|
Specific costs, e.g., in €/kW_nominal or €/m²_nominal. Example: {costs: 3, CO2: 0.3} with costs and CO2 representing an Object of class Effect (Attention: Annualize costs to chosen period!) |
None
|
effects_in_segments
|
list or List[ List[Union[int,float]], Dict[cEffecType: Union[List[Union[int,float]]
|
Linear relation in segments [invest_segments, cost_segments]. Example 1: [ [5, 25, 25, 100], # size in kW {costs: [50,250,250,800], # € PE: [5, 25, 25, 100] # kWh_PrimaryEnergy } ] Example 2 (if only standard-effect): [ [5, 25, 25, 100], # kW # size in kW [50,250,250,800] # value for standart effect, typically € ] # € (Attention: Annualize costs to chosen period!) (Args 'specific_effects' and 'fix_effects' can be used in parallel to InvestsizeSegments) |
None
|
minimum_size
|
scalar
|
Min nominal value (only if: size_is_fixed = False). |
0
|
maximum_size
|
(scalar, Optional)
|
Max nominal value (only if: size_is_fixed = False). |
None
|
Functions
infos
Generate a dictionary representation of the object's constructor arguments. Excludes default values and empty dictionaries and lists. Converts data to be compatible with JSON.
Parameters:
use_numpy bool:
Whether to convert NumPy arrays to lists. Defaults to True.
If True, numeric numpy arrays (np.ndarray) are preserved as-is.
If False, they are converted to lists.
use_element_label bool:
Whether to use the element label instead of the infos of the element. Defaults to False.
Note that Elements used as keys in dictionaries are always converted to their labels.
Returns: Dict: A dictionary representation of the object's constructor arguments.
OnOffParameters
OnOffParameters(effects_per_switch_on: Union[Dict, Numeric] = None, effects_per_running_hour: Union[Dict, Numeric] = None, on_hours_total_min: Optional[int] = None, on_hours_total_max: Optional[int] = None, consecutive_on_hours_min: Optional[Numeric] = None, consecutive_on_hours_max: Optional[Numeric] = None, consecutive_off_hours_min: Optional[Numeric] = None, consecutive_off_hours_max: Optional[Numeric] = None, switch_on_total_max: Optional[int] = None, force_switch_on: bool = False)
Bases: Interface
on_off_parameters class for modeling on and off state of an Element. If no parameters are given, the default is to create a binary variable for the on state without further constraints or effects and a variable for the total on hours.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
effects_per_switch_on
|
(scalar, array, TimeSeriesData)
|
cost of one switch from off (var_on=0) to on (var_on=1), unit i.g. in Euro |
None
|
effects_per_running_hour
|
scalar or TS
|
costs for operating, i.g. in € per hour |
None
|
on_hours_total_min
|
scalar
|
min. overall sum of operating hours. |
None
|
on_hours_total_max
|
scalar
|
max. overall sum of operating hours. |
None
|
consecutive_on_hours_min
|
scalar
|
min sum of operating hours in one piece (last on-time period of timeseries is not checked and can be shorter) |
None
|
consecutive_on_hours_max
|
scalar
|
max sum of operating hours in one piece |
None
|
consecutive_off_hours_min
|
scalar
|
min sum of non-operating hours in one piece (last off-time period of timeseries is not checked and can be shorter) |
None
|
consecutive_off_hours_max
|
scalar
|
max sum of non-operating hours in one piece |
None
|
switch_on_total_max
|
integer
|
max nr of switchOn operations |
None
|
force_switch_on
|
bool
|
force creation of switch on variable, even if there is no switch_on_total_max |
False
|
Attributes
use_consecutive_on_hours
property
Determines wether a Variable for consecutive off hours is needed or not
use_consecutive_off_hours
property
Determines wether a Variable for consecutive off hours is needed or not
use_switch_on
property
Determines wether a Variable for SWITCH-ON is needed or not
Functions
infos
Generate a dictionary representation of the object's constructor arguments. Excludes default values and empty dictionaries and lists. Converts data to be compatible with JSON.
Parameters:
use_numpy bool:
Whether to convert NumPy arrays to lists. Defaults to True.
If True, numeric numpy arrays (np.ndarray) are preserved as-is.
If False, they are converted to lists.
use_element_label bool:
Whether to use the element label instead of the infos of the element. Defaults to False.
Note that Elements used as keys in dictionaries are always converted to their labels.
Returns: Dict: A dictionary representation of the object's constructor arguments.
Functions
create_datetime_array
create_datetime_array(start: str, steps: Optional[int] = None, freq: str = '1h', end: Optional[str] = None) -> np.ndarray[np.datetime64]
Create a NumPy array with datetime64 values.
Parameters:
| Name | Type | Description | Default |
|---|---|---|---|
start
|
str
|
Start date in 'YYYY-MM-DD' format or a full timestamp (e.g., 'YYYY-MM-DD HH:MM'). |
required |
steps
|
int
|
Number of steps in the datetime array. If |
None
|
freq
|
str
|
Frequency for the datetime64 array. Supports flexible intervals: - 'Y', 'M', 'W', 'D', 'h', 'm', 's' (e.g., '1h', '15m', '2h'). Defaults to 'h' (hourly). |
'1h'
|
end
|
str
|
End date in 'YYYY-MM-DD' format or a full timestamp (e.g., 'YYYY-MM-DD HH:MM').
If provided, the function generates an array from |
None
|
Returns:
| Type | Description |
|---|---|
ndarray
|
NumPy array of datetime64 values. |
Examples:
Create an array with 15-minute intervals:
>>> create_datetime_array('2023-01-01', steps=5, freq='15m')
array(['2023-01-01T00:00', '2023-01-01T00:15', '2023-01-01T00:30', ...], dtype='datetime64[m]')
Create 2-hour intervals:
>>> create_datetime_array('2023-01-01T00', steps=4, freq='2h')
array(['2023-01-01T00', '2023-01-01T02', '2023-01-01T04', ...], dtype='datetime64[h]')
Generate minute intervals until a specified end time: