schedule-reader 0.7.0__py3-none-any.whl

schedule_reader/__init__.py

@@ -0,0 +1,81 @@
+"""
+A set of functions to read and process the schedule data from a .DATA file, including functions to extract the WELSPECS, COMPDAT, WCONPROD, WCONINJE, WCONHIST, WCONINJH, and WLIST keywords from the schedule dictionary and return a DataFrame of the corresponding data by DATES. Also includes functions to read and process the property keywords in the .DATA file, such as DIMENS, PORO, PERMX, etc.
+
+developed by: Martin Araya
+email: martinaraya@gmail.com
+"""
+
+import pandas as pd
+from .data_reader import read_data
+from .welspec import extract_welspecs, extract_welspecl, extract_wellspec, extract_welspec2
+from .compdat import extract_compdat, extract_compdatl, extract_compdat2
+from .wcon import extract_wconprod, extract_wconinje, extract_wconhist, extract_wconinjh
+from .wlist import extract_wlist
+from .property_keywords import read_keyword_from_include, expand_keyword, ijk_index, get_dimens
+from .schedule_keywords import extract_keyword
+from .counter import start_counter
+
+__all__ = ['compdat2df', 'welspecs2df', 'property2df', 'start_counter']
+__version__ = '0.7.0'
+__release__ = 20260228
+
+
+def compdat2df(path, encoding='cp1252', verbose=False):
+    if type(path) is dict:
+        return extract_compdat2(path)
+    return extract_compdat2(read_data(path, encoding=encoding, verbose=verbose))
+
+def welspecs2df(path, encoding='cp1252', verbose=False):
+    if type(path) is dict:
+        return extract_welspec2(path)
+    return extract_welspec2(read_data(path, encoding=encoding, verbose=verbose))
+
+def wconprod2df(path, encoding='cp1252', verbose=False):
+    if type(path) is dict:
+        return extract_wconprod(path)
+    return extract_wconprod(read_data(path, encoding=encoding, verbose=verbose))
+
+def wconinje2df(path, encoding='cp1252', verbose=False):
+    if type(path) is dict:
+        return extract_wconinje(path)
+    return extract_wconinje(read_data(path, encoding=encoding, verbose=verbose))
+
+def wconhist2df(path, encoding='cp1252', verbose=False):
+    if type(path) is dict:
+        return extract_wconhist(path)
+    return extract_wconhist(read_data(path, encoding=encoding, verbose=verbose))
+
+def wconinjh2df(path, encoding='cp1252', verbose=False):
+    if type(path) is dict:
+        return extract_wconinjh(path)
+    return extract_wconinjh(read_data(path, encoding=encoding, verbose=verbose))
+
+def wlist2df(path, encoding='cp1252', verbose=False):
+    if type(path) is dict:
+        return extract_wlist(path)
+    return extract_wlist(read_data(path, encoding=encoding, verbose=verbose))
+
+def keyword2df(path, keyword, record_names=[], encoding='cp1252', verbose=False):
+    record_names = None if len(record_names) == 0 else record_names
+    if type(path) is dict:
+        return extract_keyword(path, keyword=keyword, record_names=record_names)
+    return extract_keyword(
+        read_data(path, encoding=encoding, verbose=verbose),
+        keyword=keyword, record_names=record_names)
+
+def property2df(path, keyword, dimens=(None, None, None), encoding='cp1252', verbose=False, parse_to=None):       
+    keyword_data = expand_keyword(read_keyword_from_include(path, keyword, encoding=encoding))
+    if dimens[0] is not None and dimens[1] is not None and dimens[2] is not None:
+        cells = ijk_index(dimens[0], dimens[1], dimens[2])
+        output = pd.Series(
+            keyword_data.split(),
+            index=pd.MultiIndex.from_tuples(cells),
+            name=keyword).reset_index()
+        output.columns = ['I', 'J', 'K', keyword]
+        output[['I', 'J', 'K']] = output[['I', 'J', 'K']].astype(int)
+        if parse_to is None:
+            parse_to = int if keyword.endswith('NUM') else float
+        output[keyword] = output[keyword].astype(parse_to)
+        return output
+    else:
+        return keyword_data

schedule_reader/compdat.py

@@ -0,0 +1,153 @@
+"""
+This module contains functions to extract and process the COMPDAT keyword from the schedule dictionary.
+The COMPDAT keyword defines the completion data for wells in the reservoir simulation model. It includes information such as the well name, location, status, and other parameters related to the well completion.
+The functions in this module will extract the COMPDAT data from the schedule dictionary, process it, and return it as a pandas DataFrame for further analysis and use in reservoir simulation models.
+
+The main functions in this module are:
+- `extract_compdat`: Extracts the COMPDAT keyword from the schedule dictionary and returns a DataFrame of COMPDAT data by DATES.
+- `extract_compdatl`: Extracts the COMPDATL keyword from the schedule dictionary and returns a DataFrame of COMPDATL data by DATES.
+- `extract_compdatm`: Alias for `extract_compdatl`.
+
+developed by: Martin Araya
+email: martinaraya@gmail.com
+"""
+
+import pandas as pd
+from .dates import parse_dates
+from .schedule_keywords import extract_keyword
+from .welspec import extract_welspecs, extract_welspecl
+
+__version__ = '0.7.0'
+__release__ = 20260228
+
+
+def _defaultIJ(well, date, IJ, welspec_table):
+    """
+    Helper function to find the I and J coordinates for a well, from its WELSPECS definition.
+    Used when the I or J coordinates are defaulted in the COMPDAT keyword.
+
+    Params:
+        well: str
+        date: str or datetime
+        IJ: str 'I' 'J'
+            the coordinate to be extracted
+        welspecs_table: pandas.DataFrame
+            A DataFrame containing at least the 'date', 'well', 'I' and 'J' data from the WELSPEC keyword.
+            This DataFrame is prepared by the function `extract_welspecs`. It is automatically called by the function `extract_compdat` if required.
+    """
+    return welspec_table[(welspec_table['well'] == well) & (welspec_table['date'] <= date), IJ].iloc[-1]
+
+
+def extract_compdat(schedule_dict:dict) -> pd.DataFrame:
+    """
+    Shortcut for `extract_keyword` for the COMPDAT keyword.
+    Extract the COMPDAT keyword from the schedule dictionary and return a DataFrame of COMPDAT data by DATES.
+
+    Params:
+        schedule_dict: dict
+            shedule dictionary prepared by the .data_reader.read_data function
+
+    Return:
+        pandas.DataFrame
+    """
+    compdat_columns = ['date', 'well', 'I', 'J', 'K_up', 'K_low', 'status', 'saturation table',
+                       'transimissibility factor', 'well bore diameter', 'Kh', 'skin', 'D-factor', 'direction',
+                       'pressure equivalent radius']
+    compdat_table = extract_keyword(schedule_dict, 'COMPDAT', compdat_columns)  # {}
+    if len(compdat_table) > 0:
+        compdat_table['date'] = parse_dates(
+            compdat_table['date'].to_list())  # to parse dates exactly as stated by DATES eclipse format
+        compdat_table['well'] = [well.strip("'") for well in compdat_table['well']]
+        compdat_table['well'] = compdat_table['well'].astype('string').astype('category', errors='ignore')
+        compdat_table = compdat_table.replace('1*', None).replace("'1*'", None)
+        to_int = ['I', 'J', 'K_up', 'K_low']
+        compdat_table[to_int] = compdat_table[to_int].astype('string').fillna('0').astype(int, errors='ignore')
+        if 0 in compdat_table['I'].values or 0 in compdat_table['J'].values:
+            welspecs_table = extract_welspecs(schedule_dict)
+            if 0 in compdat_table['I'].values:
+                compdat_table['I'] = [compdat_table['I'].iloc[r] if compdat_table['I'].iloc[r] > 0 else _defaultIJ(
+                    compdat_table['date'].iloc[r], compdat_table['date'].iloc[r], 'I', welspecs_table) for r in
+                                      len(compdat_table)]
+            if 0 in compdat_table['J'].values:
+                compdat_table['J'] = [compdat_table['I'].iloc[r] if compdat_table['I'].iloc[r] > 0 else _defaultIJ(
+                    compdat_table['date'].iloc[r], compdat_table['date'].iloc[r], 'J', welspecs_table) for r in
+                                      len(compdat_table)]
+        to_float = ['transimissibility factor', 'well bore diameter', 'Kh', 'skin', 'D-factor',
+                    'pressure equivalent radius']
+        compdat_table[to_float] = compdat_table[to_float].astype(float, errors='ignore')
+        compdat_table['status'] = compdat_table['status'].astype('string').fillna('OPEN').astype('category', errors='ignore').cat.set_categories(['AUTO', 'OPEN', 'SHUT', 'HEAT'], rename=True)
+        compdat_table['skin'] = compdat_table['skin'].fillna(0.0)
+        compdat_table['direction'] = compdat_table['direction'].astype('string').fillna('Z').astype('category', errors='ignore').cat.set_categories(['X', 'Y', 'Z', 'FX', 'FY'], rename=True)
+    return compdat_table
+
+
+def extract_compdatl(schedule_dict:dict) -> pd.DataFrame:
+    """
+    Shortcut for `extract_keyword` for the COMPDAT keyword.
+    Extract the COMPDAT keyword from the schedule dictionary and return a DataFrame of COMPDATL data by DATES.
+
+    Params:
+        schedule_dict: dict
+            schedule dictionary prepared by the .data_reader.read_data function
+
+    Return:
+        pandas.DataFrame
+    """
+    compdatl_columns = ['date', 'well', 'local grid', 'I', 'J', 'K_up', 'K_low', 'status', 'saturation table',
+                        'transimissibility factor', 'well bore diameter', 'Kh', 'skin', 'D-factor', 'direction',
+                        'pressure equivalent radius']
+    compdatl_table = extract_keyword(schedule_dict, 'COMPDATL', compdatl_columns)  # {}
+    if len(compdatl_table) > 0:
+        compdatl_table['date'] = parse_dates(
+            compdatl_table['date'].to_list())  # to parse dates exactly as stated by DATES eclipse format
+        compdatl_table['well'] = [well.strip("'") for well in compdatl_table['well']]
+        compdatl_table['well'] = compdatl_table['well'].astype('category', errors='ignore')
+        compdat_table = compdat_table.replace('1*', None).replace("'1*'", None)
+        to_int = ['I', 'J', 'K_up', 'K_low']
+        compdatl_table[to_int] = compdatl_table[to_int].astype('string').fillna('0').astype(int, errors='ignore')
+        if 0 in compdatl_table['I'].values or 0 in compdatl_table['J'].values:
+            welspecl_table = extract_welspecl(schedule_dict)
+            if 0 in compdatl_table['I'].values:
+                compdatl_table['I'] = [compdatl_table['I'].iloc[r] if compdatl_table['I'].iloc[r] > 0 else _defaultIJ(
+                    compdatl_table['date'].iloc[r], compdatl_table['date'].iloc[r], 'I', welspecl_table) for r in
+                                       len(compdatl_table)]
+            if 0 in compdatl_table['J'].values:
+                compdatl_table['J'] = [compdatl_table['I'].iloc[r] if compdatl_table['I'].iloc[r] > 0 else _defaultIJ(
+                    compdatl_table['date'].iloc[r], compdatl_table['date'].iloc[r], 'J', welspecl_table) for r in
+                                       len(compdatl_table)]
+        to_float = ['transimissibility factor', 'well bore diameter', 'Kh', 'skin', 'D-factor',
+                    'pressure equivalent radius']
+        compdatl_table[to_float] = compdatl_table[to_float].astype(float, errors='ignore')
+        compdatl_table['status'] = compdatl_table['status'].astype('string').fillna('OPEN').astype('category', errors='ignore').cat.set_categories(['AUTO', 'OPEN', 'SHUT', 'HEAT'], rename=True)
+        compdatl_table['skin'] = compdatl_table['skin'].fillna(0.0)
+        compdatl_table['direction'] = compdatl_table['direction'].astype('string').fillna('Z').astype('category', errors='ignore').cat.set_categories(['X', 'Y', 'Z', 'FX', 'FY'], rename=True)
+    return compdatl_table
+
+
+def extract_compdatm(schedule_dict:dict) -> pd.DataFrame:
+    """
+    alias for extract_compdatl
+    """
+    return extract_compdatl(schedule_dict)
+
+
+def extract_compdat2(schedule_dict:dict) -> pd.DataFrame:
+    """
+    Extract COMPDAT, COMPDATL and COMPDATM from the schedule dictionary and return a DataFrame of COMPDAT(s) data by DATES.
+
+    Params:
+        schedule_dict: dict
+            schedule dictionary prepared by the .data_reader.read_data function
+
+    Return:
+        pandas.DataFrame
+    """
+    compdat = extract_compdat(schedule_dict)
+    compdatl = extract_compdatl(schedule_dict)
+
+    if len(compdat) > 0 and len(compdatl) > 0:
+        return pd.concat([compdat, compdatl], axis=0, ignore_index=False)
+    elif len(compdatl) > 0:
+        return compdatl
+    else:
+        return compdat

schedule_reader/counter.py

@@ -0,0 +1,66 @@
+"""
+A simple counter class that can be used to count the number of iterations in a loop. It can be initialized with a starting value and a step size, and it has methods to increment, decrement, and get the current value of the counter. It also has a __call__ method that can be used to get the next value of the counter or the current value without incrementing it. The class also has __add__, __sub__, and __mult__ methods to perform arithmetic operations on the counter. The start_counter function is a helper function to create a new Counter instance with a given starting value.
+
+developed by: Martin Araya
+email: martinaraya@gmail.com
+"""
+__version__ = '0.7.0'
+__release__ = 20260228
+
+class Counter(object):
+    """A simple counter that can be used to count the number of iterations in a loop."""
+    def __init__(self, start: int = 0, step: int = 1):
+        """Initialize the counter with a starting value and a step size."""
+        if step == 0:
+            raise ValueError(f"The `step` can't be zero!")
+        self.start = start
+        self.step = step
+        self.current = start - step
+
+    def next(self):
+        """Increment the counter by the step size and return the current value."""
+        self.current += self.step
+        return self.current
+
+    def curr(self):
+        """Return the current value of the counter without incrementing it."""
+        return self.current if self.current >= self.start else self.start
+
+    def prev(self):
+        """Decrement the counter by the step size and return the current value."""
+        self.current -= self.step
+
+    def __call__(self, count=True):
+        """Return the next value of the counter if `count` is True, otherwise return the current value."""
+        if count is None:
+            return None
+        elif count:
+            return self.next()
+        elif not count:
+            return self.curr()
+        else:
+            return None
+
+    def __add__(self, other: int):
+        """Add a value to the current count and return the new count."""
+        self.current = self.curr + other
+        return self.curr()
+
+    def __sub__(self, other: int):
+        """Subtract a value from the current count and return the new count."""
+        self.current = self.curr - other
+        return self.curr()
+
+    def __mult__(self, other: int):
+        """Multiply the current count by a value and return the new count."""
+        self.current = self.curr * other
+        return self.curr()
+
+    def __repr__(self):
+        """Return a string representation of the counter."""
+        return f"{self.curr()} counted"
+
+
+def start_counter(start: int):
+    """Start a counter with a given starting value."""
+    return Counter(start)