increased performance of some of SARDI computation and removed the ne…

…ed to compute transformer related sardi metrics

emerge/cli/custom_metrics.py

@@ -14,7 +14,6 @@
 from emerge.simulator import simulation_manager
 from emerge.metrics import node_voltage_stats
 from emerge.metrics import line_loading_stats
-from emerge.metrics import xfmr_loading_stats
 
 
 def get_observers(metrics: Dict):
@@ -28,13 +27,9 @@ def get_observers(metrics: Dict):
         'node_voltage_bins': node_voltage_stats.NodeVoltageBins,
         'line_loading_stats': line_loading_stats.LineLoadingStats,
         'line_loading_bins': line_loading_stats.LineLoadingBins,
-        'xfmr_loading_stats': xfmr_loading_stats.XfmrLoadingStats,
-        'xfmr_loading_bins': xfmr_loading_stats.XfmrLoadingBins,
         'overloaded_lines': line_loading_stats.OverloadedLines,
-        'overloaded_transformers': xfmr_loading_stats.OverloadedTransformers,
         'sardi_voltage': system_metrics.SARDI_voltage,
         'sardi_line': system_metrics.SARDI_line,
-        'sardi_xfmr': system_metrics.SARDI_transformer,
         'sardi_aggregated': system_metrics.SARDI_aggregated
     }
 

emerge/cli/get_observers.py

@@ -7,7 +7,6 @@
 from emerge.metrics import system_metrics
 from emerge.metrics import node_voltage_stats
 from emerge.metrics import line_loading_stats
-from emerge.metrics import xfmr_loading_stats
 
 
 CLASS_MAPPER = {
@@ -19,13 +18,9 @@
         'node_voltage_bins': node_voltage_stats.NodeVoltageBins,
         'line_loading_stats': line_loading_stats.LineLoadingStats,
         'line_loading_bins': line_loading_stats.LineLoadingBins,
-        'xfmr_loading_stats': xfmr_loading_stats.XfmrLoadingStats,
-        'xfmr_loading_bins': xfmr_loading_stats.XfmrLoadingBins,
         'overloaded_lines': line_loading_stats.OverloadedLines,
-        'overloaded_transformers': xfmr_loading_stats.OverloadedTransformers,
         'sardi_voltage': system_metrics.SARDI_voltage,
         'sardi_line': system_metrics.SARDI_line,
-        'sardi_xfmr': system_metrics.SARDI_transformer,
         'sardi_aggregated': system_metrics.SARDI_aggregated
     }
 

emerge/cli/nodal_hosting_capacity.py

@@ -25,8 +25,8 @@
 from emerge.cli.nodal_hosting_sqlite_tables import (
     HostingCapacityReport, 
     OverloadedLinesReport, 
-    OverloadedTransformersReport, 
-    SimulationConvergenceReport, 
+    SimulationConvergenceReport,
+    SimulationTime, 
     TotalEnergyReport, 
     create_table,
     get_engine
@@ -35,12 +35,10 @@
 from emerge.metrics.system_metrics import (
     SARDI_aggregated, 
     SARDI_line, 
-    SARDI_transformer, 
     SARDI_voltage, 
     TotalEnergy, 
     TotalPVGeneration
 )
-from emerge.metrics.xfmr_loading_stats import OverloadedTransformers
 from emerge.simulator.simulation_manager import OpenDSSSimulationManager
 
 class BasicSimulationSettings(BaseModel):
@@ -75,29 +73,23 @@ def __init__(self):
         self.sardi_agg = SARDI_aggregated()
         self.sardi_voltage = SARDI_voltage()
         self.sardi_line = SARDI_line()
-        self.sardi_xfmr = SARDI_transformer()
         self.solar_generation = TotalPVGeneration()
         self.ol_lines = OverloadedLines()
-        self.ol_xmfrs = OverloadedTransformers()
         self.circuit_energy = TotalEnergy()
         self.export_energy = TotalEnergy(export_only=True)
 
-        for obs in [self.sardi_agg, self.sardi_voltage, self.sardi_line, self.sardi_xfmr, 
-            self.solar_generation, self.ol_lines, self.ol_xmfrs, self.circuit_energy, self.export_energy]:
+        for obs in [self.sardi_agg, self.sardi_voltage, self.sardi_line,  
+            self.solar_generation, self.ol_lines, self.circuit_energy, self.export_energy]:
             self.subject.attach(obs)
 
     def is_hosting_capacity_reached(self) -> bool:
         """ Method to check if hosting capacity is reached."""
-        return self.get_sardi_aggregated() > 0 or self.get_total_export_energy() !=0
+        return self.get_sardi_aggregated() > 0 or self.get_total_export_energy() !=0 # uncomment for reverse power flow
 
     def get_subject(self) -> observer.MetricsSubject:
         """ Return subject container containing observers."""
         return self.subject 
 
-    def get_overloaded_xfmr_loadings(self) -> dict[str, list[float]]:
-        """ Return overloaded transformers."""
-        return self.ol_xmfrs.get_metric()
-
     def get_overloaded_line_loadings(self) -> dict[str, list[float]]:
         """Returns overloaded lines."""
         return self.ol_lines.get_metric()
@@ -114,10 +106,6 @@ def get_sardi_line(self):
         """ Method to return SARDI line metric. """
         return pl.from_dict(self.sardi_line.get_metric())['sardi_line'].to_list()[0]
 
-    def get_sardi_transformer(self):
-        """ Method to return SARDI transformer metric. """
-        return pl.from_dict(self.sardi_xfmr.get_metric())['sardi_transformer'].to_list()[0]
-
     def get_solar_total_energy(self):
         """ Method to return total solar energy. """
         return pl.from_dict(self.solar_generation.get_metric())['active_power'].to_list()[0]
@@ -144,7 +132,7 @@ def compute_hosting_capacity(config: SingleNodeHostingCapacityInput,
     engine = get_engine(sqlite_file)
 
     for capacity in np.arange(config.step_kw, config.max_kw, config.step_kw):
-
+        
         opendss_instance = opendss.OpenDSSSimulator(config.master_dss_file)
         opendss_instance.dss_instance.Circuit.SetActiveBus(bus)
         bus_kv = round(opendss_instance.dss_instance.Bus.kVBase()*math.sqrt(3), 2)
@@ -175,7 +163,6 @@ def compute_hosting_capacity(config: SingleNodeHostingCapacityInput,
         logger.info(f"Node finished {bus}, " 
                     f"elpased time {end_time - start_time} seconds")
 
-
         with Session(engine) as session:
             for timestamp, conv_ in zip(sim_manager.convergence_dict['datetime'], 
                                         sim_manager.convergence_dict['convergence']):
@@ -185,6 +172,12 @@ def compute_hosting_capacity(config: SingleNodeHostingCapacityInput,
                     capacity_kw=capacity,
                     timestamp=timestamp
                 ))
+
+            session.add(SimulationTime(
+                node_name=bus,
+                capacity=capacity,
+                compute_sec=(end_time - start_time)
+            ))
 
             session.add(TotalEnergyReport(
                 node_name=bus,
@@ -204,18 +197,8 @@ def compute_hosting_capacity(config: SingleNodeHostingCapacityInput,
                     )
                 )
 
-            for ol_xfmr, loadings in report_instance.get_overloaded_xfmr_loadings().items():
-                session.add(
-                    OverloadedTransformersReport(
-                    start_time=config.start_time,
-                    resolution_min=config.resolution_min,
-                    node_name=bus,
-                    xfmr_name=ol_xfmr,
-                    loadings=str(loadings)
-                    )
-                )
             session.commit()
-        
+
         if report_instance.is_hosting_capacity_reached() > 0:
             break
 
@@ -229,7 +212,6 @@ def compute_hosting_capacity(config: SingleNodeHostingCapacityInput,
             sardi_voltage=report_instance.get_sardi_voltage(),
             sardi_aggregated=report_instance.get_sardi_aggregated(),
             sardi_line=report_instance.get_sardi_line(),
-            sardi_transformer=report_instance.get_sardi_transformer()
         ))
         session.commit()
 
@@ -254,6 +236,7 @@ def nodal_hosting_analysis(
     """Run multiscenario time series simulation and compute
     time series metrics."""
 
+    analysis_start_time = time.time()
     with open(config, "r", encoding="utf-8") as file:
         config_dict = json.load(file)
 
@@ -267,6 +250,9 @@ def nodal_hosting_analysis(
 
     create_table(config.export_sqlite_path)
 
+    # buses = ["86690a2f-1860-4367-b93f-6a7052b390e8"]
+    buses = ["802b3d17-08f4-4a70-b254-9ca4f233595c"]
+
     num_core = get_num_core.get_num_core(config.num_core, len(buses))
     with multiprocessing.Pool(int(num_core)) as pool:
         data_to_process = [
@@ -276,4 +262,7 @@ def nodal_hosting_analysis(
              config.export_sqlite_path
             ] for bus in buses
         ]
-        pool.map(_compute_hosting_capacity, data_to_process)
+        pool.map(_compute_hosting_capacity, data_to_process)
+    analysis_end_time = time.time()
+    print(f"Required time: {analysis_end_time - analysis_start_time} seconds, num_core={num_core}")
+

emerge/cli/nodal_hosting_sqlite_tables.py

@@ -12,9 +12,14 @@ class HostingCapacityReport(SQLModel, table=True):
     hosting_capacity_kw: float
     sardi_voltage: float 
     sardi_line: float 
-    sardi_transformer: float 
     sardi_aggregated: float
 
+class SimulationTime(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    node_name: str 
+    capacity: float 
+    compute_sec: float
+
 
 class SimulationConvergenceReport(SQLModel, table=True):
     id: Optional[int] = Field(default=None, primary_key=True)
@@ -39,14 +44,6 @@ class OverloadedLinesReport(SQLModel, table=True):
     line_name: str 
     loadings: str
 
-class OverloadedTransformersReport(SQLModel, table=True):
-    id: Optional[int] = Field(default=None, primary_key=True)
-    start_time: datetime 
-    resolution_min: int
-    node_name: str 
-    xfmr_name: str 
-    loadings: str
-
 def get_engine(sqlite_file: Path):
     return create_engine(f"sqlite:///{str(sqlite_file)}")
 

emerge/metrics/line_loading_stats.py

@@ -10,10 +10,7 @@
 from emerge.simulator import powerflow_results
 
 def get_line_loading_df(dss_instance:dss):
-    return polars.from_pandas(
-            powerflow_results.get_lineloading_dataframe(
-            dss_instance
-        ))
+    return powerflow_results.get_loading_dataframe()
 
 class OverloadedLines(observer.MetricObserver):
     """Class for computing time series loading metrics for lines."""
@@ -23,8 +20,8 @@ def __init__(self):
 
     def compute(self, dss_instance: dss) -> None:
 
-        df = powerflow_results.get_lineloading_dataframe(dss_instance)
-        loading_dict = dict(zip(df.index, df["loading(pu)"]))
+        df = powerflow_results.get_loading_dataframe()
+        loading_dict = dict(zip(df["branch"], df["loading(pu)"]))
         if len(self.metrics) == 0:
             self.metrics = {key: [] for key in loading_dict}
 

emerge/metrics/observer.py

@@ -1,6 +1,7 @@
 """ Module for managing metric computation subscriber and publisher. """
 
 import abc
+import time
 import uuid
 from typing import Dict, List
 import polars

emerge/metrics/snapshot_metrics.py

@@ -13,8 +13,7 @@
     get_voltage_by_distance,
     get_voltage_by_lat_lon,
     get_voltage_distribution,
-    get_lineloading_dataframe,
-    get_transloading_dataframe
+    get_loading_dataframe,
 )
 
 def compute_snapshot_metrics(
@@ -56,16 +55,10 @@ def compute_snapshot_metrics(
             "data":  voltage_by_lat_lon})
 
     """ line loading """
-    line_loading_df = get_lineloading_dataframe(opendss_instance.dss_instance)
+    line_loading_df = get_loading_dataframe(opendss_instance.dss_instance)
     db_instance.db.insert({
             "type": "snapshot_lineloading_for_heatmap", 
             "label": "peak_load", 
             "data":  line_loading_df.to_dict()['loading(pu)']})
 
-    """ transformer loading """
-    xfmr_loading_df = get_transloading_dataframe(opendss_instance.dss_instance)
-    db_instance.db.insert({
-            "type": "snapshot_xfmrloading_for_heatmap", 
-            "label": "peak_load", 
-            "data":  xfmr_loading_df.to_dict()['loading(pu)']})