odys.parameters.entity_arrays¶

def battery_storage_state_arrays(
    storages: Sequence[BatteryStorage],
    coordinates: Coordinates,
    context: ModelContext,
) -> BatteryStateArrays:
    """Build the initial and final state of charge of the battery storages.

    Args:
        storages: The battery storages, in coordinate order.
        coordinates: The labels of the storages along their dimension.
        context: The shared indexing of the problem, with its conditions.

    Returns:
        The storages' state of charge arrays; `soc_end` is NaN where there is no final state.

    """
    return _battery_state_arrays(StorageInitialState, StorageFinalState, storages, coordinates, context)

def commitment_state_arrays(
    commitments: Sequence[Commitment],
    coordinates: Coordinates,
    horizon: Horizon,
    initially_on: xr.DataArray,
    initial_steps_in_state: xr.DataArray,
) -> CommitmentStateArrays:
    """Build the minimum up and down times in steps of the given commitments, with their entities' initial status.

    Args:
        commitments: The commitments, in coordinate order.
        coordinates: The labels of their entities along the entity dimension.
        horizon: The time grid of the optimization.
        initially_on: Whether each entity is on just before the first timestep.
        initial_steps_in_state: How many steps each entity has been in its initial status (`inf` when unknown).

    Returns:
        The on/off state arrays.

    """

    def steps(duration: timedelta | None) -> int:
        return 1 if duration is None else horizon.steps_in(duration)

    def along_entities(values: Sequence[float]) -> xr.DataArray:
        return xr.DataArray(values, dims=coordinates.dimension, coords=coordinates.dimension_coordinates_map)

    return CommitmentStateArrays(
        min_up_steps=along_entities([steps(commitment.min_up_time) for commitment in commitments]),
        min_down_steps=along_entities([steps(commitment.min_down_time) for commitment in commitments]),
        initially_on=initially_on,
        initial_steps_in_state=initial_steps_in_state,
    )

def electric_vehicle_arrays(
    electric_vehicles: Sequence[ElectricVehicle],
    coordinates: Coordinates,
    context: ModelContext,
) -> ElectricVehicleArrays:
    """Build the battery, state of charge and trip arrays of the electric vehicles.

    Args:
        electric_vehicles: The electric vehicles, in coordinate order.
        coordinates: The labels of the electric vehicles along the EV dimension.
        context: The shared indexing of the problem, with its time coordinates and conditions.

    Returns:
        The electric vehicles' arrays.

    """
    return ElectricVehicleArrays(
        battery=vectorize(BatteryArrays, [ev.battery for ev in electric_vehicles], coordinates),
        states=_battery_state_arrays(
            ElectricVehicleInitialState,
            ElectricVehicleFinalState,
            electric_vehicles,
            coordinates,
            context,
        ),
        trips=_trip_arrays(electric_vehicles, coordinates, context),
    )

def flexible_load_state_arrays(
    loads: Sequence[FlexibleLoad],
    coordinates: Coordinates,
    context: ModelContext,
) -> FlexibleLoadStateArrays:
    """Build the flexible loads' initial consumption and their on/off states.

    A load without a commitment gets `Commitment()` here, so every load has an on/off state; it is always on.

    Args:
        loads: The flexible loads, in coordinate order.
        coordinates: The labels of the loads along the flexible load dimension.
        context: The shared indexing of the problem, with its horizon and conditions.

    Returns:
        The flexible loads' state arrays.

    """
    initial_power = context.conditions(
        FlexibleLoadInitialState,
        loads,
        coordinates,
        lambda state: state.power,
        default=0.0,
    )
    is_switchable = xr.DataArray(
        [load.commitment is not None for load in loads],
        dims=coordinates.dimension,
        coords=coordinates.dimension_coordinates_map,
    )
    initial_steps_in_state = context.conditions(
        FlexibleLoadInitialState,
        loads,
        coordinates,
        lambda state: _steps_in_state(state.time_in_state, context.horizon),
        default=np.inf,
    )
    return FlexibleLoadStateArrays(
        initial_power=initial_power,
        is_switchable=is_switchable,
        commitment=commitment_state_arrays(
            [load.commitment or Commitment() for load in loads],
            coordinates,
            context.horizon,
            initially_on=~is_switchable | (initial_power > 0),
            initial_steps_in_state=initial_steps_in_state,
        ),
    )

def generator_state_arrays(
    generators: Sequence[Generator],
    coordinates: Coordinates,
    context: ModelContext,
) -> GeneratorStateArrays:
    """Build the generators' initial and final power and their on/off states.

    Args:
        generators: The generators, in coordinate order.
        coordinates: The labels of the generators along the generator dimension.
        context: The shared indexing of the problem, with its horizon and conditions.

    Returns:
        The generators' state arrays.

    """
    initial_power = context.conditions(
        GeneratorInitialState,
        generators,
        coordinates,
        lambda state: state.power,
        default=0.0,
    )
    initial_steps_in_state = context.conditions(
        GeneratorInitialState,
        generators,
        coordinates,
        lambda state: _steps_in_state(state.time_in_state, context.horizon),
        default=np.inf,
    )
    return GeneratorStateArrays(
        initial_power=initial_power,
        final_power=context.conditions(
            GeneratorFinalState,
            generators,
            coordinates,
            lambda state: state.power,
            default=np.nan,
        ),
        commitment=commitment_state_arrays(
            [generator.commitment for generator in generators],
            coordinates,
            context.horizon,
            initially_on=initial_power > 0,
            initial_steps_in_state=initial_steps_in_state,
        ),
    )