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

erad/db/assets/critical_infras.py

@@ -1,171 +1,171 @@
-""" This module contains functions to update 
-survival probability and survive property
-based on disaster event. """
-
-# manage python imports
-from datetime import datetime 
-import random
-
-from neo4j import GraphDatabase
-
-from erad.db.utils import _run_read_query
-from erad.metrics.check_microgrid import node_connected_to_substation
-
-
-def _update_critical_infra_based_on_grid_access_fast(
-    critical_infras,
-    driver: GraphDatabase.driver   
-):
-    """ A faster function to update survive attribute 
-    based on whether critical infra has access to grid power."""
-    # Let's get substation 
-    cypher_query = f"""
-        MATCH (n:Substation)
-        WHERE n.survive is NULL OR n.survive<>0 
-        RETURN n.name
-    """
-    substations = _run_read_query(driver, cypher_query)
-    substations = [item["n.name"]  for item in substations]
-    
-    nodes = node_connected_to_substation(substations, driver)
-
-    # Get all critical infra and check if they are in above nodes
-    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.survive = $survive
-                SET c.survival_probability = $s_prob
-            """
-
-            with driver.session() as session:
-                session.write_transaction(
-                    lambda tx: tx.run(
-                        cypher_write_query,
-                        cname=infra['c.name'],
-                        s_prob= 1 if infra['c.name'] in nodes or int(infra['c.backup'])==1 else 0,
-                        survive=1 if infra['c.name'] in nodes or int(infra['c.backup'])==1 else 0 
-                    )
-                )
-
-
-
-def _update_critical_infra_based_on_grid_access(
-    critical_infras,
-    driver: GraphDatabase.driver 
-):
-    """ A function to update survive attribute 
-    based on whether critical infra has access to grid power."""
-
-    # Let's get substation 
-    cypher_query = f"""
-        MATCH (n:Substation)
-        WHERE n.survive is NULL OR n.survive<>0 
-        RETURN n.name
-    """
-    substations = _run_read_query(driver, cypher_query)
-    substations = [item["n.name"]  for item in substations]
-
-    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:
-            connected = []
-            for substation in substations:
-
-                _name = "{name:" + f'"{infra["c.name"]}"' + "}"
-                substation_name = "{name:" + f'"{substation}"' + "}"
-                cypher_query = f"""
-                    MATCH 
-                        (g:{cri_infra} {_name})-[:GETS_POWER_FROM]-(b:Bus),
-                        (s:Substation {substation_name}),
-                        p=shortestPath((b)-[:CONNECTED_TO*]-(s))
-                    WHERE all(r in relationships(p) WHERE r.survive is NULL OR r.survive<>0 )
-                    RETURN length(p)
-                """
-
-                if not infra['c.backup']: 
-                    path = _run_read_query(driver, cypher_query)
-                    connected.append(1 if path else 0) 
-                else:
-                    connected.append(1)
-                
-
-            cypher_write_query = f"""
-                MATCH (c:{cri_infra})
-                WHERE c.name = $cname
-                SET c.survive = $survive
-                SET c.survival_probability = $s_prob
-            """
-
-            with driver.session() as session:
-                session.write_transaction(
-                    lambda tx: tx.run(
-                        cypher_write_query,
-                        cname=infra['c.name'],
-                        s_prob= int(any(connected)),
-                        survive=int(any(connected)) 
-                    )
-                )
-
-def _update_critical_infra(
-        scenario,
-        critical_infras,
-        driver: GraphDatabase.driver,
-        timestamp: datetime 
-):
-
-    critical_infras_items = {}
-    assets = {}
-
-    for infra in critical_infras:
-        cypher_query = f"""
-                        MATCH (c:{infra})
-                        RETURN c.longitude, c.latitude, c.name
-                    """
-        critical_infras_items[infra] = _run_read_query(driver, cypher_query)
-
-    
-    for c_infra, data in critical_infras_items.items():
-        assets[c_infra] =  {
-            item["c.name"]: {
-                "coordinates": [item["c.longitude"], item["c.latitude"]]
-            } for item in data
-            if all([item["c.longitude"], item["c.latitude"]])
-        }
-
-    survival_prob = scenario.calculate_survival_probability(assets, datetime.now())
-    
-    # update the survival probability
-    for infra in critical_infras:
-        cypher_query = f"""
-                        MATCH (c:{infra})
-                        WHERE c.name = $cname
-                        SET c.survive = $survive
-                        SET c.survival_probability = $s_prob
-                    """
-
-        with driver.session() as session:
-            for cname, cdict in survival_prob[infra].items():
-                session.write_transaction(
-                    lambda tx: tx.run(
-                        cypher_query,
-                        cname=cname,
-                        s_prob=cdict["survival_probability"],
-                        survive=int(
-                            random.random() < cdict["survival_probability"]
-                        ),
-                    )
+""" This module contains functions to update 
+survival probability and survive property
+based on disaster event. """
+
+# manage python imports
+from datetime import datetime 
+import random
+
+from neo4j import GraphDatabase
+
+from erad.db.utils import _run_read_query
+from erad.metrics.check_microgrid import node_connected_to_substation
+
+
+def _update_critical_infra_based_on_grid_access_fast(
+    critical_infras,
+    driver: GraphDatabase.driver   
+):
+    """ A faster function to update survive attribute 
+    based on whether critical infra has access to grid power."""
+    # Let's get substation 
+    cypher_query = f"""
+        MATCH (n:Substation)
+        WHERE n.survive is NULL OR n.survive<>0 
+        RETURN n.name
+    """
+    substations = _run_read_query(driver, cypher_query)
+    substations = [item["n.name"]  for item in substations]
+    
+    nodes = node_connected_to_substation(substations, driver)
+
+    # Get all critical infra and check if they are in above nodes
+    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.survive = $survive
+                SET c.survival_probability = $s_prob
+            """
+
+            with driver.session() as session:
+                session.write_transaction(
+                    lambda tx: tx.run(
+                        cypher_write_query,
+                        cname=infra['c.name'],
+                        s_prob= 1 if infra['c.name'] in nodes or int(infra['c.backup'])==1 else 0,
+                        survive=1 if infra['c.name'] in nodes or int(infra['c.backup'])==1 else 0 
+                    )
+                )
+
+
+
+def _update_critical_infra_based_on_grid_access(
+    critical_infras,
+    driver: GraphDatabase.driver 
+):
+    """ A function to update survive attribute 
+    based on whether critical infra has access to grid power."""
+
+    # Let's get substation 
+    cypher_query = f"""
+        MATCH (n:Substation)
+        WHERE n.survive is NULL OR n.survive<>0 
+        RETURN n.name
+    """
+    substations = _run_read_query(driver, cypher_query)
+    substations = [item["n.name"]  for item in substations]
+
+    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:
+            connected = []
+            for substation in substations:
+
+                _name = "{name:" + f'"{infra["c.name"]}"' + "}"
+                substation_name = "{name:" + f'"{substation}"' + "}"
+                cypher_query = f"""
+                    MATCH 
+                        (g:{cri_infra} {_name})-[:GETS_POWER_FROM]-(b:Bus),
+                        (s:Substation {substation_name}),
+                        p=shortestPath((b)-[:CONNECTED_TO*]-(s))
+                    WHERE all(r in relationships(p) WHERE r.survive is NULL OR r.survive<>0 )
+                    RETURN length(p)
+                """
+
+                if not infra['c.backup']: 
+                    path = _run_read_query(driver, cypher_query)
+                    connected.append(1 if path else 0) 
+                else:
+                    connected.append(1)
+                
+
+            cypher_write_query = f"""
+                MATCH (c:{cri_infra})
+                WHERE c.name = $cname
+                SET c.survive = $survive
+                SET c.survival_probability = $s_prob
+            """
+
+            with driver.session() as session:
+                session.write_transaction(
+                    lambda tx: tx.run(
+                        cypher_write_query,
+                        cname=infra['c.name'],
+                        s_prob= int(any(connected)),
+                        survive=int(any(connected)) 
+                    )
+                )
+
+def _update_critical_infra(
+        scenario,
+        critical_infras,
+        driver: GraphDatabase.driver,
+        timestamp: datetime 
+):
+
+    critical_infras_items = {}
+    assets = {}
+
+    for infra in critical_infras:
+        cypher_query = f"""
+                        MATCH (c:{infra})
+                        RETURN c.longitude, c.latitude, c.name
+                    """
+        critical_infras_items[infra] = _run_read_query(driver, cypher_query)
+
+    
+    for c_infra, data in critical_infras_items.items():
+        assets[c_infra] =  {
+            item["c.name"]: {
+                "coordinates": [item["c.longitude"], item["c.latitude"]]
+            } for item in data
+            if all([item["c.longitude"], item["c.latitude"]])
+        }
+
+    survival_prob = scenario.calculate_survival_probability(assets, datetime.now())
+    
+    # update the survival probability
+    for infra in critical_infras:
+        cypher_query = f"""
+                        MATCH (c:{infra})
+                        WHERE c.name = $cname
+                        SET c.survive = $survive
+                        SET c.survival_probability = $s_prob
+                    """
+
+        with driver.session() as session:
+            for cname, cdict in survival_prob[infra].items():
+                session.write_transaction(
+                    lambda tx: tx.run(
+                        cypher_query,
+                        cname=cname,
+                        s_prob=cdict["survival_probability"],
+                        survive=int(
+                            random.random() < cdict["survival_probability"]
+                        ),
+                    )
                 )

erad/db/assets/distribution_lines.py

@@ -1,101 +1,101 @@
-""" This module contains a function to get the distribution 
-line assets and update it's survival probability and survive
-attribute based on event scenario. 
-"""
-
-# Manage python imports
-from datetime import datetime
-import random
-import json
-import random
-
-random.seed(20)
-
-from neo4j import GraphDatabase
-
-from erad.db.utils import _run_read_query
-
-
-def _create_assets(lines):
-    """ Takes the list of lines and convert into
-    asset dictionary. """
-
-    return {
-            line["r.name"]: {
-                "coordinates": [line["r.latitude"], line["r.longitude"]],
-                "heights_ft": float(line["r.height_m"])*3.28084,
-                "elevation_ft": random.randint(50, 400)
-            }
-            for line in lines
-            if all([line["r.longitude"], line["r.latitude"]])
-        }
-
-def _update_distribution_lines_survival(
-    survival_probability,
-    driver: GraphDatabase.driver   
-):
-    """ Takes survival probabilty and update survival 
-    probability and survive property. """
-
-  
-
-    cypher_query = """
-                    MATCH (b1:Bus)-[r:CONNECTS_TO {name: $rname}]-(b2:Bus)
-                    SET r.survive = $survive
-                    SET r.survival_probability = $s_prob
-                """
-    with driver.session() as session:
-        for rname, rdict in survival_probability.items():
-            session.write_transaction(
-                lambda tx: tx.run(
-                    cypher_query,
-                    rname=rname,
-                    s_prob=rdict.get("survival_probability", 1),
-                    survive=int(random.random() < rdict.get("survival_probability", 1)),
-                )
-            )
-
-
-def _update_distribution_overhead_lines(scenario, driver: GraphDatabase.driver, timestamp: datetime):
-    """Get overhead lines and update the survival probability."""
-
-    # Cypher query to get overhead line segments
-    cypher_query = """ 
-                    MATCH (b1:Bus)-[r:CONNECTS_TO]-(b2:Bus)
-                    WHERE r.ampacity IS NOT NULL AND r.type = 'overhead'
-                    RETURN r.longitude, r.latitude, r.name, r.type, r.height_m
-                """
-    overhead_lines = _run_read_query(driver, cypher_query)
-
-    if overhead_lines:
-        assets = {"distribution_overhead_lines": _create_assets(overhead_lines)}
-
-        survival_prob = scenario.calculate_survival_probability(assets, timestamp)
-
-        # with open('surv.json', "w") as fp:
-        #     json.dump(survival_prob,fp)
-        _update_distribution_lines_survival(
-            survival_prob['distribution_overhead_lines'],
-            driver
-        )
-
-def _update_distribution_underground_lines(scenario, driver: GraphDatabase.driver, timestamp: datetime):
-    """Get overhead lines and update the survival probability."""
-
-    # Cypher query to get overhead line segments
-    cypher_query = """ 
-                    MATCH (b1:Bus)-[r:CONNECTS_TO]-(b2:Bus)
-                    WHERE r.ampacity IS NOT NULL AND r.type = 'underground'
-                    RETURN r.longitude, r.latitude, r.name, r.type, r.height_m
-                """
-    underground_lines = _run_read_query(driver, cypher_query)
-
-    if underground_lines:
-        assets = {"buried_lines": _create_assets(underground_lines)}
-
-        survival_prob = scenario.calculate_survival_probability(assets, timestamp)
-        _update_distribution_lines_survival(
-            survival_prob['buried_lines'],
-            driver
-        )
-
+""" This module contains a function to get the distribution 
+line assets and update it's survival probability and survive
+attribute based on event scenario. 
+"""
+
+# Manage python imports
+from datetime import datetime
+import random
+import json
+import random
+
+random.seed(20)
+
+from neo4j import GraphDatabase
+
+from erad.db.utils import _run_read_query
+
+
+def _create_assets(lines):
+    """ Takes the list of lines and convert into
+    asset dictionary. """
+
+    return {
+            line["r.name"]: {
+                "coordinates": [line["r.latitude"], line["r.longitude"]],
+                "heights_ft": float(line["r.height_m"])*3.28084,
+                "elevation_ft": random.randint(50, 400)
+            }
+            for line in lines
+            if all([line["r.longitude"], line["r.latitude"]])
+        }
+
+def _update_distribution_lines_survival(
+    survival_probability,
+    driver: GraphDatabase.driver   
+):
+    """ Takes survival probabilty and update survival 
+    probability and survive property. """
+
+  
+
+    cypher_query = """
+                    MATCH (b1:Bus)-[r:CONNECTS_TO {name: $rname}]-(b2:Bus)
+                    SET r.survive = $survive
+                    SET r.survival_probability = $s_prob
+                """
+    with driver.session() as session:
+        for rname, rdict in survival_probability.items():
+            session.write_transaction(
+                lambda tx: tx.run(
+                    cypher_query,
+                    rname=rname,
+                    s_prob=rdict.get("survival_probability", 1),
+                    survive=int(random.random() < rdict.get("survival_probability", 1)),
+                )
+            )
+
+
+def _update_distribution_overhead_lines(scenario, driver: GraphDatabase.driver, timestamp: datetime):
+    """Get overhead lines and update the survival probability."""
+
+    # Cypher query to get overhead line segments
+    cypher_query = """ 
+                    MATCH (b1:Bus)-[r:CONNECTS_TO]-(b2:Bus)
+                    WHERE r.ampacity IS NOT NULL AND r.type = 'overhead'
+                    RETURN r.longitude, r.latitude, r.name, r.type, r.height_m
+                """
+    overhead_lines = _run_read_query(driver, cypher_query)
+
+    if overhead_lines:
+        assets = {"distribution_overhead_lines": _create_assets(overhead_lines)}
+
+        survival_prob = scenario.calculate_survival_probability(assets, timestamp)
+
+        # with open('surv.json', "w") as fp:
+        #     json.dump(survival_prob,fp)
+        _update_distribution_lines_survival(
+            survival_prob['distribution_overhead_lines'],
+            driver
+        )
+
+def _update_distribution_underground_lines(scenario, driver: GraphDatabase.driver, timestamp: datetime):
+    """Get overhead lines and update the survival probability."""
+
+    # Cypher query to get overhead line segments
+    cypher_query = """ 
+                    MATCH (b1:Bus)-[r:CONNECTS_TO]-(b2:Bus)
+                    WHERE r.ampacity IS NOT NULL AND r.type = 'underground'
+                    RETURN r.longitude, r.latitude, r.name, r.type, r.height_m
+                """
+    underground_lines = _run_read_query(driver, cypher_query)
+
+    if underground_lines:
+        assets = {"buried_lines": _create_assets(underground_lines)}
+
+        survival_prob = scenario.calculate_survival_probability(assets, timestamp)
+        _update_distribution_lines_survival(
+            survival_prob['buried_lines'],
+            driver
+        )
+

erad/db/credential_model.py

@@ -1,20 +1,20 @@
-""" Module for storing pydantic model for neo4j credential. """
-
-from pydantic import BaseModel, validator
-
-from erad.exceptions import DatabaseMissingInfo
-
-
-class Neo4jConnectionModel(BaseModel):
-    neo4j_url: str
-    neo4j_username: str
-    neo4j_password: str
-
-    @validator("neo4j_url", "neo4j_username", "neo4j_password")
-    def check_string(cls, value):
-        if not all(value):
-            raise DatabaseMissingInfo(
-                "Credential and/or connection URL missing \
-                to connect to Neo4J database!"
-            )
-        return value
+""" Module for storing pydantic model for neo4j credential. """
+
+from pydantic import BaseModel, validator
+
+from erad.exceptions import DatabaseMissingInfo
+
+
+class Neo4jConnectionModel(BaseModel):
+    neo4j_url: str
+    neo4j_username: str
+    neo4j_password: str
+
+    @validator("neo4j_url", "neo4j_username", "neo4j_password")
+    def check_string(cls, value):
+        if not all(value):
+            raise DatabaseMissingInfo(
+                "Credential and/or connection URL missing \
+                to connect to Neo4J database!"
+            )
+        return value

erad/db/disaster_input_model.py

@@ -1,23 +1,23 @@
-""" Module for storing pydantic model for injecting scenarios. """
-
-from typing import Dict, Optional, List
-import datetime
-
-from pydantic import BaseModel, validator, confloat
-
-
-class PointEarthquake(BaseModel):
-    longitude: confloat(ge=-180, le=180)
-    latitude: confloat(ge=-90, le=90)
-    probability_model: Optional[Dict]
-    timestamp: datetime.datetime
-    magnitude: confloat(ge=0, le=10)
-    depth: confloat(ge=0)
-
-class PolygonFlooding(BaseModel):
-    polygon: List
-    probability_model: Optional[Dict]
-    timestamp: datetime.datetime
-    file_flow: str 
-    file_levels: str 
-    file_gaugues: str
+""" Module for storing pydantic model for injecting scenarios. """
+
+from typing import Dict, Optional, List
+import datetime
+
+from pydantic import BaseModel, validator, confloat
+
+
+class PointEarthquake(BaseModel):
+    longitude: confloat(ge=-180, le=180)
+    latitude: confloat(ge=-90, le=90)
+    probability_model: Optional[Dict]
+    timestamp: datetime.datetime
+    magnitude: confloat(ge=0, le=10)
+    depth: confloat(ge=0)
+
+class PolygonFlooding(BaseModel):
+    polygon: List
+    probability_model: Optional[Dict]
+    timestamp: datetime.datetime
+    file_flow: str 
+    file_levels: str 
+    file_gaugues: str