NREL-erad 0.0.0a0__py3-none-any.whl

erad/utils/opendss_utils.py

@@ -0,0 +1,357 @@
+""" Module for extracting assets from OpenDSS model.
+
+Examples:
+
+    >>> from erad import utils
+    >>> extract_opendss_model(
+            <path_to_opendss_master_file>,
+            <output_folder>
+        )
+"""
+
+# standard imports
+from genericpath import exists
+from pathlib import Path
+import logging
+from typing import List
+
+# third-party imports
+import opendssdirect as dss
+import pandas as pd
+import networkx as nx
+from shapely.geometry import MultiPoint
+import stateplane
+
+# internal imports
+from erad.utils.util import path_validation, setup_logging
+from erad.exceptions import OpenDSSCommandError, MultiStatePlaneError
+
+
+logger = logging.getLogger(__name__)
+
+
+def get_transformers(dss_instance: dss) -> List:
+    """Function to return list of transformers in opendss models.
+
+    Args:
+        dss_instance (dss): OpenDSS instance with models preloaded
+
+    Returns:
+        List: List of transformer metadata object
+    """
+
+    transformer_container = []
+    flag = dss_instance.Transformers.First()
+    while flag > 0:
+        trans_name = dss_instance.CktElement.Name().lower()
+        buses = dss_instance.CktElement.BusNames()
+        bus1, bus2 = buses[0].split(".")[0], buses[1].split(".")[0]
+
+        transformer_container.append(
+            {
+                "name": trans_name,
+                "type": "Transformer",
+                "source": bus1,
+                "target": bus2,
+                "kva": dss_instance.Transformers.kVA(),
+                "num_phase": dss_instance.CktElement.NumPhases(),
+            }
+        )
+        flag = dss_instance.Transformers.Next()
+    return transformer_container
+
+
+def get_line_sections(dss_instance: dss) -> List:
+    """Function to return list of all line segments in opendss model.
+
+    Args:
+        dss_instance (dss): OpenDSS instance with models preloaded
+
+    Returns:
+        List: List of line segment metadata object
+    """
+    UNIT_MAPPER = {
+        0: 0,
+        1: 1.60934,
+        2: 0.3048,
+        3: 1,
+        4: 0.001,
+        5: 0.0003048,
+        6: 0.0000254,
+        7: 0.00001,
+    }
+
+    sections_container = []
+    flag = dss_instance.Lines.First()
+    while flag > 0:
+        section_name = dss_instance.CktElement.Name().lower()
+        buses = dss_instance.CktElement.BusNames()
+        bus1, bus2 = buses[0].split(".")[0], buses[1].split(".")[0]
+
+        sections_container.append(
+            {
+                "name": section_name,
+                "type": "LineSegment",
+                "source": bus1,
+                "target": bus2,
+                "length_km": UNIT_MAPPER[dss_instance.Lines.Units()]
+                * dss_instance.Lines.Length(),
+                "ampacity": dss_instance.Lines.NormAmps(),
+                "num_phase": dss_instance.CktElement.NumPhases(),
+            }
+        )
+
+        flag = dss_instance.Lines.Next()
+    return sections_container
+
+
+def get_buses(dss_instance: dss) -> List:
+    """Function to return list of all buses in opendss model.
+
+    Args:
+        dss_instance (dss): OpenDSS instance with models preloaded
+
+    Returns:
+        List: List of bus metadata object
+    """
+    buses_container = []
+    for bus in dss_instance.Circuit.AllBusNames():
+        dss_instance.Circuit.SetActiveBus(bus)
+        buses_container.append(
+            {
+                "name": bus,
+                "type": "Bus",
+                "kv": dss_instance.Bus.kVBase(),
+                "longitude": dss_instance.Bus.X(),
+                "latitude": dss_instance.Bus.Y(),
+            }
+        )
+    return buses_container
+
+
+def get_capacitors(dss_instance: dss) -> List:
+    """Function to return list of all capacitors in opendss model.
+
+    Args:
+        dss_instance (dss): OpenDSS instance with models preloaded
+
+    Returns:
+        List: List of capacitor metadata object
+    """
+
+    capacitors_container = []
+    flag = dss_instance.Capacitors.First()
+    while flag > 0:
+        capacitor_name = dss_instance.CktElement.Name().lower()
+        buses = dss_instance.CktElement.BusNames()
+        bus1 = buses[0].split(".")[0]
+
+        capacitors_container.append(
+            {
+                "name": capacitor_name,
+                "type": "Capacitor",
+                "source": bus1,
+                "kv": dss_instance.Capacitors.kV(),
+                "kvar": dss_instance.Capacitors.kvar(),
+            }
+        )
+
+        flag = dss_instance.Capacitors.Next()
+    return capacitors_container
+
+
+def get_pvsystems(dss_instance: dss) -> List:
+    """Function to return list of all pv systems in opendss model.
+
+    Args:
+        dss_instance (dss): OpenDSS instance with models preloaded
+
+    Returns:
+        List: List of PVsystem metadata object
+    """
+
+    pvs_container = []
+    flag = dss_instance.PVsystems.First()
+    while flag > 0:
+        pv_name = dss_instance.CktElement.Name().lower()
+        buses = dss_instance.CktElement.BusNames()
+        bus1 = buses[0].split(".")[0]
+
+        pvs_container.append(
+            {
+                "name": pv_name,
+                "type": "PVSystem",
+                "source": bus1,
+                "rated_power": dss_instance.PVSystems.Pmpp(),
+            }
+        )
+
+        flag = dss_instance.PVsystems.Next()
+    return pvs_container
+
+
+def get_loads(dss_instance):
+    """Function to return list of all loads in opendss model.
+
+    Args:
+        dss_instance (dss): OpenDSS instance with models preloaded
+
+    Returns:
+        List: List of load metadata object
+    """
+
+    loads_container = []
+    flag = dss_instance.Loads.First()
+    while flag > 0:
+        load_name = dss_instance.CktElement.Name().lower()
+        buses = dss_instance.CktElement.BusNames()
+        bus1 = buses[0].split(".")[0]
+
+        loads_container.append(
+            {
+                "name": load_name,
+                "type": "Load",
+                "source": bus1,
+                "kw": dss_instance.Loads.kW(),
+                "kvar": dss_instance.Loads.kvar(),
+            }
+        )
+
+        flag = dss_instance.Loads.Next()
+    return loads_container
+
+
+def execute_dss_command(dss_instance: dss, dss_command: str) -> None:
+    """Pass the valid dss command to be executed.
+
+    Args:
+        dss_instance (dss): OpenDSS instance with models preloaded
+        dss_command (str): DSS command sring to be executed
+
+    Raises:
+        OpenDSSCommandError: Raises this because opendss command execution
+            ran into error
+
+    """
+    error = dss_instance.run_command(dss_command)
+    if error:
+        logger.error(f"Error executing command {dss_command} >> {error}")
+        raise OpenDSSCommandError(
+            f"Error executing command {dss_command} >> {error}"
+        )
+    logger.info(f"Sucessfully executed the command, {dss_command}")
+
+
+def get_bounding_box(master_file: str, buffer: float = 1000) -> List:
+    """Creates a bounding box coordinate for covering region of opendss model.
+
+    Args:
+        master_file (str): Path to master dss file
+        buffer (float): Buffer distance around distribution model in meter
+
+    Raises:
+        MultiStatePlaneError: Raises this if opendss models lies in multiple
+            state plane coordinates
+
+    Returns:
+        List: List of bounding box coordinates (lower_left, upper_right)
+    """
+
+    # Get bounding box for opendss network
+    # Do a basic check on the path
+    master_file = Path(master_file)
+    path_validation(master_file)
+    logger.debug(f"Attempting to read case file >> {master_file}")
+
+    # Clear memory and compile dss file
+    dss.run_command("Clear")
+    dss.Basic.ClearAll()
+    execute_dss_command(dss, f"Redirect {master_file}")
+
+    # Get all the points
+    points = []
+    for bus in dss.Circuit.AllBusNames():
+        dss.Circuit.SetActiveBus(bus)
+        points.append([dss.Bus.X(), dss.Bus.Y()])
+
+    # Create a multipoint to get bounds
+    multi_points = MultiPoint(points)
+    bounds = multi_points.bounds
+
+    # Get EPSG value for converting into coordinate reference system
+    if stateplane.identify(bounds[0], bounds[1]) != stateplane.identify(
+        bounds[2], bounds[3]
+    ):
+        raise MultiStatePlaneError(
+            f"The regions uses multiple stateplane coordinate system"
+        )
+
+    epsg_value = stateplane.identify(bounds[0], bounds[1])
+
+    # Let's project all the WGS84 coordinates into
+    # transformed coordinates this will make sure distance is in meter
+    transformed_points = [
+        stateplane.from_lonlat(*point, epsg_value) for point in points
+    ]
+
+    # Create a multipoint from the transformed coordinates
+    transformed_multipoint = MultiPoint(transformed_points).buffer(buffer)
+
+    # Get the bounds and convert back to wsg84 format
+    transformed_bounds = transformed_multipoint.bounds
+    bounds_wsg84 = stateplane.to_lonlat(
+        transformed_bounds[0], transformed_bounds[1], epsg_value
+    ) + stateplane.to_lonlat(
+        transformed_bounds[2], transformed_bounds[3], epsg_value
+    )
+
+    return bounds_wsg84
+
+
+def extract_export_opendss_model(
+    master_file: str, output_folder_path: str
+) -> None:
+    """Extract the opendss models and exports into csv file format.
+
+    Args:
+        master_file (str): Path to opendss master file
+        output_folder_path (str): Folder path for exporting the models to.
+    """
+
+    # Do a basic check on the path
+    master_file = Path(master_file)
+    path_validation(master_file)
+    logger.debug(f"Attempting to read case file >> {master_file}")
+
+    # Clear memory and compile dss file
+    dss.run_command("Clear")
+    dss.Basic.ClearAll()
+    execute_dss_command(dss, f"Redirect {master_file}")
+
+    # Initial container
+    transformers = get_transformers(dss)
+    line_sections = get_line_sections(dss)
+    buses = get_buses(dss)
+    capacitors = get_capacitors(dss)
+    pv_systems = get_pvsystems(dss)
+    loads = get_loads(dss)
+
+    output_folder_path = Path(output_folder_path)
+    output_folder_path.mkdir(exist_ok=True)
+    transformers_df = pd.DataFrame(transformers)
+    transformers_df.to_csv(output_folder_path / "transformers.csv")
+
+    line_sections_df = pd.DataFrame(line_sections)
+    line_sections_df.to_csv(output_folder_path / "line_sections.csv")
+
+    buses_df = pd.DataFrame(buses)
+    buses_df.to_csv(output_folder_path / "buses.csv")
+
+    capacitors_df = pd.DataFrame(capacitors)
+    capacitors_df.to_csv(output_folder_path / "capacitors.csv")
+
+    pv_systems_df = pd.DataFrame(pv_systems)
+    pv_systems_df.to_csv(output_folder_path / "pv_systems.csv")
+
+    loads_df = pd.DataFrame(loads)
+    loads_df.to_csv(output_folder_path / "loads.csv")

erad/utils/overpass.py

@@ -0,0 +1,76 @@
+import json
+from typing import List
+
+import overpass
+import polars
+
+# Define your polygon coordinates as a string
+
+GROCERY_TAGS = [
+    'shop=supermarket', 'shop=grocery', 'shop=convenience',
+    'shop=market', 'shop=healthfood', 'shop=organic'
+]
+
+HOSPITAL_TAGS = [
+        'amenity=hospital', 'healthcare=hospital', 'building=hospital',
+        'amenity=clinic', 'healthcare=centre','healthcare=pharmacy',
+]
+
+
+def export_json(json_parcels, out_path):
+    with open(out_path, 'w') as fp:
+        json.dump(json_parcels, fp)
+
+def export_csv(json_parcels, out_path:str):
+
+    csv_data = {
+        "id": [],
+        "longitude": [],
+        "latitude": [],
+    }
+
+    for feature in json_parcels['features']:
+        for key in  feature['properties']:
+            if key not in csv_data:
+                csv_data[key] = []
+    
+    
+    for feature in json_parcels['features']:
+        csv_data["id"].append(feature["id"])
+        csv_data["longitude"].append(feature["geometry"]["coordinates"][0])
+        csv_data["latitude"].append(feature["geometry"]["coordinates"][1])
+
+        for key in csv_data:
+            if key not in ["id", "longitude", "latitude"]:
+                csv_data[key].append(feature['properties'].get(key, None))
+
+    df = polars.from_dict(csv_data)
+    df.write_csv(out_path)
+
+
+def get_sites(polygon: str, tags: List[str] ):
+    # polygon = "33.6812,-118.5966, 34.3407,-118.1390" latitude, longitude 
+    json_parcels = {
+        "type": "FeatureCollection",
+        "features": []
+    }
+
+    for tag in tags:
+
+        query = f"""
+        node[{tag}]({polygon});
+        out;
+        """
+
+        # Create an instance of the Overpass API
+        api = overpass.API()
+
+        # Send the query and retrieve the data
+        response = api.Get(query)
+
+        json_parcels['features'].extend(response['features'])
+        print(f'Number of parcels extracted of shop type {tag}: ', len(response['features']))
+
+    print('Number of parcels extracted: ', len(json_parcels['features']))
+    return json_parcels
+

erad/utils/util.py

@@ -0,0 +1,178 @@
+""" Utility functions that can be used in various parts of the code. """
+
+# standard libraries
+import json
+from pathlib import Path
+import logging
+import logging.config
+import time
+from typing import Union
+
+# third-party libraries
+import yaml
+import geojson
+
+# internal imports
+from erad.exceptions import (
+    FeatureNotImplementedError,
+    PathDoesNotExist,
+    NotAFileError,
+    InvalidFileTypePassed,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def timeit(func):
+    """Decorator for timing execution of a function."""
+
+    def wrapper(*args, **kwargs):
+        time_start = time.perf_counter()
+        logger.debug(f"Timing for {func} started")
+        ret_val = func(*args, **kwargs)
+        time_elapsed = time.perf_counter() - time_start
+        # memory_mb =resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1024.0/1024.0
+        logger.debug(
+            f"Time took to execute the function {func} \
+            with args {args}, kwargs {kwargs} is {time_elapsed} seconds"
+        )
+        return ret_val
+
+    return wrapper
+
+
+def setup_logging(filename: Union[str, None] = None) -> None:
+    """Creates log directory and sets up logging via logging.yaml.
+
+    Args:
+        filename (str): Path to logging.yaml file
+
+    If not providex expects log file in the root of repo.
+    """
+
+    if filename is None:
+        filename = Path(__file__).parents[2] / "logging.yaml"
+
+    logging.config.dictConfig(read_file(filename))
+
+
+def path_validation(
+    file_path: str,
+    check_for_file: bool = False,
+    check_for_file_type: Union[str, None] = None,
+) -> None:
+    """Utility function for validating the path.
+
+    Args:
+        file_path (str): Path to be validated
+        check_for_file (bool): Checks for existence of file
+        check_for_file_type (Union[str, None]): Check if file is of
+            this type
+
+    Raises:
+        PathDoesNotExist: Raises if path does not exist
+        NotAFileError: Raises if file is not present
+        InvalidFileTypePassed: Raises if invalid file type is passed
+    """
+
+    file_path = Path(file_path)
+    if not file_path.exists():
+        logger.error(f"{file_path} does not exist!")
+        raise PathDoesNotExist(file_path)
+
+    if check_for_file and file_path.is_dir():
+        logger.error(f"Expected file but got folder : {file_path} ")
+        raise NotAFileError(file_path)
+
+    if check_for_file_type and file_path.suffix != check_for_file_type:
+        raise InvalidFileTypePassed(file_path, check_for_file_type)
+
+    logger.debug(f"{file_path} validated successfully!")
+
+
+@timeit
+def read_file(file_path: str) -> dict:
+    """Utility function to read file into a python dict.
+
+    Supports json, yaml and geojson.
+
+    Args:
+        file_path (str): Path to a file to be read.
+
+    Raises:
+        FeatureNotImplementedError: Raises if invalid file is passed.
+
+    Returns:
+        dict: Python dict containing content of file.
+    """
+
+    file_path = Path(file_path)
+    logger.debug(f"Attempting to read {file_path}")
+
+    path_validation(file_path, check_for_file=True)
+
+    # Handle JSON file read
+    if file_path.suffix == ".json":
+        with open(file_path, "r") as f:
+            content = json.load(f)
+
+    # Handle YAML file read
+    elif file_path.suffix == ".yaml":
+        with open(file_path, "r") as f:
+            content = yaml.safe_load(f)
+
+    # Handle geojson file read
+    elif file_path.suffix == ".geojson":
+        with open(file_path, "r") as f:
+            content = geojson.load(f)
+
+    else:
+        logger.error(
+            f"Could not read the {file_path}, this feature is not yet implemented"
+        )
+        raise FeatureNotImplementedError(
+            f"File of type {file_path.suffix} \
+            is not yet implemented for reading purpose"
+        )
+
+    logger.debug(f"{file_path} read successfully")
+    return content
+
+
+def write_file(content: dict, file_path: str, **kwargs) -> None:
+    """Utility function to write to a file..
+
+    Supports json, yaml and geojson.
+
+    Args:
+        content (dict): Python dict content
+        file_path (str): Path to a file to be read
+        kwargs (dict): Keyword arguments passed to
+            relevant writer.
+
+    Raises:
+        FeatureNotImplementedError: Raises if invalid file type is passed.
+    """
+    file_path = Path(file_path)
+    path_validation(file_path.parent)
+
+    # Handle JSON file write
+    if file_path.suffix == ".json":
+        with open(file_path, "w") as f:
+            json.dump(content, f, **kwargs)
+
+    # Handle YAML file write
+    elif file_path.suffix == ".yaml":
+        with open(file_path, "w") as f:
+            yaml.safe_dump(content, f, **kwargs)
+
+    # Handle geojson file write
+    elif file_path.suffix == ".geojson":
+        with open(file_path, "w") as f:
+            geojson.dump(content, f, **kwargs)
+
+    else:
+        raise FeatureNotImplementedError(
+            f"File of type {file_path.suffix} \
+            is not yet implemented for writing purpose"
+        )