completor 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

completor/main.py

@@ -7,6 +7,7 @@ import os
 import re
 import sys
 import time
+from pathlib import Path
 
 from matplotlib.backends.backend_pdf import PdfPages  # type: ignore
 from tqdm import tqdm
@@ -15,15 +16,18 @@ from completor import create_output, parse, read_schedule, utils
 from completor.constants import Keywords, ScheduleData
 from completor.exceptions.clean_exceptions import CompletorError
 from completor.get_version import get_version
+from completor.icv_file_handling import IcvFileHandling
+from completor.initialization import Initialization
 from completor.launch_args_parser import get_parser
 from completor.logger import handle_error_messages, logger
-from completor.read_casefile import ReadCasefile
+from completor.read_casefile import ICVReadCasefile, ReadCasefile
 from completor.utils import (
-    abort,
     clean_file_lines,
     clean_raw_data,
+    completion_keyword_in_file,
     find_keyword_data,
     find_well_keyword_data,
+    icvc_keyword_in_file,
     replace_preprocessing_names,
 )
 from completor.wells import Well
@@ -76,7 +80,7 @@ def get_content_and_path(case_content: str, file_path: str | None, keyword: str)
 
 def create(
     case_file: str, schedule: str, new_file: str, show_fig: bool = False, paths: tuple[str, str] | None = None
-) -> tuple[ReadCasefile, Well | None]:
+) -> tuple[ReadCasefile, Well | None, list[tuple[str, int]]]:
     """Create and write the advanced schedule file from input case- and schedule files.
 
     Args:
@@ -87,10 +91,13 @@ def create(
         paths: Optional additional paths.
 
     Returns:
-        The case and schedule file, the well and output object.
+        - ReadCasefile object.
+        - Well object or None if no well was found.
+        - Well segment list or None if no update of segment list.
     """
     case = ReadCasefile(case_file=case_file, schedule_file=schedule, output_file=new_file)
     active_wells = utils.get_active_wells(case.completion_table, case.gp_perf_devicelayer)
+    well_segment_list: list[tuple[str, int]] = []
     pdf = None
     figure_name = None
     if show_fig:
@@ -109,6 +116,7 @@ def create(
     schedule = re.sub(r"[^\S\r\n]+$", "", schedule, flags=re.MULTILINE)
     meaningful_data: ScheduleData = {}
 
+    well_segment_list = []
     try:
         # Find the old data for each of the four main keywords.
         for chunk in find_keyword_data(Keywords.WELL_SPECIFICATION, schedule):
@@ -132,7 +140,9 @@ def create(
             except KeyError:
                 logger.warning(f"Well '{well_name}' is written in case file but does not exist in schedule file.")
                 continue
-            compdat, welsegs, compsegs, bonus = create_output.format_output(well, case, pdf)
+            compdat, welsegs, compsegs, bonus, df_icv = create_output.format_output(well, case, pdf)
+            if len(df_icv) > 0:
+                get_icv_segment(well_segment_list, df_icv)
             for keyword in [Keywords.COMPLETION_SEGMENTS, Keywords.WELL_SEGMENTS, Keywords.COMPLETION_DATA]:
                 old_data = find_well_keyword_data(well_name, keyword, schedule)
                 if not old_data:
@@ -166,7 +176,14 @@ def create(
     if err is not None:
         raise err
 
-    return case, well
+    return case, well, well_segment_list
+
+
+def get_icv_segment(well_segment_list, icv_dataframe):
+    for row in range(len(icv_dataframe)):
+        well_name = icv_dataframe.iloc[row]["WELL"]
+        segment_number = int(icv_dataframe.iloc[row]["START_SEGMENT_NUMBER"])
+        well_segment_list.append((well_name, segment_number))
 
 
 def main() -> None:
@@ -197,18 +214,17 @@ def main() -> None:
     schedule_file_content, inputs.schedulefile = get_content_and_path(
         case_file_content, inputs.schedulefile, Keywords.SCHEDULE_FILE
     )
-
-    if isinstance(schedule_file_content, str):
-        parse.read_schedule_keywords(clean_file_lines(schedule_file_content.splitlines()), Keywords.main_keywords)
+    # If ICVC exists, it should not be mandatory to have whole schedule files
+    # Check on both schedule and case files first
+    if completion_keyword_in_file(inputs.inputfile) and not icvc_keyword_in_file(inputs.inputfile):
+        if isinstance(schedule_file_content, str):
+            parse.read_schedule_keywords(clean_file_lines(schedule_file_content.splitlines()), Keywords.main_keywords)
 
     _, inputs.outputfile = get_content_and_path(case_file_content, inputs.outputfile, Keywords.OUT_FILE)
 
     if inputs.outputfile is None:
         if inputs.schedulefile is None:
-            raise ValueError(
-                "Could not find a path to schedule file. "
-                f"It must be provided as a input argument or within the case files keyword '{Keywords.SCHEDULE_FILE}'."
-            )
+            raise ValueError("Could not find a path to schedule file. It must be provided as a input argument.")
         inputs.outputfile = inputs.schedulefile.split(".")[0] + "_advanced.wells"
 
     paths_input_schedule = (inputs.inputfile, inputs.schedulefile)
@@ -217,16 +233,69 @@ def main() -> None:
     logger.debug("-" * 60)
     start_a = time.time()
 
-    handle_error_messages(create)(
+    case, well, well_start_segments = handle_error_messages(create)(
         case_file_content, schedule_file_content, inputs.outputfile, inputs.figure, paths=paths_input_schedule
     )
+    if icvc_keyword_in_file(inputs.inputfile):
+        # start running ICV Control
+        # the input schedule file to second run of ICV Control is the output file from Completor
+        # therefore
+
+        inputs.schedulefile = inputs.outputfile
+        inputs.schedulefile = os.path.abspath(inputs.schedulefile)
+
+        if inputs.outputfile is not None:
+
+            schedule_content, inputs.schedulefile = get_content_and_path(
+                case_file_content, inputs.schedulefile, Keywords.SCHEDULE_FILE
+            )
+            inputs.outputfile, inputs.outputdirectory = get_output_filename_and_directory(inputs)
+
+            if inputs.inputfile is not None:
+                create_icvc(case_file_content, schedule_content, inputs, well_start_segments)
 
     logger.debug("Total runtime: %d", (time.time() - start_a))
     logger.debug("-" * 60)
 
 
-if __name__ == "__main__":
-    try:
-        main()
-    except CompletorError as e:
-        raise abort(str(e)) from e
+def get_output_filename_and_directory(inputs) -> tuple[str, str]:
+    """Get the output filename and directory from the user input.
+
+    Args:
+        arguments: Arguments from the command line.
+
+    Returns:
+        output_filename: The output filename.
+        output_directory: The output directory.
+    """
+    if inputs.outputfile:
+        output_path = Path(inputs.outputfile)
+        output_filename = f"{output_path.name}"
+    else:
+        output_path = Path(inputs.schedulefile)
+        output_filename = f"{output_path.stem}.sch"
+
+    # use cwd as output directory if the output_path is just a filename. e.g. output.sch
+    output_directory = str(Path.cwd() if output_path.parent == Path(".") else output_path.parent)
+    return output_filename, output_directory
+
+
+def create_icvc(case_content: str, schedule_content: str | None, inputs, new_segments: str):
+    """
+    Create ICV-control schedule- and include files from input case- and schedule files.
+
+    Args:
+        input_case_content: Input case file.
+        schedule_content: Input schedule file.
+        arguments: Arguments from the command line.
+    """
+
+    case = ICVReadCasefile(case_content, schedule_content, new_segments)
+    initials = Initialization(case, schedule_content)
+    file_data = {
+        "output_file_name": inputs.outputfile,
+        "output_directory": inputs.outputdirectory,
+        "schedule_file_path": inputs.schedulefile,
+        "input_case_file": inputs.inputfile,
+    }
+    IcvFileHandling(file_data, initials)

completor/parse.py

@@ -338,8 +338,8 @@ def get_welsegs_table(collections: list[ContentCollection]) -> tuple[pd.DataFram
             try:
                 header_table: npt.NDArray[np.unicode_] | pd.DataFrame
                 record_table: npt.NDArray[np.unicode_] | pd.DataFrame
-                header_table = np.row_stack((header_table, header_collection))
-                record_table = np.row_stack((record_table, record_collection))
+                header_table = np.vstack((header_table, header_collection))
+                record_table = np.vstack((record_table, record_collection))
             except NameError:
                 # First iteration
                 header_table = np.asarray(header_collection)
@@ -394,7 +394,7 @@ def get_welspecs_table(collections: list[ContentCollection]) -> pd.DataFrame:
             if welspecs_table is None:
                 welspecs_table = np.copy(the_collection)
             else:
-                welspecs_table = np.row_stack((welspecs_table, the_collection))
+                welspecs_table = np.vstack((welspecs_table, the_collection))
 
     if welspecs_table is None:
         raise ValueError(f"Collection does not contain the '{Keywords.WELL_SPECIFICATION}' keyword")
@@ -424,7 +424,7 @@ def get_compdat_table(collections: list[ContentCollection]) -> pd.DataFrame:
             if compdat_table is None:
                 compdat_table = np.copy(the_collection)
             else:
-                compdat_table = np.row_stack((compdat_table, the_collection))
+                compdat_table = np.vstack((compdat_table, the_collection))
     if compdat_table is None:
         raise ValueError(f"Collection does not contain the '{Keywords.COMPLETION_DATA}' keyword")
     compdat_table = pd.DataFrame(
@@ -472,7 +472,7 @@ def get_compsegs_table(collections: list[ContentCollection]) -> pd.DataFrame:
             if compsegs_table is None:
                 compsegs_table = np.copy(the_collection)
             else:
-                compsegs_table = np.row_stack((compsegs_table, the_collection))
+                compsegs_table = np.vstack((compsegs_table, the_collection))
 
     if compsegs_table is None:
         raise ValueError(f"Collection does not contain the '{Keywords.COMPLETION_SEGMENTS}' keyword")