NREL-erad 0.0.0a0__py3-none-any.whl → 0.1.1__py3-none-any.whl

erad/default_fragility_curves/default_peak_ground_velocity.py

@@ -0,0 +1,94 @@
+import erad.models.fragility_curve as frag
+from erad.enums import AssetTypes
+from erad.quantities import Speed
+
+DEFAULT_PEAK_GROUND_VELOCITY_FRAGILITY_CURVES = frag.HazardFragilityCurves(
+    asset_state_param="peak_ground_velocity",
+    curves=[
+        frag.FragilityCurve(
+            asset_type=AssetTypes.switch,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.5, "cm/s"), Speed(35, "cm/s"), 2]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.battery_storage,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.5, "cm/s"), Speed(35, "cm/s"), 2]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.distribution_junction_box,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.5, "cm/s"), Speed(35, "cm/s"), 2]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.distribution_overhead_lines,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.5, "cm/s"), Speed(40, "cm/s"), 2]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.distribution_poles,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.5, "cm/s"), Speed(40, "cm/s"), 2]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.distribution_underground_cables,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.5, "cm/s"), Speed(60, "cm/s"), 2]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.solar_panels,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.5, "cm/s"), Speed(35, "cm/s"), 2]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.substation,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.5, "cm/s"), Speed(50, "cm/s"), 2]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.transformer_mad_mount,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.5, "cm/s"), Speed(35, "cm/s"), 2]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.transformer_pole_mount,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.5, "cm/s"), Speed(40, "cm/s"), 2]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.transmission_junction_box,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.5, "cm/s"), Speed(50, "cm/s"), 2]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.transmission_overhead_lines,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.5, "cm/s"), Speed(45, "cm/s"), 2]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.transmission_tower,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.5, "cm/s"), Speed(35, "cm/s"), 2]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.transmission_underground_cables,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm",
+                parameters=[Speed(0.55, "cm/s"), Speed(65, "cm/s"), 1 / 0.55],
+            ),
+        ),
+    ],
+)

erad/default_fragility_curves/default_wind_speed.py

@@ -0,0 +1,94 @@
+import erad.models.fragility_curve as frag
+from erad.enums import AssetTypes
+from erad.quantities import Speed
+
+
+DEFAULT_WIND_SPEED_FRAGILITY_CURVES = frag.HazardFragilityCurves(
+    asset_state_param="wind_speed",
+    curves=[
+        frag.FragilityCurve(
+            asset_type=AssetTypes.switch,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.45, "m/s"), Speed(50, "m/s"), 1 / 0.45]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.battery_storage,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.45, "m/s"), Speed(50, "m/s"), 1 / 0.45]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.distribution_junction_box,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.4, "m/s"), Speed(50, "m/s"), 1 / 0.4]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.distribution_overhead_lines,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.35, "m/s"), Speed(45, "m/s"), 1 / 0.35]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.distribution_poles,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.4, "m/s"), Speed(45, "m/s"), 1 / 0.4]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.distribution_underground_cables,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.4, "m/s"), Speed(55, "m/s"), 1 / 0.4]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.solar_panels,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.3, "m/s"), Speed(55, "m/s"), 1 / 0.3]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.substation,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.4, "m/s"), Speed(55, "m/s"), 1 / 0.40]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.transformer_mad_mount,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.35, "m/s"), Speed(50, "m/s"), 1 / 0.35]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.transformer_pole_mount,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.3, "m/s"), Speed(45, "m/s"), 1 / 0.30]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.transmission_junction_box,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.54, "m/s"), Speed(55, "m/s"), 1 / 0.54]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.transmission_overhead_lines,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.35, "m/s"), Speed(50, "m/s"), 1 / 0.35]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.transmission_tower,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.4, "m/s"), Speed(55, "m/s"), 1 / 0.40]
+            ),
+        ),
+        frag.FragilityCurve(
+            asset_type=AssetTypes.transmission_underground_cables,
+            prob_function=frag.ProbabilityFunction(
+                distribution="lognorm", parameters=[Speed(0.4, "m/s"), Speed(60, "m/s"), 1 / 0.40]
+            ),
+        ),
+    ],
+)

erad/enums.py

@@ -0,0 +1,40 @@
+from enum import IntEnum
+
+
+class ScenarioTypes(IntEnum):
+    flood_m = 0
+    wind_m_per_s = 1
+    fire_m = 2
+    earthquake_pga = 3
+
+
+class NodeTypes(IntEnum):
+    transmission_tower = 5
+    distribution_poles = 6
+    transmission_junction_box = 11
+    distribution_junction_box = 12
+
+
+class AssetTypes(IntEnum):
+    substation = 0
+    solar_panels = 1
+    distribution_underground_cables = 2
+    transmission_underground_cables = 3
+    battery_storage = 4
+    transmission_tower = 5
+    distribution_poles = 6
+    transmission_overhead_lines = 7
+    distribution_overhead_lines = 8
+    transformer_mad_mount = 9
+    transformer_pole_mount = 10
+    transmission_junction_box = 11
+    distribution_junction_box = 12
+    switch = 13
+
+    @classmethod
+    def has_value(cls, value):
+        return value in cls._value2member_map_
+
+    @classmethod
+    def has_asset(cls, asset):
+        return asset in cls.__members__

erad/gdm_mapping.py

@@ -0,0 +1,83 @@
+import gdm.distribution.components as gdc
+import gdm.distribution.equipment as gde
+
+from erad.enums import AssetTypes
+from erad.models.asset_mapping import ComponentFilterModel
+
+
+asset_to_gdm_mapping = {
+    AssetTypes.switch: [
+        ComponentFilterModel(
+            component_type=gdc.DistributionSwitchBase,
+        ),
+    ],
+    AssetTypes.switch: [
+        ComponentFilterModel(
+            component_type=gdc.DistributionSwitchBase,
+        ),
+    ],
+    AssetTypes.substation: [
+        ComponentFilterModel(
+            component_type=gdc.DistributionVoltageSource,
+        ),
+    ],
+    AssetTypes.solar_panels: [
+        ComponentFilterModel(
+            component_type=gdc.DistributionSolar,
+        ),
+    ],
+    AssetTypes.battery_storage: [
+        ComponentFilterModel(
+            component_type=gdc.DistributionBattery,
+        ),
+    ],
+    AssetTypes.distribution_underground_cables: [
+        ComponentFilterModel(
+            component_type=gdc.GeometryBranch,
+            component_filter=lambda x: x.equipment.conductors[0].__class__
+            == gde.ConcentricCableEquipment
+            and x.buses[0].rated_voltage.to("kilovolt").magnitude < 35.0,
+        ),
+        ComponentFilterModel(
+            component_type=gdc.MatrixImpedanceBranch,
+            component_filter=lambda x: x.equipment.c_matrix[0, 0]
+            .to("microfarad/kilometer")
+            .magnitude
+            > 0.05
+            and x.buses[0].rated_voltage.to("kilovolt").magnitude < 35.0,
+        ),
+    ],
+    AssetTypes.distribution_overhead_lines: [
+        ComponentFilterModel(
+            component_type=gdc.GeometryBranch,
+            component_filter=lambda x: (
+                x.equipment.conductors[0].__class__ == gde.BareConductorEquipment
+            )
+            and x.buses[0].rated_voltage.to("kilovolt").magnitude < 35.0,
+        ),
+        ComponentFilterModel(
+            component_type=gdc.MatrixImpedanceBranch,
+            component_filter=lambda x: x.equipment.c_matrix[0, 0]
+            .to("microfarad/kilometer")
+            .magnitude
+            < 0.05
+            and x.buses[0].rated_voltage.to("kilovolt").magnitude < 35.0,
+        ),
+    ],
+    AssetTypes.transmission_underground_cables: [
+        ComponentFilterModel(
+            component_type=gdc.GeometryBranch,
+            component_filter=lambda x: x.equipment.conductors[0].__class__
+            == gde.ConcentricCableEquipment
+            and x.buses[0].rated_voltage.to("kilovolt").magnitude > 35.0,
+        ),
+    ],
+    AssetTypes.transmission_overhead_lines: [
+        ComponentFilterModel(
+            component_type=gdc.GeometryBranch,
+            component_filter=lambda x: x.equipment.conductors[0].__class__
+            == gde.BareConductorEquipment
+            and x.buses[0].rated_voltage.to("kilovolt").magnitude > 35.0,
+        ),
+    ],
+}

erad/models/__init__.py

@@ -0,0 +1 @@
+

erad/models/asset.py

@@ -0,0 +1,300 @@
+from datetime import datetime
+from uuid import UUID
+import math
+
+from pydantic import computed_field, Field
+from infrasys.quantities import Distance
+from geopy.distance import geodesic
+from shapely.geometry import Point
+from pyhigh import get_elevation
+from infrasys import Component
+from loguru import logger
+
+# from erad.constants import RASTER_DOWNLOAD_PATH
+from erad.quantities import Acceleration, Speed
+from erad.models.probability import (
+    AccelerationProbability,
+    DistanceProbability,
+    SpeedProbability,
+)
+from erad.enums import AssetTypes
+import erad.models.hazard as hz
+
+
+class AssetState(Component):
+    name: str = ""
+    timestamp: datetime
+    wind_speed: SpeedProbability | None = None
+    flood_velocity: SpeedProbability | None = None
+    flood_depth: DistanceProbability | None = None
+    fire_boundary_dist: DistanceProbability | None = None
+    peak_ground_velocity: SpeedProbability | None = None
+    peak_ground_acceleration: AccelerationProbability | None = None
+
+    def calculate_earthquake_vectors(
+        self, asset_coordinate: Point, hazard_model: hz.EarthQuakeModel
+    ):
+        """
+        Sources:
+
+        Atkinson, G.M., & Wald, D.J. (2007). “Did You Feel It?” intensity data: A surprisingly good
+        measure of earthquake ground motion. Seismological Research Letters, 78(3), 362–368.
+        """
+
+        epicenter_distance = Distance(
+            geodesic(
+                (hazard_model.origin.y, hazard_model.origin.x),
+                (asset_coordinate.y, asset_coordinate.x),
+            ).km,
+            "km",
+        )
+
+        hypocentral_distance = (hazard_model.depth**2 + epicenter_distance**2) ** 0.5
+
+        mmi = (
+            3.31
+            + 1.28 * hazard_model.magnitude
+            - 1.42 * math.log10(hypocentral_distance.to("km").magnitude)
+        )  # Modified Mercalli Intensity
+
+        log_pgv = (mmi - 3.78) / 1.47
+        pgv = 10**log_pgv  # cm/s
+        self.peak_ground_velocity = SpeedProbability(
+            speed=Speed(pgv, "centimeter/second"),
+            survival_probability=1,
+        )
+
+        log_pga = (mmi - 1.78) / 3.70
+        pga_per_g = 10**log_pga  # % of g
+        self.peak_ground_acceleration = AccelerationProbability(
+            acceleration=Acceleration(pga_per_g / 100.0 * 9.80665, "meter/second**2"),
+            survival_probability=1,
+        )
+
+    def calculate_fire_vectors(self, asset_coordinate: Point, hazard_model: hz.FireModel):
+        """
+        Sources:
+
+        “Integrating Wildfire Risk Modeling with Electric Grid Asset Management” (EPRI)
+        “Modeling and Mitigating Wildfire Risk to the Power Grid” (PNNL, 2021)
+        “A Framework for Assessing Wildfire Ignition Risk on Distribution Systems”
+            (IEEE Transactions on Power Systems, 2020)
+        Improving Grid Safety and Resilience to Mitigate Ignition Incident and Fire Risks – EPRI
+        Wildfire Risk Reduction Methods 2024 – EPRI
+        """
+
+        distances_to_wild_fire_boundaries = []
+        for wild_fire_area in hazard_model.affected_areas:
+            if wild_fire_area.affected_area.contains(asset_coordinate):
+                distance = 0
+            else:
+                distance = wild_fire_area.affected_area.exterior.distance(asset_coordinate)
+            distances_to_wild_fire_boundaries.append(distance)
+        minimum_distance_km = min(distances_to_wild_fire_boundaries)
+        self.fire_boundary_dist = DistanceProbability(
+            distance=Distance(minimum_distance_km, "kilometer"),
+            survival_probability=1,
+        )
+
+        # survival_probability = 1 - 0.95 * math.exp(-k * minimum_distance_km)
+
+    def calculate_wind_vectors(self, asset_coordinate: Point, hazard_model: hz.WindModel):
+        r = Distance(
+            geodesic(
+                (hazard_model.center.y, hazard_model.center.x),
+                (asset_coordinate.y, asset_coordinate.x),
+            ).km,
+            "km",
+        )
+
+        r = r.to("nautical_mile")
+        r_max = hazard_model.radius_of_closest_isobar.to("nautical_mile")
+        r_v_max = hazard_model.radius_of_max_wind.to("nautical_mile")
+        v_max = hazard_model.max_wind_speed.to("knot")
+
+        k = 1.14
+        b = 10
+
+        a = math.log(b) / (r_max - r_v_max)
+        m = (1 / r_v_max) * math.log(k / (k + 1))
+
+        if r >= 0 and r < r_v_max:
+            wind_speed = k * v_max * (1 - math.exp(-m * r))
+        elif r >= r_v_max and r < r_max:
+            wind_speed = v_max * math.exp(-a * (r - r_v_max))
+        else:
+            wind_speed = 0
+
+        self.wind_speed = SpeedProbability(
+            speed=wind_speed.to("miles/hour"),
+            survival_probability=1,
+        )
+
+    def calculate_flood_vectors(
+        self, asset_coordinate: Point, hazard_model: hz.FloodModel, asset_total_elevation: Distance
+    ):
+        for area in hazard_model.affected_areas:
+            if area.affected_area.contains(asset_coordinate):
+                self.flood_depth = DistanceProbability(
+                    distance=area.water_elevation - asset_total_elevation,
+                    survival_probability=1,
+                )
+                self.flood_velocity = SpeedProbability(
+                    speed=area.water_velocity,
+                    survival_probability=1,
+                )
+
+        if self.flood_depth is None and self.flood_velocity is None:
+            self.flood_depth = DistanceProbability(
+                distance=Distance(-9999, "meter"),
+                survival_probability=1,
+            )
+            self.flood_velocity = SpeedProbability(
+                speed=Speed(0, "meter / second"),
+                survival_probability=1,
+            )
+
+    @computed_field
+    @property
+    def survival_probability(self) -> float:
+        wind_survival_probability = self.wind_speed.survival_probability if self.wind_speed else 1
+        water_flow_survival_probability = (
+            self.flood_velocity.survival_probability if self.flood_velocity else 1
+        )
+        water_level_survivial_probability = (
+            self.flood_depth.survival_probability if self.flood_depth else 1
+        )
+        fire_survival_probability = (
+            self.fire_boundary_dist.survival_probability if self.fire_boundary_dist else 1
+        )
+        pgv_survival_probability = (
+            self.peak_ground_velocity.survival_probability if self.peak_ground_velocity else 1
+        )
+        pga_survival_probability = (
+            self.peak_ground_acceleration.survival_probability
+            if self.peak_ground_acceleration
+            else 1
+        )
+
+        return (
+            wind_survival_probability
+            * water_flow_survival_probability
+            * water_level_survivial_probability
+            * fire_survival_probability
+            * pgv_survival_probability
+            * pga_survival_probability
+        )
+
+    @classmethod
+    def example(cls) -> "AssetState":
+        return AssetState(
+            timestamp=datetime.now(),
+            wind_speed=SpeedProbability.example(),
+            flood_velocity=SpeedProbability.example(),
+            flood_depth=DistanceProbability.example(),
+            fire_boundary_dist=DistanceProbability.example(),
+            peak_ground_velocity=SpeedProbability.example(),
+            peak_ground_acceleration=AccelerationProbability.example(),
+        )
+
+
+class Asset(Component):
+    distribution_asset: UUID = Field(..., description="UUID of the distribution asset")
+    connections: list[UUID] = Field([], description="List of UUIDs of connected assets")
+    devices: list[UUID] = Field(
+        [], description="List of UUIDs of devices associated with the asset"
+    )
+    asset_type: AssetTypes = Field(..., description="Type of the asset")
+    height: Distance = Field(..., description="Height of the asset")
+    latitude: float = Field(..., ge=-90, le=90, description="Latitude in degrees")
+    longitude: float = Field(..., ge=-180, le=180, description="Longitude in degrees")
+    asset_state: list[AssetState] = Field(
+        ..., description="List of asset states associated with the asset"
+    )
+    _raster_handler: str | None = None
+
+    @computed_field
+    @property
+    def elevation(self) -> Distance:
+        try:
+            elev = Distance(get_elevation(lat=self.latitude, lon=self.longitude), "meter")
+        except Exception:
+            logger.warning(
+                f"Error getting elevation information for asset {self.name} with coordinates {self.latitude}, {self.longitude}. Defaulting to 999 meters"
+            )
+            elev = Distance(999, "meter")
+        return elev
+
+    def _get_asset_state_at_timestamp(self, timestamp: datetime) -> AssetState | None:
+        for asset_state in self.asset_state:
+            if asset_state.timestamp == timestamp:
+                return asset_state
+        return AssetState(
+            timestamp=timestamp,
+        )
+
+    def update_survival_probability(
+        self, time_stamp: datetime, hazard_model: hz.BaseDisasterModel, frag_curves
+    ):
+        asset_state = self._get_asset_state_at_timestamp(time_stamp)
+        asset_location = Point(self.longitude, self.latitude)
+
+        if isinstance(hazard_model, hz.EarthQuakeModel):
+            asset_state.calculate_earthquake_vectors(asset_location, hazard_model)
+        elif isinstance(hazard_model, hz.FireModel):
+            asset_state.calculate_fire_vectors(asset_location, hazard_model)
+        elif isinstance(hazard_model, hz.WindModel):
+            asset_state.calculate_wind_vectors(asset_location, hazard_model)
+        elif isinstance(hazard_model, hz.FloodModel):
+            asset_state.calculate_flood_vectors(
+                asset_location, hazard_model, self.elevation + self.height
+            )
+        else:
+            raise (f"Unsupported hazard type {hazard_model.__class__.__name__}")
+
+        self.calculate_probabilities(asset_state, frag_curves)
+        if asset_state not in self.asset_state:
+            self.asset_state.append(asset_state)
+        return asset_state
+
+    def calculate_probabilities(self, asset_state: AssetState, frag_curves):
+        fields = [
+            model_field
+            for model_field in list(asset_state.model_fields.keys())
+            if model_field not in ["uuid", "name", "timestamp"]
+        ]
+        for field in fields:
+            prob_model = getattr(asset_state, field)
+            if prob_model and prob_model.survival_probability == 1:
+                curve = self.get_vadid_curve(frag_curves, field)
+                if curve is None:
+                    raise Exception(f"No fragility curve found for field - {field}")
+                prob_inst = curve.prob_model
+                quantity_name = [
+                    model_field
+                    for model_field in list(prob_model.model_fields.keys())
+                    if model_field not in ["uuid", "name", "survival_probability"]
+                ][0]
+                quantity = getattr(prob_model, quantity_name)
+                prob_model.survival_probability = 1 - prob_inst.probability(quantity)
+
+    def get_vadid_curve(self, frag_curves, field: SyntaxError) -> float:
+        for frag_curve in frag_curves:
+            if frag_curve.asset_state_param == field:
+                for curve in frag_curve.curves:
+                    if curve.asset_type == self.asset_type:
+                        return curve.prob_function
+
+        return None
+
+    @classmethod
+    def example(cls) -> "Asset":
+        return Asset(
+            name="Asset 1",
+            asset_type=AssetTypes.distribution_poles,
+            distribution_asset=UUID("123e4567-e89b-12d3-a456-426614174000"),
+            height=Distance(100, "m"),
+            latitude=37.7749,
+            longitude=-122.4194,
+            asset_state=[AssetState.example()],
+        )

erad/models/asset_mapping.py

@@ -0,0 +1,20 @@
+from typing import Type, Callable
+
+from pydantic import BaseModel, ConfigDict
+from infrasys import Component
+
+from erad.enums import AssetTypes
+
+
+class BaseEradScenarioModel(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, extra="forbid")
+
+
+class ComponentFilterModel(BaseEradScenarioModel):
+    component_type: Type[Component]
+    component_filter: Callable | None = None
+
+
+class AssetComponentMap(BaseEradScenarioModel):
+    asset_type: AssetTypes
+    filters: list[ComponentFilterModel] = []

erad/models/edit_store.py

@@ -0,0 +1,22 @@
+from pathlib import Path
+import json
+
+from pydantic import BaseModel
+
+from gdm.tracked_changes import TrackedChange
+
+
+class EditStore(BaseModel):
+    updates: list[TrackedChange] = []
+
+    def to_json(self, filename: Path):
+        filename = Path(filename)
+        with open(filename, "w") as f:
+            f.write(self.model_dump_json(indent=4))
+
+    @classmethod
+    def from_json(cls, filename: Path):
+        filename = Path(filename)
+        with open(filename) as f:
+            data = json.load(f)
+            return EditStore(**data)