easysewer 0.0.1__py3-none-any.whl

easysewer/Rain.py

@@ -0,0 +1,209 @@
+"""
+Rainfall Data Management Module
+
+This module handles rainfall data input and processing, including rain gages,
+time series data, and rainfall patterns for the drainage model.
+"""
+
+from .utils import *
+
+
+def parse_swmm_datetime(date_str=None, time_str=None):
+    """Convert SWMM date and time strings to minutes since start of day
+
+    Args:
+        date_str: Optional date string in format 'MM/DD/YYYY'
+        time_str: Time string in format 'HH:MM' or 'H:MM'
+
+    Returns:
+        minutes: Integer minutes since start of day
+    """
+    if date_str is None:
+        # Just parse time when no date provided
+        hours, minutes = time_str.split(':')
+        return int(minutes) + 60 * int(hours)
+
+    # Parse date and time when both provided
+    from datetime import datetime
+    dt = datetime.strptime(f"{date_str} {time_str}", "%m/%d/%Y %H:%M")
+    return dt.hour * 60 + dt.minute
+
+
+class TimeSeries:
+    def __init__(self):
+        self.name = ''
+        self.time = []  # in minutes
+        self.value = []  # in mm
+        self.has_date = False  # whether the timeseries includes date information
+        self.start_date = None  # store the start date if available
+
+    def __repr__(self):
+        if len(self.time) == 0:
+            return 'None'
+        else:
+            interval = self.time[1] - self.time[0]
+            total = sum([(v * interval / 60) for v in self.value])
+            total = round(total, 2)
+            return f'{self.name}: {self.time[-1]}min - {total}mm'
+
+
+class RainGage:
+    """
+    Represents a rain gage station in the model.
+    
+    Defines characteristics of rainfall measurement points including data format,
+    time intervals, and data source.
+
+    Attributes:
+        name (str): Unique identifier for the rain gage
+        format (str): Format of the rainfall data (INTENSITY/VOLUME/CUMULATIVE)
+        interval (float): Recording time interval
+        snow_catch (float): Snow catch deficiency correction
+        data_source (str): Source of the rainfall data
+        time_series (str): Name of associated time series data
+    """
+    def __init__(self):
+        self.name = ''
+        self.form = ''  # INTENSIFY: mm/h
+        self.interval = ''
+        self.SCF = 1  # snow catch deficiency correction factor (use 1.0 for no adjustment)
+        self.source = ''  # timeseries name
+
+    def __repr__(self):
+        return f'RainGage<{self.name}>: {self.source}'
+
+
+class Rain:
+    """
+    Container class for managing rainfall data.
+    
+    Manages collection of rain gages and their associated time series data
+    for the drainage model.
+
+    Attributes:
+        gage_list (list): Collection of RainGage objects
+        ts_list (list): Collection of time series data
+    """
+    def __init__(self):
+        self.ts_list = []
+        self.gage_list = []
+
+    def __repr__(self):
+        if len(self.gage_list) == 0:
+            return 'None'
+        elif len(self.gage_list) == 1:
+            return f'{self.gage_list[0]}'
+        else:
+            return 'Gages'
+
+    def add_ts(self, new_ts):
+        self.ts_list.append(new_ts)
+
+    def add_gage(self, new_gage):
+        self.gage_list.append(new_gage)
+
+    def read_from_swmm_inp(self, filename):
+        from datetime import datetime
+
+        content = get_swmm_inp_content(filename, '[TIMESERIES]')
+        this_timeseries = TimeSeries()
+        this_timeseries.name = 'initial'
+
+        for line in content:
+            parts = line.split()
+
+            # Skip empty lines or invalid formats
+            if len(parts) < 3:
+                continue
+
+            # Determine if this line has date information
+            has_date = len(parts) == 4
+
+            if has_date:
+                name, date, time, value = parts
+                minutes = parse_swmm_datetime(date_str=date, time_str=time)
+            else:
+                name, time, value = parts
+                minutes = parse_swmm_datetime(time_str=time)
+
+            value = float(value)
+
+            # Handle first timeseries
+            if this_timeseries.name == 'initial':
+                this_timeseries.name = name
+                this_timeseries.has_date = has_date
+                if has_date:
+                    this_timeseries.start_date = datetime.strptime(date, "%m/%d/%Y").date()
+
+            # If we encounter a new timeseries name
+            if this_timeseries.name != name:
+                # Save the current timeseries
+                self.add_ts(this_timeseries)
+
+                # Start a new timeseries
+                this_timeseries = TimeSeries()
+                this_timeseries.name = name
+                this_timeseries.has_date = has_date
+                if has_date:
+                    this_timeseries.start_date = datetime.strptime(date, "%m/%d/%Y").date()
+
+            # Add the data point
+            this_timeseries.time.append(minutes)
+            this_timeseries.value.append(value)
+
+        # Add the last timeseries if it exists
+        if this_timeseries.name != 'initial':
+            self.add_ts(this_timeseries)
+        # rain gage section
+        content = get_swmm_inp_content(filename, '[RAINGAGES]')
+        for line in content:
+            name, form, interval, SCF, _, tise = line.split()
+            this_gage = RainGage()
+            this_gage.name = name
+            this_gage.form = form
+            this_gage.interval = interval
+            this_gage.SCF = SCF
+            this_gage.source = tise
+            self.add_gage(this_gage)
+        return 0
+
+    def write_to_swmm_inp(self, filename):
+        from datetime import datetime, timedelta
+
+        def time_minute2text(minutes):
+            minutes = int(minutes)
+            hours, left = divmod(minutes, 60)
+            text = f'{hours}:{left:02}'
+            return text
+
+        def get_date_for_minutes(start_date, minutes):
+            """Convert minutes to date string, handling day rollovers"""
+            days, remaining_minutes = divmod(minutes, 24 * 60)
+            date = start_date + timedelta(days=days)
+            return date.strftime("%m/%d/%Y")
+
+        with open(filename, 'a', encoding='utf-8') as f:
+            f.write('\n\n[TIMESERIES]\n')
+            if any(ts.has_date for ts in self.ts_list):
+                f.write(';;Name           Date       Time       Value\n')
+                f.write(';;-------------- ---------- ---------- ----------\n')
+            else:
+                f.write(';;Name       Time       Value\n')
+                f.write(';;---------- ---------- ----------\n')
+
+            for ts in self.ts_list:
+                for time, value in zip(ts.time, ts.value):
+                    if ts.has_date:
+                        date_str = get_date_for_minutes(ts.start_date, time)
+                        time_str = time_minute2text(time % (24 * 60))  # Get time within the day
+                        f.write(f'{ts.name:<14} {date_str}  {time_str}  {value:>.2f}\n')
+                    else:
+                        f.write(f'{ts.name}  {time_minute2text(time)}  {value:>.2f}\n')
+                f.write(';;\n')
+
+            f.write('\n\n[RAINGAGES]\n')
+            f.write(';;Name  Format   Interval  SCF  Source    \n')
+            f.write(';;----- -------- --------- ---- ----------\n')
+            for gage in self.gage_list:
+                f.write(f'{gage.name}  {gage.form}  {gage.interval}  {gage.SCF}  TIMESERIES  {gage.source}\n')
+            return 0

easysewer/SolverAPI.py

@@ -0,0 +1,154 @@
+"""
+pass
+"""
+import platform
+import os
+from ctypes import CDLL, c_char_p, c_int, c_double, c_float, byref, POINTER, create_string_buffer
+
+
+class SWMMSolverAPI:
+    def __init__(self):
+        #
+        system = platform.system()
+        if system == 'Windows':
+            lib_path = os.path.join(os.path.dirname(__file__), 'libs', 'win', 'swmm5.dll')
+        elif system == 'Linux':
+            lib_path = os.path.join(os.path.dirname(__file__), 'libs', 'linux', 'libswmm5.so')
+        else:
+            raise OSError('Unsupported operating system')
+
+        self.swmm = CDLL(lib_path)
+        self._set_prototypes()
+
+    def _set_prototypes(self):
+        self.swmm.swmm_run.argtypes = [c_char_p, c_char_p, c_char_p]
+        self.swmm.swmm_run.restype = c_int
+
+        self.swmm.swmm_open.argtypes = [c_char_p, c_char_p, c_char_p]
+        self.swmm.swmm_open.restype = c_int
+
+        self.swmm.swmm_start.argtypes = [c_int]
+        self.swmm.swmm_start.restype = c_int
+
+        self.swmm.swmm_step.argtypes = [POINTER(c_double)]
+        self.swmm.swmm_step.restype = c_int
+
+        self.swmm.swmm_end.argtypes = []
+        self.swmm.swmm_end.restype = c_int
+
+        self.swmm.swmm_report.argtypes = []
+        self.swmm.swmm_report.restype = c_int
+
+        self.swmm.swmm_close.argtypes = []
+        self.swmm.swmm_close.restype = c_int
+
+        self.swmm.swmm_getMassBalErr.argtypes = [POINTER(c_float), POINTER(c_float), POINTER(c_float)]
+        self.swmm.swmm_getMassBalErr.restype = c_int
+
+        self.swmm.swmm_getVersion.argtypes = []
+        self.swmm.swmm_getVersion.restype = c_int
+
+        self.swmm.swmm_getError.argtypes = [c_char_p, c_int]
+        self.swmm.swmm_getError.restype = c_int
+
+        self.swmm.swmm_getWarnings.argtypes = []
+        self.swmm.swmm_getWarnings.restype = c_int
+
+        self.swmm.swmm_getCount.argtypes = [c_int]
+        self.swmm.swmm_getCount.restype = c_int
+
+        self.swmm.swmm_getName.argtypes = [c_int, c_int, c_char_p, c_int]
+        self.swmm.swmm_getName.restype = None
+
+        self.swmm.swmm_getIndex.argtypes = [c_int, c_char_p]
+        self.swmm.swmm_getIndex.restype = c_int
+
+        self.swmm.swmm_getValue.argtypes = [c_int, c_int]
+        self.swmm.swmm_getValue.restype = c_double
+
+        self.swmm.swmm_setValue.argtypes = [c_int, c_int, c_double]
+        self.swmm.swmm_setValue.restype = None
+
+        self.swmm.swmm_getSavedValue.argtypes = [c_int, c_int, c_int]
+        self.swmm.swmm_getSavedValue.restype = c_double
+
+        self.swmm.swmm_writeLine.argtypes = [c_char_p]
+        self.swmm.swmm_writeLine.restype = None
+
+        self.swmm.swmm_decodeDate.argtypes = [c_double, POINTER(c_int), POINTER(c_int), POINTER(c_int), POINTER(c_int), POINTER(c_int), POINTER(c_int), POINTER(c_int)]
+        self.swmm.swmm_decodeDate.restype = None
+
+    def run(self, input_file, report_file, output_file):
+        return self.swmm.swmm_run(input_file.encode('utf-8'), report_file.encode('utf-8'), output_file.encode('utf-8'))
+
+    def open(self, input_file, report_file, output_file):
+        return self.swmm.swmm_open(input_file.encode('utf-8'), report_file.encode('utf-8'), output_file.encode('utf-8'))
+
+    def start(self, save_flag):
+        return self.swmm.swmm_start(save_flag)
+
+    def step(self):
+        elapsed_time = c_double()
+        result = self.swmm.swmm_step(byref(elapsed_time))
+        return result, elapsed_time.value
+
+    def end(self):
+        return self.swmm.swmm_end()
+
+    def report(self):
+        return self.swmm.swmm_report()
+
+    def close(self):
+        return self.swmm.swmm_close()
+
+    def get_mass_bal_err(self):
+        runoff_err = c_float()
+        flow_err = c_float()
+        qual_err = c_float()
+        self.swmm.swmm_getMassBalErr(byref(runoff_err), byref(flow_err), byref(qual_err))
+        return runoff_err.value, flow_err.value, qual_err.value
+
+    def get_version(self):
+        return self.swmm.swmm_getVersion()
+
+    def get_error(self, msg_len=256):
+        err_msg = create_string_buffer(msg_len)
+        self.swmm.swmm_getError(err_msg, msg_len)
+        return err_msg.value.decode('utf-8')
+
+    def get_warnings(self):
+        return self.swmm.swmm_getWarnings()
+
+    def get_count(self, obj_type):
+        return self.swmm.swmm_getCount(obj_type)
+
+    def get_name(self, obj_type, index, size=256):
+        name = create_string_buffer(size)
+        self.swmm.swmm_getName(obj_type, index, name, size)
+        return name.value.decode('utf-8')
+
+    def get_index(self, obj_type, name):
+        return self.swmm.swmm_getIndex(obj_type, name.encode('utf-8'))
+
+    def get_value(self, property, index):
+        return self.swmm.swmm_getValue(property, index)
+
+    def set_value(self, property, index, value):
+        self.swmm.swmm_setValue(property, index, value)
+
+    def get_saved_value(self, property, index, period):
+        return self.swmm.swmm_getSavedValue(property, index, period)
+
+    def write_line(self, line):
+        self.swmm.swmm_writeLine(line.encode('utf-8'))
+
+    def decode_date(self, date):
+        year = c_int()
+        month = c_int()
+        day = c_int()
+        hour = c_int()
+        minute = c_int()
+        second = c_int()
+        day_of_week = c_int()
+        self.swmm.swmm_decodeDate(date, byref(year), byref(month), byref(day), byref(hour), byref(minute), byref(second), byref(day_of_week))
+        return (year.value, month.value, day.value, hour.value, minute.value, second.value, day_of_week.value)

easysewer/UDM.py

@@ -0,0 +1,126 @@
+"""
+Urban Drainage Model (UDM) - Main Model Class
+
+This module implements the core Urban Drainage Model functionality for hydraulic simulations.
+It serves as the main interface for creating and managing drainage system models including
+nodes (junctions, outfalls), links (conduits), subcatchment areas, and rainfall data.
+
+The model supports:
+- Reading/writing SWMM .inp files
+- Managing network elements (nodes, links, areas)
+- Handling rainfall and calculation settings
+- Supporting various hydraulic elements like conduits and junctions
+"""
+
+from .Options import CalculationInformation
+from .Link import LinkList
+from .Node import NodeList
+from .Area import AreaList
+from .Rain import Rain
+from .Curve import ValueList
+import json
+from .utils import get_swmm_inp_content
+
+
+class UrbanDrainageModel:
+    """
+    Main class for managing an Urban Drainage Model.
+
+    This class serves as the central point for managing all aspects of an urban drainage
+    model including network topology, hydraulic elements, and simulation settings.
+
+    Attributes:
+        calc (CalculationInformation): Calculation and simulation settings
+        link (LinkList): Collection of conduits and other hydraulic links
+        node (NodeList): Collection of junctions, outfalls and other nodes
+        area (AreaList): Collection of subcatchment areas
+        rain (Rain): Rainfall data and settings
+        value (ValueList): Curves and patterns for various model parameters
+        label (dict): Model metadata and labeling information
+
+    Args:
+        model_path (str, optional): Path to SWMM .inp file to load. Defaults to None.
+    """
+
+    def __init__(self, model_path=None):
+        # calculation related information
+        self.calc = CalculationInformation()
+
+        # entity related information
+        self.link = LinkList()
+        self.node = NodeList()
+        self.area = AreaList()
+
+        # rain related information
+        self.rain = Rain()
+        self.value = ValueList()
+
+        # label information
+        self.label = {}
+
+        # read model from the file if provided
+        if model_path is not None:
+            self.read_inp(model_path)
+
+    def __repr__(self):
+        """Returns a string representation of the model showing key components"""
+        return f'{self.link}, {self.node}, {self.area}'
+
+    def to_inp(self, filename):
+        """
+        Writes the model to a SWMM .inp file.
+
+        Args:
+            filename (str): Path to the output .inp file
+
+        Returns:
+            int: 0 on success
+        """
+        with open(filename, 'w', encoding='utf-8') as f:
+            # Write TITLE section first
+            f.write('[TITLE]\n')
+            if self.label:
+                try:
+                    f.write(json.dumps(self.label, indent=2))
+                    f.write('\n\n')
+                except:
+                    f.write(str(self.label.get('TITLE', '')) + '\n\n')
+
+        # Continue with other sections
+        self.calc.write_to_swmm_inp(filename)
+        self.node.write_to_swmm_inp(filename)
+        self.link.write_to_swmm_inp(filename)
+        self.area.write_to_swmm_inp(filename)
+        self.rain.write_to_swmm_inp(filename)
+        self.value.write_to_swmm_inp(filename)
+        return 0
+
+    def read_inp(self, filename):
+        """
+        Reads a SWMM .inp file and populates the model.
+
+        Args:
+            filename (str): Path to the input .inp file
+
+        Returns:
+            int: 0 on success
+        """
+        # Read TITLE section
+        title_content = get_swmm_inp_content(filename, '[TITLE]')
+        if title_content:
+            try:
+                # Try to parse as JSON
+                json_text = '\n'.join(title_content)
+                self.label = json.loads(json_text)
+            except json.JSONDecodeError:
+                # If not JSON, store as plain text
+                self.label = {'TITLE': '\n'.join(title_content)}
+
+        # Continue with other sections
+        self.calc.read_from_swmm_inp(filename)
+        self.node.read_from_swmm_inp(filename)
+        self.link.read_from_swmm_inp(filename)
+        self.area.read_from_swmm_inp(filename)
+        self.rain.read_from_swmm_inp(filename)
+        self.value.read_from_swmm_inp(filename)
+        return 0

easysewer/__init__.py

@@ -0,0 +1,7 @@
+"""
+pass
+"""
+from .UDM import UrbanDrainageModel
+from .UDM import UrbanDrainageModel as Model
+from .OutputAPI import SWMMOutputAPI
+from .SolverAPI import SWMMSolverAPI

easysewer/utils.py

@@ -0,0 +1,97 @@
+"""
+Utility Functions Module
+
+This module provides helper functions for file I/O operations and data processing
+in the urban drainage model, particularly for SWMM input/output file handling.
+"""
+
+
+def get_swmm_inp_content(filename, flag):
+    """
+    Extracts content from a specific section of a SWMM input file.
+    
+    Args:
+        filename (str): Path to the SWMM input file
+        flag (str): Section identifier (e.g., '[TITLE]', '[JUNCTIONS]')
+    
+    Returns:
+        list: Lines of content from the specified section
+    """
+    flag += '\n'
+    result = []
+
+    with open(filename, 'r', encoding='utf-8') as f:
+        # getting to the flag line
+        for line in f:
+            if line == flag:
+                break
+        # adding related lines to results
+        for line in f:
+            # finish when getting to another section
+            if line[0] == '[':
+                break
+            # skip if this line is blank or annotation
+            if line == '\n' or line[0] == ';':
+                continue
+            result.append(line[0:-1])
+
+    return result
+
+
+def combine_swmm_inp_contents(content1, content2):
+    """
+    Combines two sections of SWMM input content based on matching identifiers.
+    
+    Args:
+        content1 (list): Primary content lines
+        content2 (list): Secondary content lines to merge
+    
+    Returns:
+        list: Combined content with merged information
+    """
+    # generate a name list of content1
+    index_dic = []
+    for line in content1:
+        pair = line.split()
+        index_dic.append(pair[0])
+    #
+    for line in content2:
+        pair = line.split()
+        index = index_dic.index(pair[0])
+        content1[index] = content1[index] + ' ' + ' '.join(pair[1::])
+    #
+    return content1
+
+
+def get_swmm_rpt_content(filename, flag):
+    """
+    Extracts content from a specific section of a SWMM report file.
+    
+    Args:
+        filename (str): Path to the SWMM report file
+        flag (str): Section identifier
+    
+    Returns:
+        list: Lines of content from the specified report section
+    """
+    # example:
+    # res = ut.get_swmm_rpt_content('calculate_temp/test.rpt', 'Node G80F425')
+    flag = f'  <<< {flag} >>>\n'
+    result = []
+    with open(filename, 'r', encoding='utf-8') as f:
+        # getting to the flag line
+        for line in f:
+            if line == flag:
+                break
+        # adding related lines to results
+        i = 0
+        for line in f:
+            # skip title bar ( four lines )
+            if i < 4:
+                i += 1
+                continue
+            # finish when getting to another section
+            if line == '  \n':
+                break
+            result.append(line[0:-1])
+    return result

easysewer-0.0.1.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: easysewer
+Version: 0.0.1
+Summary: An urban drainage modeling toolkit
+Author-email: Yiran Ji <yiranji@zju.edu.cn>
+License-Expression: AGPL-3.0-only
+Project-URL: Homepage, https://github.com/yourusername/easysewer
+Project-URL: Documentation, https://github.com/yourusername/easysewer#readme
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# EasySewer
+🚀 An urban drainage modeling toolkit
+> Note: Project under active development

easysewer-0.0.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+easysewer/Area.py,sha256=Y7SjlcA9byN4A3fk70D4M4hG8MulE0LLVJLqZ8FDt6c,13010
+easysewer/Curve.py,sha256=C5X_CJ9CtuYcUFqdClFkxWYZOYHhQFBxENYg9jC6Dqs,4241
+easysewer/Link.py,sha256=tZWGPg5EMcii6hfswNPp5MMz3wLdZPzuil9Sjv6OqXc,11802
+easysewer/Node.py,sha256=trtXGPLDk1gkdKMXXwJ1hUOmsS6x2mVr4wh61Lxisqk,14092
+easysewer/Options.py,sha256=zsmyDpiQO0Swsrqkzw_vow4lNKbiLsLX_0YQ6XWsSBI,18425
+easysewer/OutputAPI.py,sha256=tD6-6VjBpG-DBlmvVhb9siZ_zgEe1lD1d0h2xPr72Qw,7519
+easysewer/Rain.py,sha256=Hu_XtEXreIquf4uLxMgAiG_eRNc0OzuansDnZ1ozGAQ,7597
+easysewer/SolverAPI.py,sha256=H1KZkS_03Mv2ruSNX6-Rg_fesTwL9O6R5TRCil2eC7o,5612
+easysewer/UDM.py,sha256=DfEOFRyFR5guy7yEU_ve_XsRypXQ3k2nn5Slc5VAzOc,4385
+easysewer/__init__.py,sha256=XD2zR0vua7-FMz5brRDY9FCzF_QNkPozfrOl7dvYALc,175
+easysewer/utils.py,sha256=dkK5YwwaE2eLdiaY3YAEg78xv74TU6ff7Q3Rl3ltatI,2847
+easysewer/libs/linux/libswmm5.so,sha256=UI5v1fCZ7LU9zkjLQMJqqJtzDefkFnL1iy3jmAlFsVo,839664
+easysewer/libs/linux/swmm-output.so,sha256=248JHb0PUGyeo3tLj9fL4L114ySTSLBrUUA_k3VHnCQ,30928
+easysewer/libs/win/swmm-output.dll,sha256=tN0K2ZRk7rlQZ-cLxlGLYZ6w269uvc5JuH1oVumADD0,71168
+easysewer/libs/win/swmm5.dll,sha256=7LjGQXUyj8bdVuFzzY8-pObQV0VcUDI5KsAz-hstWls,915968
+easysewer-0.0.1.dist-info/METADATA,sha256=GGX1eS11v3_hpeMxS1QsuqwJQi9wfJzEVZfVWTja_es,586
+easysewer-0.0.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+easysewer-0.0.1.dist-info/top_level.txt,sha256=YJi065ohgpDZhPb0XuXfE6ExHMhHPlwveH40BgZ7kt4,10
+easysewer-0.0.1.dist-info/RECORD,,

easysewer-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

easysewer-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+easysewer