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

erad/metrics/metric.py

@@ -1,178 +1,178 @@
-""" Module for handling computation of equity and resilience metrics.
-
-Idea is to create separate function for computing each metric. 
-"""
-
-from pathlib import Path
-from typing import Callable, Union, Dict, List
-import json
-
-from neo4j import GraphDatabase
-import pandas as pd
-import numpy as np
-
-from erad.utils import util
-from erad import exceptions
-
-
-def validate_export_path(file_path: Union[str, Path], file_type: str):
-    """Function for validating the export file path.
-
-    Args:
-        file_path (Union[str, Path]): Export file path
-        file_type (str): File type to be exported e.g. .csv
-    """
-
-    output_path = Path(file_path)
-    util.path_validation(output_path.parent)
-    if output_path.suffix != file_type:
-        raise exceptions.InvalidFileTypePassed(output_path, file_type)
-
-
-def is_customer_getting_power(
-    driver: GraphDatabase.driver, output_csv_path: str,
-    load_list: List[str] = None
-):
-
-    """Function for checking whether customer is still connected
-    to substation or not.
-
-    Args:
-        driver (GraphDatabase.driver): Instance of `GraphDatabase.driver`
-            instance
-        output_csv_path (str): CSV file path for exporting the metric.
-    """
-    if not load_list:
-        load_list = []
-
-    validate_export_path(output_csv_path, ".csv")
-    cypher_query = """
-                    MATCH (b:Bus)
-                    MATCH (s:Substation)
-                    WHERE b <> s
-                    WITH b, shortestPath((b)-[:CONNECTS_TO*]-(s)) as p
-                    MATCH (c:Load)-[:CONSUMES_POWER_FROM]-(b)
-                    WITH c, p, apoc.coll.min([r in relationships(p) | r.survive]) AS max_p
-                    RETURN c.name, max_p
-                """
-    metric_container = {"load_name": [], "metric": []}
-    with driver.session() as session:
-        result = session.read_transaction(
-            lambda tx: tx.run(cypher_query).data()
-        )
-
-        for item in result:
-            metric_container["load_name"].append(item["c.name"])
-            metric_container["metric"].append(item["max_p"] \
-                                              if item["c.name"] not in load_list else 1)
-
-    df = pd.DataFrame(metric_container)
-    df.to_csv(output_csv_path)
-
-
-def energy_resilience_by_customer(
-    driver: GraphDatabase.driver, output_csv_path: str,
-    critical_infras: List = ["Grocery", "Hospital", "Pharmacy"]
-):
-    """Function for checking whether customer is still connected
-    to substation or not.
-
-    Args:
-        driver (GraphDatabase.driver): Instance of `GraphDatabase.driver`
-            instance
-        output_csv_path (str): CSV file path for exporting the metric.
-    """
-
-    validate_export_path(output_csv_path, ".csv")
-
-    metric_container = {"load_name": [], "metric": [], "critical_service": []}
-    with driver.session() as session:
-
-        for cs in critical_infras:
-            cypher_query = (
-                f"""
-                    MATCH (lo:Load)
-                    MATCH (cs:{cs})
-                    """
-                + """
-                    WITH lo,cs, 
-                        point.distance(point({longitude: lo.longitude, latitude:lo.latitude}), 
-                        point({longitude: cs.longitude, latitude:cs.latitude}))/1000 AS d
-                    RETURN lo.name, sum(toInteger(toBoolean(cs.survive) OR toBoolean(cs.backup))/d) AS gamma
-                    """
-                    # count(d)/sum(d) AS gamma
-                    # WHERE cs.survive = 1 
-            )
-            result = session.read_transaction(
-                lambda tx: tx.run(cypher_query).data()
-            )
-
-            for item in result:
-                metric_container["load_name"].append(item["lo.name"])
-                metric_container["metric"].append(item["gamma"])
-                metric_container["critical_service"].append(cs)
-
-    df = pd.DataFrame(metric_container)
-    df.to_csv(output_csv_path)
-
-
-def equity_based_energy_resilience_by_income(
-    driver: GraphDatabase.driver,
-    path_to_energy_resilience_metric: str,
-    output_json_path: str,
-    category: Dict[str, Callable] = {
-        "low": lambda x: x < 90000,
-        "medium": lambda x: (90000 < x < 110000),
-        "high": lambda x: x > 110000,
-    },
-):
-    """Function to compute the equity based energy resilience metric.
-
-    Args:
-        driver (GraphDatabase.driver): Instance of `GraphDatabase.driver`
-            instance
-        path_to_energy_resilience_metric (str): Path to energy resilience metric.
-        output_json_path (str): JSON file path for exporting the metric.
-        category (Dict[str, Callable]): Income categories
-    """
-
-    validate_export_path(output_json_path, ".json")
-    util.path_validation(path_to_energy_resilience_metric)
-
-    metric_container = {}
-
-    with driver.session() as session:
-
-        cypher_query = """
-                            MATCH (lo:Load)
-                            RETURN lo.income as income, lo.name as name
-                        """
-        result = session.read_transaction(
-            lambda tx: tx.run(cypher_query).data()
-        )
-
-    resilience_metric = pd.read_csv(path_to_energy_resilience_metric)
-    gamma_dict = (
-        resilience_metric.groupby("load_name").sum()["metric"].to_dict()
-    )
-
-    for id, func in category.items():
-
-        metric, income_flag_sum = 0, 0
-        for load in result:
-            load_income_flag = func(load["income"])
-            metric += load_income_flag * gamma_dict[load["name"]]
-            income_flag_sum += load_income_flag
-
-        metric_container[id] = (
-            metric / income_flag_sum if income_flag_sum else None
-        )
-
-    metric_values = [val for _, val in metric_container.items() if val]
-    if metric_values:
-        metric_container["community_resilience_equity_score"] = np.mean(
-            metric_values
-        ) / np.std(metric_values)
-
-    with open(output_json_path, "w") as fpointer:
-        json.dump(metric_container, fpointer)
+""" Module for handling computation of equity and resilience metrics.
+
+Idea is to create separate function for computing each metric. 
+"""
+
+from pathlib import Path
+from typing import Callable, Union, Dict, List
+import json
+
+from neo4j import GraphDatabase
+import pandas as pd
+import numpy as np
+
+from erad.utils import util
+from erad import exceptions
+
+
+def validate_export_path(file_path: Union[str, Path], file_type: str):
+    """Function for validating the export file path.
+
+    Args:
+        file_path (Union[str, Path]): Export file path
+        file_type (str): File type to be exported e.g. .csv
+    """
+
+    output_path = Path(file_path)
+    util.path_validation(output_path.parent)
+    if output_path.suffix != file_type:
+        raise exceptions.InvalidFileTypePassed(output_path, file_type)
+
+
+def is_customer_getting_power(
+    driver: GraphDatabase.driver, output_csv_path: str,
+    load_list: List[str] = None
+):
+
+    """Function for checking whether customer is still connected
+    to substation or not.
+
+    Args:
+        driver (GraphDatabase.driver): Instance of `GraphDatabase.driver`
+            instance
+        output_csv_path (str): CSV file path for exporting the metric.
+    """
+    if not load_list:
+        load_list = []
+
+    validate_export_path(output_csv_path, ".csv")
+    cypher_query = """
+                    MATCH (b:Bus)
+                    MATCH (s:Substation)
+                    WHERE b <> s
+                    WITH b, shortestPath((b)-[:CONNECTS_TO*]-(s)) as p
+                    MATCH (c:Load)-[:CONSUMES_POWER_FROM]-(b)
+                    WITH c, p, apoc.coll.min([r in relationships(p) | r.survive]) AS max_p
+                    RETURN c.name, max_p
+                """
+    metric_container = {"load_name": [], "metric": []}
+    with driver.session() as session:
+        result = session.read_transaction(
+            lambda tx: tx.run(cypher_query).data()
+        )
+
+        for item in result:
+            metric_container["load_name"].append(item["c.name"])
+            metric_container["metric"].append(item["max_p"] \
+                                              if item["c.name"] not in load_list else 1)
+
+    df = pd.DataFrame(metric_container)
+    df.to_csv(output_csv_path)
+
+
+def energy_resilience_by_customer(
+    driver: GraphDatabase.driver, output_csv_path: str,
+    critical_infras: List = ["Grocery", "Hospital", "Pharmacy"]
+):
+    """Function for checking whether customer is still connected
+    to substation or not.
+
+    Args:
+        driver (GraphDatabase.driver): Instance of `GraphDatabase.driver`
+            instance
+        output_csv_path (str): CSV file path for exporting the metric.
+    """
+
+    validate_export_path(output_csv_path, ".csv")
+
+    metric_container = {"load_name": [], "metric": [], "critical_service": []}
+    with driver.session() as session:
+
+        for cs in critical_infras:
+            cypher_query = (
+                f"""
+                    MATCH (lo:Load)
+                    MATCH (cs:{cs})
+                    """
+                + """
+                    WITH lo,cs, 
+                        point.distance(point({longitude: lo.longitude, latitude:lo.latitude}), 
+                        point({longitude: cs.longitude, latitude:cs.latitude}))/1000 AS d
+                    RETURN lo.name, sum(toInteger(toBoolean(cs.survive) OR toBoolean(cs.backup))/d) AS gamma
+                    """
+                    # count(d)/sum(d) AS gamma
+                    # WHERE cs.survive = 1 
+            )
+            result = session.read_transaction(
+                lambda tx: tx.run(cypher_query).data()
+            )
+
+            for item in result:
+                metric_container["load_name"].append(item["lo.name"])
+                metric_container["metric"].append(item["gamma"])
+                metric_container["critical_service"].append(cs)
+
+    df = pd.DataFrame(metric_container)
+    df.to_csv(output_csv_path)
+
+
+def equity_based_energy_resilience_by_income(
+    driver: GraphDatabase.driver,
+    path_to_energy_resilience_metric: str,
+    output_json_path: str,
+    category: Dict[str, Callable] = {
+        "low": lambda x: x < 90000,
+        "medium": lambda x: (90000 < x < 110000),
+        "high": lambda x: x > 110000,
+    },
+):
+    """Function to compute the equity based energy resilience metric.
+
+    Args:
+        driver (GraphDatabase.driver): Instance of `GraphDatabase.driver`
+            instance
+        path_to_energy_resilience_metric (str): Path to energy resilience metric.
+        output_json_path (str): JSON file path for exporting the metric.
+        category (Dict[str, Callable]): Income categories
+    """
+
+    validate_export_path(output_json_path, ".json")
+    util.path_validation(path_to_energy_resilience_metric)
+
+    metric_container = {}
+
+    with driver.session() as session:
+
+        cypher_query = """
+                            MATCH (lo:Load)
+                            RETURN lo.income as income, lo.name as name
+                        """
+        result = session.read_transaction(
+            lambda tx: tx.run(cypher_query).data()
+        )
+
+    resilience_metric = pd.read_csv(path_to_energy_resilience_metric)
+    gamma_dict = (
+        resilience_metric.groupby("load_name").sum()["metric"].to_dict()
+    )
+
+    for id, func in category.items():
+
+        metric, income_flag_sum = 0, 0
+        for load in result:
+            load_income_flag = func(load["income"])
+            metric += load_income_flag * gamma_dict[load["name"]]
+            income_flag_sum += load_income_flag
+
+        metric_container[id] = (
+            metric / income_flag_sum if income_flag_sum else None
+        )
+
+    metric_values = [val for _, val in metric_container.items() if val]
+    if metric_values:
+        metric_container["community_resilience_equity_score"] = np.mean(
+            metric_values
+        ) / np.std(metric_values)
+
+    with open(output_json_path, "w") as fpointer:
+        json.dump(metric_container, fpointer)

erad/programs/backup.py

@@ -1,62 +1,62 @@
-""" This module will update the backup property for 
-critical infrastructure. """
-
-# standard imports
-from typing import List
-import random
-
-# third party imports
-from neo4j import GraphDatabase
-
-# internal imports
-from erad.db.utils import _run_read_query
-
-def apply_backup_program(
-    driver: GraphDatabase.driver,
-    electricity_backup: any,
-    critical_infras: List[str],
-):
-
-    """ Function that will update the backup 
-    property of critical infras based on backup percentage.
-    
-    Args:
-        driver (GraphDatabase.driver): Neo4J Driver instance
-        electricity_backup (float): backup percentage number between 0 and 1 or list of infras to set as backup
-        critical_infras (List[str]): list of critical infrastructure
-    """
-
-    infra_with_backups = []
-    for cri_infra in critical_infras:
-        cypher_query = f"""
-                        MATCH (c:{cri_infra})
-                        RETURN c.longitude, c.latitude, c.name, c.backup
-                    """
-        infras = _run_read_query(driver, cypher_query)
-        
-        for infra in infras:
-            
-            cypher_write_query = f"""
-                MATCH (c:{cri_infra})
-                WHERE c.name = $cname
-                SET c.backup = $backup
-            """
-
-            if not isinstance(electricity_backup, list):
-                backup = 1 if random.random() < electricity_backup else 0
-            else:
-                backup = 1 if infra['c.name'] in electricity_backup else 0 
-
-            if backup == 1:
-                infra_with_backups.append(infra['c.name'])
-
-            with driver.session() as session:
-                session.write_transaction(
-                    lambda tx: tx.run(
-                        cypher_write_query,
-                        cname=infra['c.name'],
-                        backup= backup
-                    )
-                )
-
+""" This module will update the backup property for 
+critical infrastructure. """
+
+# standard imports
+from typing import List
+import random
+
+# third party imports
+from neo4j import GraphDatabase
+
+# internal imports
+from erad.db.utils import _run_read_query
+
+def apply_backup_program(
+    driver: GraphDatabase.driver,
+    electricity_backup: any,
+    critical_infras: List[str],
+):
+
+    """ Function that will update the backup 
+    property of critical infras based on backup percentage.
+    
+    Args:
+        driver (GraphDatabase.driver): Neo4J Driver instance
+        electricity_backup (float): backup percentage number between 0 and 1 or list of infras to set as backup
+        critical_infras (List[str]): list of critical infrastructure
+    """
+
+    infra_with_backups = []
+    for cri_infra in critical_infras:
+        cypher_query = f"""
+                        MATCH (c:{cri_infra})
+                        RETURN c.longitude, c.latitude, c.name, c.backup
+                    """
+        infras = _run_read_query(driver, cypher_query)
+        
+        for infra in infras:
+            
+            cypher_write_query = f"""
+                MATCH (c:{cri_infra})
+                WHERE c.name = $cname
+                SET c.backup = $backup
+            """
+
+            if not isinstance(electricity_backup, list):
+                backup = 1 if random.random() < electricity_backup else 0
+            else:
+                backup = 1 if infra['c.name'] in electricity_backup else 0 
+
+            if backup == 1:
+                infra_with_backups.append(infra['c.name'])
+
+            with driver.session() as session:
+                session.write_transaction(
+                    lambda tx: tx.run(
+                        cypher_write_query,
+                        cname=infra['c.name'],
+                        backup= backup
+                    )
+                )
+
     return infra_with_backups

erad/programs/microgrid.py

@@ -1,45 +1,45 @@
-"""
-This module will update the survive property based on whether 
-the critica infrastructure is going to be powered from microgrid or not.
-"""
-
-
-from neo4j import GraphDatabase
-
-from erad.metrics.check_microgrid import check_for_microgrid
-
-
-def apply_microgrid_to_critical_infra(
-        driver: GraphDatabase.driver,
-        factor: float= (0.5 * 0.4)
-):
-    """ Function that will update the survive property of 
-    critical infrastructure if it can get power from microgrid."""
-
-    islands_jsons = check_for_microgrid(driver, output_json_path=None)
-    infra_island = [subdict['sinks'] for _, subdict \
-                      in islands_jsons.items() if len(subdict['sources'])>0]
-    infra_microgrid = [1 if subdict['source_capacity'] >= subdict['sink_capacity']*factor  else 0 for _, subdict \
-                      in islands_jsons.items()]
-
-    infra_survives = [el for id, el in enumerate(infra_island) \
-                      if infra_microgrid[id]]
-    all_sinks = [x for el in infra_survives for x in el]
-    infra_survives = [x for el in infra_survives for x in el if 'load' not in x]
-    
-    for infra in infra_survives:
-        cypher_query = f"""
-                        MATCH (c)
-                        WHERE c.name = $cname
-                        SET c.survive = 1
-                        SET c.survival_probability = 1
-                    """
-
-        with driver.session() as session:
-                session.write_transaction(
-                    lambda tx: tx.run(
-                        cypher_query,
-                        cname=infra,
-                    )
-                )
+"""
+This module will update the survive property based on whether 
+the critica infrastructure is going to be powered from microgrid or not.
+"""
+
+
+from neo4j import GraphDatabase
+
+from erad.metrics.check_microgrid import check_for_microgrid
+
+
+def apply_microgrid_to_critical_infra(
+        driver: GraphDatabase.driver,
+        factor: float= (0.5 * 0.4)
+):
+    """ Function that will update the survive property of 
+    critical infrastructure if it can get power from microgrid."""
+
+    islands_jsons = check_for_microgrid(driver, output_json_path=None)
+    infra_island = [subdict['sinks'] for _, subdict \
+                      in islands_jsons.items() if len(subdict['sources'])>0]
+    infra_microgrid = [1 if subdict['source_capacity'] >= subdict['sink_capacity']*factor  else 0 for _, subdict \
+                      in islands_jsons.items()]
+
+    infra_survives = [el for id, el in enumerate(infra_island) \
+                      if infra_microgrid[id]]
+    all_sinks = [x for el in infra_survives for x in el]
+    infra_survives = [x for el in infra_survives for x in el if 'load' not in x]
+    
+    for infra in infra_survives:
+        cypher_query = f"""
+                        MATCH (c)
+                        WHERE c.name = $cname
+                        SET c.survive = 1
+                        SET c.survival_probability = 1
+                    """
+
+        with driver.session() as session:
+                session.write_transaction(
+                    lambda tx: tx.run(
+                        cypher_query,
+                        cname=infra,
+                    )
+                )
     return all_sinks