feat: new PfS columns

src/libecalc/dto/components.py

@@ -300,6 +300,14 @@ class GeneratorSet(BaseEquipment):
             Field(discriminator="component_type"),
         ]
     ] = Field(default_factory=list)
+    cable_loss: Optional[ExpressionType] = Field(
+        None,
+        title="CABLE_LOSS",
+        description="Power loss in cables from shore. " "Used to calculate onshore delivery/power supply onshore.",
+    )
+    max_usage_from_shore: Optional[ExpressionType] = Field(
+        None, title="MAX_USAGE_FROM_SHORE", description="The peak load/effect that is expected for one hour, per year."
+    )
     _validate_genset_temporal_models = field_validator("generator_set_model", "fuel")(validate_temporal_model)
 
     @field_validator("user_defined_category", mode="before")

src/libecalc/fixtures/cases/ltp_export/data/sim/cable_loss.csv

@@ -0,0 +1,11 @@
+DATE,CABLE_LOSS_FACTOR
+01.01.2021,0.1
+01.01.2022,0.1
+01.01.2023,0.1
+01.01.2024,0.1
+01.01.2025,0.1
+01.01.2026,0.1
+01.01.2027,0.1
+01.01.2028,0.1
+01.01.2029,0.1
+01.01.2030,0.1

src/libecalc/fixtures/cases/ltp_export/ltp_power_from_shore_yaml.py

@@ -0,0 +1,92 @@
+from pathlib import Path
+
+import yaml
+
+from libecalc.common.time_utils import Frequency
+from libecalc.dto import Asset, ResultOptions, VariablesMap
+from libecalc.expression.expression import ExpressionType
+from libecalc.fixtures.cases.ltp_export import data
+from libecalc.presentation.yaml.mappers.variables_mapper import map_yaml_to_variables
+from libecalc.presentation.yaml.model import PyYamlYamlModel, YamlModel
+from libecalc.presentation.yaml.parse_input import map_yaml_to_dto
+
+
+def ltp_pfs_yaml_factory(
+    regularity: float,
+    cable_loss: ExpressionType,
+    max_usage_from_shore: ExpressionType,
+    load_direct_consumer: float,
+) -> [Asset, VariablesMap]:
+    input_text = f"""
+    START: 2025-01-01
+    END: 2030-01-01
+    TIME_SERIES:
+      - NAME: CABLE_LOSS
+        TYPE: DEFAULT
+        FILE: sim/cable_loss.csv
+    FACILITY_INPUTS:
+      - NAME: generator_energy_function
+        FILE: 'einput/genset_17MW.csv'
+        TYPE: ELECTRICITY2FUEL
+      - NAME: pfs_energy_function
+        FILE: 'einput/onshore_power.csv'
+        TYPE: ELECTRICITY2FUEL
+    FUEL_TYPES:
+      - NAME: fuel1
+        EMISSIONS:
+        - NAME: co2
+          FACTOR: 2
+        - NAME: ch4
+          FACTOR: 0.005
+        - NAME: nmvoc
+          FACTOR: 0.002
+        - NAME: nox
+          FACTOR: 0.001
+
+    INSTALLATIONS:
+    - NAME: minimal_installation
+      HCEXPORT: 0
+      FUEL: fuel1
+      CATEGORY: FIXED
+      REGULARITY: {regularity}
+      GENERATORSETS:
+      - NAME: generator1
+        ELECTRICITY2FUEL:
+          2025-01-01: generator_energy_function
+          2027-01-01: pfs_energy_function
+        CATEGORY:
+          2025-01-01: TURBINE-GENERATOR
+          2027-01-01: POWER-FROM-SHORE
+        CABLE_LOSS: {cable_loss}
+        MAX_USAGE_FROM_SHORE: {max_usage_from_shore}
+
+        CONSUMERS: # electrical energy consumers
+        - NAME: base_load
+          CATEGORY: BASE-LOAD
+          ENERGY_USAGE_MODEL:
+            TYPE: DIRECT
+            LOAD: {load_direct_consumer}
+
+
+    """
+
+    yaml_text = yaml.safe_load(input_text)
+    configuration = PyYamlYamlModel(
+        internal_datamodel=yaml_text,
+        instantiated_through_read=True,
+    )
+
+    path = Path(data.__path__._path[0])
+    resources = YamlModel._read_resources(yaml_configuration=configuration, working_directory=path)
+    variables = map_yaml_to_variables(
+        configuration,
+        resources=resources,
+        result_options=ResultOptions(
+            start=configuration.start,
+            end=configuration.end,
+            output_frequency=Frequency.YEAR,
+        ),
+    )
+
+    yaml_model = map_yaml_to_dto(configuration=configuration, resources=resources, name="test")
+    return yaml_model, variables

src/libecalc/presentation/exporter/configs/configs.py

@@ -20,6 +20,8 @@
     EmissionQuery,
     FuelConsumerPowerConsumptionQuery,
     FuelQuery,
+    MaxUsageFromShoreQuery,
+    PowerSupplyOnshoreQuery,
 )
 
 """
@@ -634,6 +636,22 @@ def aggregator(frequency: Frequency) -> Aggregator:
                         producer_categories=["POWER-FROM-SHORE"],
                     ),
                 ),
+                Applier(
+                    name="powerSupplyOnshore",
+                    title="Power Supply Onshore",
+                    unit=Unit.GIGA_WATT_HOURS,
+                    query=PowerSupplyOnshoreQuery(
+                        producer_categories=["POWER-FROM-SHORE"],
+                    ),
+                ),
+                Applier(
+                    name="fromShorePeakMaximum",
+                    title="Max Usage from Shore",
+                    unit=Unit.GIGA_WATT_HOURS,
+                    query=MaxUsageFromShoreQuery(
+                        producer_categories=["POWER-FROM-SHORE"],
+                    ),
+                ),
                 Applier(
                     name="steamTurbineGeneratorConsumption",
                     title="Total Electricity Consumed From Steam Turbine Generators",

src/libecalc/presentation/exporter/queries.py

@@ -6,15 +6,18 @@
 import libecalc.dto
 from libecalc.application.graph_result import GraphResult
 from libecalc.common.decorators.feature_flags import Feature
+from libecalc.common.list.list_utils import array_to_list
 from libecalc.common.temporal_model import TemporalExpression, TemporalModel
 from libecalc.common.time_utils import Frequency, resample_time_steps
 from libecalc.common.units import Unit
 from libecalc.common.utils.rates import (
     TimeSeriesFloat,
     TimeSeriesRate,
+    TimeSeriesStreamDayRate,
     TimeSeriesVolumes,
 )
 from libecalc.core.result import GeneratorSetResult
+from libecalc.expression import Expression
 
 
 class Query(abc.ABC):
@@ -308,6 +311,172 @@ def query(
         return aggregated_result_volume if aggregated_result_volume else None
 
 
+class PowerSupplyOnshoreQuery(Query):
+    """GenSet only (ie el producers)."""
+
+    def __init__(self, installation_category: Optional[str] = None, producer_categories: Optional[List[str]] = None):
+        self.installation_category = installation_category
+        self.producer_categories = producer_categories
+
+    def query(
+        self,
+        installation_graph: GraphResult,
+        unit: Unit,
+        frequency: Frequency,
+    ) -> Optional[Dict[datetime, float]]:
+        installation_dto = installation_graph.graph.get_node(installation_graph.graph.root)
+
+        installation_time_steps = installation_graph.timesteps
+        time_steps = resample_time_steps(
+            frequency=frequency,
+            time_steps=installation_time_steps,
+        )
+
+        regularity = TimeSeriesFloat(
+            timesteps=installation_time_steps,
+            values=TemporalExpression.evaluate(
+                temporal_expression=TemporalModel(installation_dto.regularity),
+                variables_map=installation_graph.variables_map,
+            ),
+            unit=Unit.NONE,
+        )
+
+        aggregated_result: DefaultDict[datetime, float] = defaultdict(float)
+        aggregated_result_volume = {}
+        unit_in = None
+
+        if self.installation_category is None or installation_dto.user_defined_category == self.installation_category:
+            for fuel_consumer in installation_dto.fuel_consumers:
+                if isinstance(fuel_consumer, libecalc.dto.GeneratorSet) and fuel_consumer.cable_loss is not None:
+                    temporal_category = TemporalModel(fuel_consumer.user_defined_category)
+                    for period, category in temporal_category.items():
+                        if self.producer_categories is None or category in self.producer_categories:
+                            fuel_consumer_result: GeneratorSetResult = installation_graph.get_energy_result(
+                                fuel_consumer.id
+                            )
+
+                            cable_loss = Expression.evaluate(
+                                fuel_consumer.cable_loss,
+                                variables=installation_graph.variables_map.variables,
+                                fill_length=len(installation_graph.variables_map.time_vector),
+                            )
+
+                            fuel_consumer_result.power.values = fuel_consumer_result.power.values * (1 + cable_loss)
+
+                            cumulative_volumes_gwh = (
+                                TimeSeriesRate.from_timeseries_stream_day_rate(
+                                    fuel_consumer_result.power, regularity=regularity
+                                )
+                                .for_period(period)
+                                .to_volumes()
+                            )
+
+                            unit_in = cumulative_volumes_gwh.unit
+
+                            for timestep, cumulative_volume_gwh in cumulative_volumes_gwh.datapoints():
+                                aggregated_result[timestep] += cumulative_volume_gwh
+
+            if aggregated_result:
+                sorted_result = dict(dict(sorted(zip(aggregated_result.keys(), aggregated_result.values()))).items())
+                sorted_result = {**dict.fromkeys(installation_time_steps, 0.0), **sorted_result}
+                date_keys = list(sorted_result.keys())
+
+                reindexed_result = (
+                    TimeSeriesVolumes(timesteps=date_keys, values=list(sorted_result.values())[:-1], unit=unit_in)
+                    .to_unit(Unit.GIGA_WATT_HOURS)
+                    .reindex(time_steps)
+                    .fill_nan(0)
+                )
+
+                aggregated_result_volume = {
+                    reindexed_result.timesteps[i]: reindexed_result.values[i] for i in range(len(reindexed_result))
+                }
+        return aggregated_result_volume if aggregated_result_volume else None
+
+
+class MaxUsageFromShoreQuery(Query):
+    """GenSet only (ie el producers)."""
+
+    def __init__(self, installation_category: Optional[str] = None, producer_categories: Optional[List[str]] = None):
+        self.installation_category = installation_category
+        self.producer_categories = producer_categories
+
+    def query(
+        self,
+        installation_graph: GraphResult,
+        unit: Unit,
+        frequency: Frequency,
+    ) -> Optional[Dict[datetime, float]]:
+        installation_dto = installation_graph.graph.get_node(installation_graph.graph.root)
+
+        installation_time_steps = installation_graph.timesteps
+        time_steps = resample_time_steps(
+            frequency=frequency,
+            time_steps=installation_time_steps,
+        )
+
+        regularity = TimeSeriesFloat(
+            timesteps=installation_time_steps,
+            values=TemporalExpression.evaluate(
+                temporal_expression=TemporalModel(installation_dto.regularity),
+                variables_map=installation_graph.variables_map,
+            ),
+            unit=Unit.NONE,
+        )
+
+        aggregated_result: DefaultDict[datetime, float] = defaultdict(float)
+        aggregated_result_volume = {}
+        unit_in = None
+
+        if self.installation_category is None or installation_dto.user_defined_category == self.installation_category:
+            for fuel_consumer in installation_dto.fuel_consumers:
+                if (
+                    isinstance(fuel_consumer, libecalc.dto.GeneratorSet)
+                    and fuel_consumer.max_usage_from_shore is not None
+                ):
+                    temporal_category = TemporalModel(fuel_consumer.user_defined_category)
+                    for period, category in temporal_category.items():
+                        if self.producer_categories is None or category in self.producer_categories:
+                            installation_graph.get_energy_result(fuel_consumer.id)
+
+                            max_usage_from_shore = TimeSeriesStreamDayRate(
+                                values=array_to_list(
+                                    Expression.evaluate(
+                                        fuel_consumer.max_usage_from_shore,
+                                        variables=installation_graph.variables_map.variables,
+                                        fill_length=len(installation_graph.variables_map.time_vector),
+                                    )
+                                ),
+                                unit=Unit.MEGA_WATT,
+                                timesteps=installation_graph.variables_map.time_vector,
+                            )
+
+                            results = TimeSeriesRate.from_timeseries_stream_day_rate(
+                                max_usage_from_shore, regularity=regularity
+                            ).for_period(period)
+
+                            unit_in = results.unit
+
+                            for timestep, result in results.datapoints():
+                                aggregated_result[timestep] += result
+
+            if aggregated_result:
+                sorted_result = dict(dict(sorted(zip(aggregated_result.keys(), aggregated_result.values()))).items())
+                sorted_result = {**dict.fromkeys(installation_time_steps, 0.0), **sorted_result}
+                date_keys = list(sorted_result.keys())
+
+                reindexed_result = (
+                    TimeSeriesVolumes(timesteps=date_keys, values=list(sorted_result.values())[:-1], unit=unit_in)
+                    .reindex(time_steps)
+                    .fill_nan(0)
+                )
+
+                aggregated_result_volume = {
+                    reindexed_result.timesteps[i]: reindexed_result.values[i] for i in range(len(reindexed_result))
+                }
+        return aggregated_result_volume if aggregated_result_volume else None
+
+
 class FuelConsumerPowerConsumptionQuery(Query):
     def __init__(self, consumer_categories: Optional[List[str]] = None, installation_category: Optional[str] = None):
         self.consumer_categories = consumer_categories

src/libecalc/presentation/yaml/mappers/component_mapper.py

@@ -6,7 +6,7 @@
 from libecalc import dto
 from libecalc.common.logger import logger
 from libecalc.common.time_utils import Period, define_time_model_for_period
-from libecalc.dto.base import ComponentType
+from libecalc.dto.base import ComponentType, ConsumerUserDefinedCategoryType
 from libecalc.dto.types import ConsumerType, ConsumptionType, EnergyModelType
 from libecalc.dto.utils.validators import convert_expression
 from libecalc.expression import Expression
@@ -216,6 +216,16 @@ def from_yaml_to_dto(
             )
             for consumer in data.get(EcalcYamlKeywords.consumers, [])
         ]
+        user_defined_category = define_time_model_for_period(
+            data.get(EcalcYamlKeywords.user_defined_tag), target_period=self._target_period
+        )
+        cable_loss = None
+        max_usage_from_shore = None
+
+        if ConsumerUserDefinedCategoryType.POWER_FROM_SHORE in user_defined_category.values():
+            cable_loss = convert_expression(data.get(EcalcYamlKeywords.cable_loss))
+            max_usage_from_shore = convert_expression(data.get(EcalcYamlKeywords.max_usage_from_shore))
+
         try:
             generator_set_name = data.get(EcalcYamlKeywords.name)
             return dto.GeneratorSet(
@@ -224,9 +234,9 @@ def from_yaml_to_dto(
                 regularity=regularity,
                 generator_set_model=generator_set_model,
                 consumers=consumers,
-                user_defined_category=define_time_model_for_period(
-                    data.get(EcalcYamlKeywords.user_defined_tag), target_period=self._target_period
-                ),
+                user_defined_category=user_defined_category,
+                cable_loss=cable_loss,
+                max_usage_from_shore=max_usage_from_shore,
             )
         except ValidationError as e:
             raise DtoValidationError(data=data, validation_error=e) from e

src/libecalc/presentation/yaml/yaml_keywords.py

@@ -63,6 +63,8 @@ class EcalcYamlKeywords:
     conditions = "CONDITIONS"
     consumers = "CONSUMERS"
     el2fuel = "ELECTRICITY2FUEL"
+    cable_loss = "CABLE_LOSS"
+    max_usage_from_shore = "MAX_USAGE_FROM_SHORE"
     emission_factor = "FACTOR"
     emissions = "EMISSIONS"
     energy_model = "ENERGYFUNCTION"