completor 0.1.2__py3-none-any.whl → 1.0.0__py3-none-any.whl

completor/utils.py

@@ -4,20 +4,17 @@ from __future__ import annotations
 
 import re
 import sys
-from typing import Any, overload
+from collections.abc import Mapping
+from typing import Any, Literal, NoReturn, overload
 
 import numpy as np
 import numpy.typing as npt
 import pandas as pd
 
-from completor.constants import Headers
+from completor.constants import Content, Headers, Keywords
+from completor.exceptions import CompletorError
 from completor.logger import logger
 
-try:
-    from typing import Literal, NoReturn
-except ImportError:
-    pass
-
 
 def abort(message: str, status: int = 1) -> SystemExit:
     """Exit the program with a message and exit code (1 by default).
@@ -28,8 +25,8 @@ def abort(message: str, status: int = 1) -> SystemExit:
         I.e. there were no errors, while 1 or above indicates that an error occurred. The default code is 1.
 
     Returns:
-        SystemExit: Makes type checkers happy, when using the ``raise`` keyword with this function. I.e.
-            `>>> raise abort("Something when terribly wrong")`
+        SystemExit: Makes type checkers happy when using the ``raise`` keyword with this function. I.e.
+            `>>> raise abort("Something when terribly wrong.")`
     """
     if status == 0:
         logger.info(message)
@@ -60,20 +57,6 @@ def sort_by_midpoint(
     return df.drop([_temp_column], axis=1)
 
 
-def as_data_frame(args: dict[str, Any] | None = None, **kwargs) -> pd.DataFrame:
-    """Helper function to create a data frame from a dictionary, or keywords."""
-    if (args is None and kwargs is None) or (not args and not kwargs):
-        raise ValueError("`as_data_frame` requires either a single dictionary, or keywords")
-
-    if args:
-        kwargs = args
-    data = pd.DataFrame()
-    for key, value in kwargs.items():
-        data[key] = value
-
-    return data
-
-
 @overload
 def log_and_raise_exception(message: str, kind: type = ..., throw: Literal[True] = ...) -> NoReturn: ...
 
@@ -116,7 +99,9 @@ def find_quote(string: str) -> re.Match | None:
     return re.search(rf"([{quotes}])(?:(?=(\\?))\2.)*?\1", string)
 
 
-def clean_file_line(line: str, comment_prefix: str = "--", remove_quotation_marks: bool = False) -> str:
+def clean_file_line(
+    line: str, comment_prefix: str = "--", remove_quotation_marks: bool = False, replace_tabs: bool = True
+) -> str:
     """Remove comments, tabs, newlines and consecutive spaces from a string.
 
     Also remove trailing '/' comments, but ignore lines containing a file path.
@@ -126,6 +111,7 @@ def clean_file_line(line: str, comment_prefix: str = "--", remove_quotation_mark
         comment_prefix: The prefix used to denote a comment in the file.
         remove_quotation_marks: Whether quotation marks should be removed from the line.
             Used for cleaning schedule files.
+        replace_tabs: Whether tabs should be replaced with a space.
 
     Returns:
         A cleaned line. Returns an empty string in the case of a comment or empty line.
@@ -144,7 +130,8 @@ def clean_file_line(line: str, comment_prefix: str = "--", remove_quotation_mark
     if not line:
         return ""
     # Replace tabs with spaces, remove newlines and remove trailing spaces.
-    line = line.replace("\t", " ").replace("\n", "")
+    if replace_tabs:
+        line = line.replace("\t", " ").replace("\n", "")
     # Remove quotation marks if specified
     if remove_quotation_marks:
         line = line.replace("'", " ").replace('"', " ")
@@ -183,3 +170,247 @@ def clean_file_lines(lines: list[str], comment_prefix: str = "--") -> list[str]:
         if cleaned_line:
             clean_lines.append(cleaned_line)
     return clean_lines
+
+
+def shift_array(array: npt.NDArray[Any], shift_by: int, fill_value: Any = np.nan) -> npt.NDArray[Any]:
+    """Shift an array to the left or right, similar to Pandas' shift.
+
+    Note: By chrisaycock https://stackoverflow.com/a/42642326.
+
+    Args:
+        array: Array to shift.
+        shift_by: The amount and direction (positive/negative) to shift by.
+        fill_value: The value to fill out of range values with. Defaults to np.nan.
+
+    Returns:
+        Shifted Numpy array.
+
+    """
+    result = np.empty_like(array)
+    if shift_by > 0:
+        result[:shift_by] = fill_value
+        result[shift_by:] = array[:-shift_by]
+    elif shift_by < 0:
+        result[shift_by:] = fill_value
+        result[:shift_by] = array[-shift_by:]
+    else:
+        result[:] = array
+    return result
+
+
+def get_active_wells(completion_table: pd.DataFrame, gp_perf_devicelayer: bool) -> npt.NDArray[np.str_]:
+    """Get a list of active wells specified by users.
+
+    Notes:
+        No device layer will be added for perforated wells with gravel-packed annulus.
+        Completor does nothing to gravel-packed perforated wells by default.
+        This behavior can be changed by setting the GRAVEL_PACKED_PERFORATED_DEVICELAYER keyword in the case file to true.
+
+    Args:
+        completion_table: Completion information.
+        gp_perf_devicelayer: Keyword denoting if the user wants a device layer for this type of completion.
+
+    Returns:
+        The active wells found.
+    """
+    # Need to check completion of all wells in the completion table to remove GP-PERF type wells
+    # If the user wants a device layer for this type of completion.
+    if not gp_perf_devicelayer:
+        gp_check = completion_table[Headers.ANNULUS] == Content.OPEN_ANNULUS
+        perf_check = completion_table[Headers.DEVICE_TYPE].isin(
+            [
+                Content.AUTONOMOUS_INFLOW_CONTROL_DEVICE,
+                Content.AUTONOMOUS_INFLOW_CONTROL_VALVE,
+                Content.DENSITY_ACTIVATED_RECOVERY,
+                Content.INFLOW_CONTROL_DEVICE,
+                Content.VALVE,
+                Content.INFLOW_CONTROL_VALVE,
+            ]
+        )
+        # Where annuli is "OA" or perforation is in the list above.
+        mask = gp_check | perf_check
+        if not mask.any():
+            logger.warning(
+                "There are no active wells for Completor to work on. E.g. all wells are defined with Gravel Pack "
+                "(GP) and valve type PERF. "
+                f"If you want these wells to be active set {Keywords.GRAVEL_PACKED_PERFORATED_DEVICELAYER} to TRUE."
+            )
+        return np.array(completion_table[Headers.WELL][mask].unique())
+    return np.array(completion_table[Headers.WELL].unique())
+
+
+def check_width_lines(result: str, limit: int) -> list[tuple[int, str]]:
+    """Check the width of each line versus limit.
+
+    Disregarding all content after '/' and '--' characters.
+
+    Args:
+        result: Raw text.
+        limit: The character width limit.
+
+    Raises:
+        ValueError: If there exists any data that is too long.
+    """
+    lines = result.splitlines()
+    lengths = np.char.str_len(lines)
+    lines_to_check = np.nonzero(lengths >= limit)[0]
+    too_long_lines = []
+    for line_index in lines_to_check:
+        # Well names can have slashes, therefore maxsplit must be 1.
+        cleaned_line = lines[line_index].rsplit("/", maxsplit=1)[0] + "/"
+        # Comment 'char' can be multiple and should not have maxsplit, nor the '--' added.
+        cleaned_line = cleaned_line.rsplit("--")[0]
+
+        if len(cleaned_line) > limit:
+            too_long_lines.append((line_index, lines[line_index]))
+    return too_long_lines
+
+
+def format_default_values(text: str) -> list[list[str]]:
+    """Format the data-records and resolve the repeat-mechanism.
+
+    E.g. 3* == 1* 1* 1*, 3*250 == 250 250 250.
+
+    Args:
+        text: A chunk data-record.
+
+    Returns:
+        Expanded values.
+    """
+    chunk = re.split(r"\s+/", text)[:-1]
+    expanded_data = []
+    for line in chunk:
+        new_record = ""
+        for record in line.split():
+            if not record[0].isdigit():
+                new_record += record + " "
+                continue
+            if "*" not in record:
+                new_record += record + " "
+                continue
+
+            # Handle repeats like 3* or 3*250.
+            multiplier, number = record.split("*")
+            new_record += f"{number if number else '1*'} " * int(multiplier)
+        if new_record:
+            expanded_data.append(new_record.split())
+    return expanded_data
+
+
+def find_keyword_data(keyword: str, text: str) -> list[str]:
+    """Finds the common pattern for the four keywords thats needed.
+
+    Args:
+        keyword: Current keyword.
+        text: The whole text to find matches in.
+
+    Returns:
+        The matches if any.
+
+    """
+    # Finds keyword followed by two slashes.
+    # Matches any characters followed by a newline, non-greedily, to allow for comments within the data.
+    # Matches new line followed by a single (can have leading whitespace) slash.
+    pattern = rf"^{keyword}(?:.*\n)*?\s*\/"
+    return re.findall(pattern, text, re.MULTILINE)
+
+
+def clean_raw_data(raw_record: str, keyword: str) -> list[list[str]]:
+    """Parse the record and clean its content.
+
+    Args:
+        raw_record: Raw data taken straight from schedule.
+        keyword: The current keyword.
+
+    Returns:
+        The contents of the keyword, cleaned.
+    """
+    record = re.split(rf"{keyword}\n", raw_record)
+    if len(record) != 2:
+        raise CompletorError(f"Something went wrong when reading keyword '{keyword}' from schedule:\n{raw_record}")
+    # Strip keyword and last line.
+    raw_content = record[1].splitlines()
+    if raw_content[-1].strip().startswith("/"):
+        raw_content = raw_content[:-1]
+
+    clean_content = []
+    for line in raw_content:
+        clean_line = clean_file_line(line, remove_quotation_marks=True)
+        if clean_line:
+            clean_content.append(format_default_values(clean_line)[0])
+    return clean_content
+
+
+def find_well_keyword_data(well: str, keyword: str, text: str) -> str:
+    """Find the data associated with keyword and well name, include leading comments.
+
+    Args:
+        well: Well name.
+        keyword: Keyword to search for.
+        text: Raw text to look for matches in.
+
+    Returns:
+        The correct match given keyword and well name.
+    """
+    matches = find_keyword_data(keyword, text)
+
+    lines = []
+    for match in matches:
+        if re.search(well, match) is None:
+            continue
+
+        matchlines = match.splitlines()
+        once = False
+        for i, line in enumerate(matchlines):
+            if not line:
+                # Allow empty lines in the middle of a record.
+                if once:
+                    lines.append(line)
+                continue
+            if well in line.split()[0]:
+                if keyword in [Keywords.WELL_SEGMENTS, Keywords.COMPLETION_SEGMENTS]:
+                    # These keywords should just be the entire match as they never contain more than one well.
+                    return match
+                if not once:
+                    once = True
+                    # Remove contiguous comments above the first line by looking backwards,
+                    # adding it to the replaceable text match.
+                    comments = []
+                    for prev_line in matchlines[i - 1 :: -1]:
+                        if not prev_line.strip().startswith("--") or not prev_line:
+                            break
+                        comments.append(prev_line)
+                    lines += sorted(comments, reverse=True)
+                lines.append(line)
+            elif not once:
+                continue
+            # All following comments inside data.
+            elif line.strip().startswith("--"):
+                lines.append(line)
+            else:
+                break
+
+    return str("\n".join(lines))
+
+
+def replace_preprocessing_names(text: str, mapper: Mapping[str, str] | None) -> str:
+    """Expand start and end marker pairs for well pattern recognition as needed.
+
+    Args:
+        text: Text with pre-processor reservoir modeling well names.
+        mapper: Map of old to new names.
+
+    Returns:
+        Text with reservoir simulator well names.
+    """
+    if mapper is None:
+        return text
+    start_marks = ["'", " ", "\n", "\t"]
+    end_marks = ["'", " ", " ", " "]
+    for key, value in mapper.items():
+        for start, end in zip(start_marks, end_marks):
+            my_key = start + str(key) + start
+            if my_key in text:
+                my_value = start + str(value) + end
+                text = text.replace(my_key, my_value)
+    return text

completor/visualization.py

@@ -4,7 +4,6 @@ import matplotlib.pyplot as plt  # type: ignore
 import matplotlib.ticker as ticker  # type: ignore
 from matplotlib import rcParams
 from matplotlib.axes import Axes  # type: ignore
-from matplotlib.backends.backend_pdf import PdfPages  # type: ignore
 from matplotlib.figure import Figure  # type: ignore
 
 
@@ -16,7 +15,7 @@ def update_fonts(family: str = "DejaVu Serif", size: float = 12) -> None:
         size: Font sizes.
     """
     rcParams["font.family"] = family
-    rcParams.update({"font.size": size})
+    rcParams["font.size"] = size
 
 
 def format_axis(subplot: Axes, title: str, xlabel: str, ylabel: str, categorical: bool = False) -> Axes:
@@ -133,18 +132,6 @@ def subplot_position(num_plots: int) -> tuple[int, int]:
     return list_rows[num_plots - 1], list_cols[num_plots - 1]
 
 
-def create_pdfpages(file_name: str) -> PdfPages:
-    """Create a pdf file.
-
-    Args:
-        file_name: Full name of the file without extension .pdf.
-
-    Returns:
-        PdfPages instance.
-    """
-    return PdfPages(file_name)
-
-
 def create_figure(figsize: list[int] | tuple[int, int] | None = (18, 12)) -> Figure:
     """Create a matplotlib figure.
 

completor/visualize_well.py

@@ -5,7 +5,7 @@ from matplotlib.axes import Axes  # type: ignore
 from matplotlib.figure import Figure  # type: ignore
 
 from completor import visualization
-from completor.constants import Headers
+from completor.constants import Content, Headers
 
 
 def visualize_tubing(axs: Axes, df_well: pd.DataFrame) -> Axes:
@@ -18,9 +18,9 @@ def visualize_tubing(axs: Axes, df_well: pd.DataFrame) -> Axes:
     Returns:
         Pyplot axis.
     """
-    df_device = df_well[(df_well[Headers.NUMBER_OF_DEVICES] > 0) | (df_well[Headers.DEVICE_TYPE] == "PERF")]
+    df_device = df_well[(df_well[Headers.NUMBER_OF_DEVICES] > 0) | (df_well[Headers.DEVICE_TYPE] == Content.PERFORATED)]
     if df_device.shape[0] > 0:
-        axs.plot(df_well[Headers.TUB_MD].to_numpy(), [1] * df_well.shape[0], "go-")
+        axs.plot(df_well[Headers.TUBING_MEASURED_DEPTH].to_numpy(), [1] * df_well.shape[0], "go-")
     return axs
 
 
@@ -34,21 +34,21 @@ def visualize_device(axs: Axes, df_well: pd.DataFrame) -> Axes:
     Returns:
         Pyplot axis
     """
-    df_device = df_well[(df_well[Headers.NUMBER_OF_DEVICES] > 0) | (df_well[Headers.DEVICE_TYPE] == "PERF")]
+    df_device = df_well[(df_well[Headers.NUMBER_OF_DEVICES] > 0) | (df_well[Headers.DEVICE_TYPE] == Content.PERFORATED)]
     for idx in range(df_device.shape[0]):
-        xpar = [df_device[Headers.TUB_MD].iloc[idx]] * 2
+        xpar = [df_device[Headers.TUBING_MEASURED_DEPTH].iloc[idx]] * 2
         ypar = [1.0, 2.0]
-        if df_device[Headers.DEVICE_TYPE].iloc[idx] == "PERF":
+        if df_device[Headers.DEVICE_TYPE].iloc[idx] == Content.PERFORATED:
             axs.plot(xpar, ypar, "ro-", markevery=[1])
-        elif df_device[Headers.DEVICE_TYPE].iloc[idx] == "AICD":
+        elif df_device[Headers.DEVICE_TYPE].iloc[idx] == Content.AUTONOMOUS_INFLOW_CONTROL_DEVICE:
             axs.plot(xpar, ypar, "rD-", markevery=[1])
-        elif df_device[Headers.DEVICE_TYPE].iloc[idx] == "ICD":
+        elif df_device[Headers.DEVICE_TYPE].iloc[idx] == Content.INFLOW_CONTROL_DEVICE:
             axs.plot(xpar, ypar, "rs-", markevery=[1])
-        elif df_device[Headers.DEVICE_TYPE].iloc[idx] == "VALVE":
+        elif df_device[Headers.DEVICE_TYPE].iloc[idx] == Content.VALVE:
             axs.plot(xpar, ypar, "rv-", markevery=[1])
-        elif df_device[Headers.DEVICE_TYPE].iloc[idx] == "DAR":
+        elif df_device[Headers.DEVICE_TYPE].iloc[idx] == Content.DENSITY_ACTIVATED_RECOVERY:
             axs.plot(xpar, ypar, "rP-", markevery=[1])
-        elif df_device[Headers.DEVICE_TYPE].iloc[idx] == "AICV":
+        elif df_device[Headers.DEVICE_TYPE].iloc[idx] == Content.AUTONOMOUS_INFLOW_CONTROL_VALVE:
             axs.plot(xpar, ypar, "r*-", markevery=[1])
     return axs
 
@@ -67,15 +67,15 @@ def visualize_annulus(axs: Axes, df_well: pd.DataFrame) -> Axes:
     branches = df_well[Headers.ANNULUS_ZONE].unique()
     for branch in branches:
         df_branch = df_annulus[df_annulus[Headers.ANNULUS_ZONE] == branch]
-        xpar = df_branch[Headers.TUB_MD].to_numpy()
+        xpar = df_branch[Headers.TUBING_MEASURED_DEPTH].to_numpy()
         ypar = [3.0] * len(xpar)
         axs.plot(xpar, ypar, "bo-")
         # find the first connection in branches
         df_annulus_with_connection_to_tubing = df_branch[
-            (df_branch[Headers.NUMBER_OF_DEVICES] > 0) | (df_branch[Headers.DEVICE_TYPE] == "PERF")
+            (df_branch[Headers.NUMBER_OF_DEVICES] > 0) | (df_branch[Headers.DEVICE_TYPE] == Content.PERFORATED)
         ]
         for idx in range(df_annulus_with_connection_to_tubing.shape[0]):
-            xpar = [df_annulus_with_connection_to_tubing[Headers.TUB_MD].iloc[idx]] * 2
+            xpar = [df_annulus_with_connection_to_tubing[Headers.TUBING_MEASURED_DEPTH].iloc[idx]] * 2
             ypar = [2.0, 3.0]
             if idx == 0:
                 axs.plot(xpar, ypar, "bo-", markevery=[1])
@@ -105,28 +105,30 @@ def visualize_reservoir(axs: Axes, ax_twinx: Axes, df_reservoir: pd.DataFrame) -
         if df_reservoir[Headers.ANNULUS_ZONE].iloc[idx] > 0:
             axs.annotate(
                 "",
-                xy=(df_reservoir[Headers.TUB_MD].iloc[idx], 3.0),
-                xytext=(df_reservoir[Headers.MD].iloc[idx], 4.0),
+                xy=(df_reservoir[Headers.TUBING_MEASURED_DEPTH].iloc[idx], 3.0),
+                xytext=(df_reservoir[Headers.MEASURED_DEPTH].iloc[idx], 4.0),
                 arrowprops=dict(facecolor="black", shrink=0.05, width=0.5, headwidth=4.0),
             )
         else:
             if (
                 df_reservoir[Headers.NUMBER_OF_DEVICES].iloc[idx] > 0
-                or df_reservoir[Headers.DEVICE_TYPE].iloc[idx] == "PERF"
+                or df_reservoir[Headers.DEVICE_TYPE].iloc[idx] == Content.PERFORATED
             ):
                 axs.annotate(
                     "",
-                    xy=(df_reservoir[Headers.TUB_MD].iloc[idx], 2.0),
-                    xytext=(df_reservoir[Headers.MD].iloc[idx], 4.0),
+                    xy=(df_reservoir[Headers.TUBING_MEASURED_DEPTH].iloc[idx], 2.0),
+                    xytext=(df_reservoir[Headers.MEASURED_DEPTH].iloc[idx], 4.0),
                     arrowprops=dict(facecolor="black", shrink=0.05, width=0.5, headwidth=4.0),
                 )
     # get connection factor
     if "1*" not in df_reservoir[Headers.CONNECTION_FACTOR].to_numpy().tolist():
         max_cf = max(df_reservoir[Headers.CONNECTION_FACTOR].to_numpy())
-        ax_twinx.plot(df_reservoir[Headers.MD], df_reservoir[Headers.CONNECTION_FACTOR], "k-")
+        ax_twinx.plot(df_reservoir[Headers.MEASURED_DEPTH], df_reservoir[Headers.CONNECTION_FACTOR], "k-")
         ax_twinx.invert_yaxis()
         ax_twinx.set_ylim([max_cf * 5.0 + 1e-5, 0])
-        ax_twinx.fill_between(df_reservoir[Headers.MD], 0, df_reservoir[Headers.CONNECTION_FACTOR], alpha=0.5)
+        ax_twinx.fill_between(
+            df_reservoir[Headers.MEASURED_DEPTH], 0, df_reservoir[Headers.CONNECTION_FACTOR], alpha=0.5
+        )
 
     return axs, ax_twinx
 
@@ -183,14 +185,14 @@ def visualize_well(
     laterals = df_well[Headers.LATERAL].unique()
     if isinstance(segment_length, float):
         if segment_length >= 0.0:
-            max_md = max(df_well[Headers.TUB_MD].to_numpy())
-            min_md = min(df_well[Headers.TUB_MD].to_numpy())
+            max_md = max(df_well[Headers.TUBING_MEASURED_DEPTH].to_numpy())
+            min_md = min(df_well[Headers.TUBING_MEASURED_DEPTH].to_numpy())
         else:
-            max_md = max(df_reservoir[Headers.MD].to_numpy())
-            min_md = min(df_reservoir[Headers.MD].to_numpy())
+            max_md = max(df_reservoir[Headers.MEASURED_DEPTH].to_numpy())
+            min_md = min(df_reservoir[Headers.MEASURED_DEPTH].to_numpy())
     elif isinstance(segment_length, str):
-        max_md = max(df_well[Headers.TUB_MD].to_numpy())
-        min_md = min(df_well[Headers.TUB_MD].to_numpy())
+        max_md = max(df_well[Headers.TUBING_MEASURED_DEPTH].to_numpy())
+        min_md = min(df_well[Headers.TUBING_MEASURED_DEPTH].to_numpy())
     else:
         raise TypeError(f"segment_length has invalid type ({type(segment_length)})")
     for lateral_idx, lateral in enumerate(laterals):