completor 1.1.3__tar.gz → 1.3.0__tar.gz

{completor-1.1.3 → completor-1.3.0}/PKG-INFO

@@ -1,29 +1,29 @@
 Metadata-Version: 2.1
 Name: completor
-Version: 1.1.3
+Version: 1.3.0
 Summary: Advanced multi-segmented well completion tool.
 Home-page: https://github.com/equinor/completor
 License: LGPL-3.0-only
 Author: Equinor ASA
 Author-email: opensource@equinor.com
-Requires-Python: >=3.11,<4.0
+Requires-Python: >=3.11,<3.14
 Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: ert
 Provides-Extra: test
-Requires-Dist: ert (>=12,<13) ; extra == "ert"
+Requires-Dist: ert (>=14,<15) ; extra == "ert"
 Requires-Dist: matplotlib (>=3.9,<4.0)
-Requires-Dist: numpy (>=1.26,<3.0)
+Requires-Dist: numpy (>=2.0,<3.0)
 Requires-Dist: pandas (>=2.2,<3.0)
 Requires-Dist: pytest (>=8.3,<9.0) ; extra == "test"
 Requires-Dist: pytest-env (>=1,<2) ; extra == "test"
 Requires-Dist: pytest-xdist (>=3.6,<4.0) ; extra == "test"
 Requires-Dist: rstcheck-core (>=1.2,<2.0) ; extra == "test"
-Requires-Dist: scipy (>=1.14,<2.0)
 Requires-Dist: tqdm (>=4.66,<5.0)
 Project-URL: Bug Tracker, https://github.com/equinor/completor/issues
 Project-URL: Documentation, https://equinor.github.io/completor
@@ -44,7 +44,7 @@ Detailed documentation for usage of completor can be found at https://equinor.gi
 ## Getting started as a user
 
 ### Prerequisites
-* [Python](https://www.python.org/), version 3.11
+* [Python](https://www.python.org/), version 3.11 or 3.13.
 * [ERT](https://github.com/equinor/ert) (optional, and only available on Linux.)
 
 ### Installation
@@ -85,7 +85,7 @@ and making a pull request.
 See [Contribution Document](documentation/docs/contribution_guide.mdx) on how to contribute.
 
 ### Install completor as dev
-In order to run Completor® you need to have versions of [Python 3.11](https://www.python.org/downloads/) installed.
+In order to run Completor® you need to have versions of [Python 3.11, 3.12 or 3.13](https://www.python.org/downloads/) installed.
 #### Source code
 Clone the [Completor® repository](https://github.com/equinor/completor) to get the source code.
 ```bash

{completor-1.1.3 → completor-1.3.0}/README.md

@@ -12,7 +12,7 @@ Detailed documentation for usage of completor can be found at https://equinor.gi
 ## Getting started as a user
 
 ### Prerequisites
-* [Python](https://www.python.org/), version 3.11
+* [Python](https://www.python.org/), version 3.11 or 3.13.
 * [ERT](https://github.com/equinor/ert) (optional, and only available on Linux.)
 
 ### Installation
@@ -53,7 +53,7 @@ and making a pull request.
 See [Contribution Document](documentation/docs/contribution_guide.mdx) on how to contribute.
 
 ### Install completor as dev
-In order to run Completor® you need to have versions of [Python 3.11](https://www.python.org/downloads/) installed.
+In order to run Completor® you need to have versions of [Python 3.11, 3.12 or 3.13](https://www.python.org/downloads/) installed.
 #### Source code
 Clone the [Completor® repository](https://github.com/equinor/completor) to get the source code.
 ```bash

{completor-1.1.3 → completor-1.3.0}/completor/completion.py

@@ -551,7 +551,7 @@ def get_device(df_well: pd.DataFrame, df_device: pd.DataFrame, device_type: str)
     Args:
         df_well: Must contain device type, device number, and the scaling factor.
         df_device: Device table.
-        device_type: Device type. `AICD`, `ICD`, `DENSITY`, `VALVE`, `DUALRCP`, `ICV`.
+        device_type: Device type. `AICD`, `ICD`, `DENSITY`, `VALVE`, `DUALRCP`, `ICV`, `INJV`.
 
     Returns:
         Updated well information with device characteristics.
@@ -581,6 +581,10 @@ def get_device(df_well: pd.DataFrame, df_device: pd.DataFrame, device_type: str)
         # rescale the Cv
         # because no scaling factor in WELL_SEGMENTS_VALVE
         df_well[Headers.FLOW_COEFFICIENT] = -df_well[Headers.FLOW_COEFFICIENT] / df_well[Headers.SCALE_FACTOR]
+    elif device_type == Content.INJECTION_VALVE:
+        # rescale the Cv
+        # because no scaling factor in WELL_SEGMENTS_VALVE
+        df_well[Headers.FLOW_COEFFICIENT] = -df_well[Headers.FLOW_COEFFICIENT] / df_well[Headers.SCALE_FACTOR]
     return df_well
 
 

{completor-1.1.3 → completor-1.3.0}/completor/constants.py

@@ -78,7 +78,7 @@ class _Headers:
     DR = "DR"
     FLAG = "FLAG"  # This is actually a header, but OPEN, SHUT, and AUTO are its possible values, see manual on COMPLETION_DATA.
     SHUT = "SHUT"
-    # CROSS = "CROSS"
+    CROSS = "CROSS"
     PRESSURE_TABLE = "PRESSURETABLE"
     DENSITY_CALCULATION_TYPE = "DENSCAL"  # Type of density calculation for the wellbore hydrostatic head.
     REGION = "REGION"
@@ -126,6 +126,7 @@ class _Headers:
     # This stops making sense from here on out?
     X = "X"
     Y = "Y"
+    Z = "Z"
     # FLAG
     A = "A"
     B = "B"
@@ -165,6 +166,15 @@ class _Headers:
     GAS_HOLDUP_FRACTION_LOW_CUTOFF = "GAS_HOLDUP_FRACTION_LOW_CUTOFF"
     GAS_HOLDUP_FRACTION_HIGH_CUTOFF = "GAS_HOLDUP_FRACTION_HIGH_CUTOFF"
 
+    # Injection Valve Well Segments (WSEGINJV)
+    # DEVICE_NUMBER
+    TRIGGER_PARAMETER = "TRIGGER_PARAMETER"
+    TRIGGER_VALUE = "TRIGGER_VALUE"
+    # FLOW_COEFFICIENT / Cv
+    # FLOW_CROSS_SECTIONAL_AREA
+    PRIMARY_FLOW_CROSS_SECTIONAL_AREA = "PRIMARY_FLOW_CROSS_SECTIONAL_AREA"
+    SECONDARY_FLOW_CROSS_SECTIONAL_AREA = "SECONDARY_FLOW_CROSS_SECTIONAL_AREA"
+
     # Miscellaneous
     DEFAULTS = "DEFAULTS"
     MEASURED_DEPTH = "MEASURED_DEPTH"
@@ -244,7 +254,9 @@ class _Keywords:
     INFLOW_CONTROL_VALVE = "WSEGICV"
     INFLOW_CONTROL_DEVICE = "WSEGSICD"
     DENSITY = "WSEGDENSITY"
+    PYTHON_DEPENDENT = "PYTHON"
     DENSITY_ACTIVATED_RECOVERY = "WSEGDAR"
+    INJECTION_VALVE = "WSEGINJV"
     LATERAL_TO_DEVICE = "LATERAL_TO_DEVICE"
     JOINT_LENGTH = "JOINTLENGTH"
     SEGMENT_LENGTH = "SEGMENTLENGTH"
@@ -290,6 +302,7 @@ class _Content:
     AUTONOMOUS_INFLOW_CONTROL_DEVICE = "AICD"
     DENSITY = "DENSITY"
     DENSITY_ACTIVATED_RECOVERY = "DAR"
+    INJECTION_VALVE = "INJV"
     VALVE = "VALVE"
     DEVICE_TYPES = [
         AUTONOMOUS_INFLOW_CONTROL_DEVICE,
@@ -297,6 +310,7 @@ class _Content:
         AUTONOMOUS_INFLOW_CONTROL_VALVE,
         DENSITY,
         DENSITY_ACTIVATED_RECOVERY,
+        INJECTION_VALVE,
         INFLOW_CONTROL_DEVICE,
         VALVE,
         INFLOW_CONTROL_VALVE,

{completor-1.1.3 → completor-1.3.0}/completor/create_output.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import getpass
 from datetime import datetime
 
+import matplotlib.pyplot as plt  # type: ignore
 import numpy as np
 import numpy.typing as npt
 import pandas as pd
@@ -20,13 +21,13 @@ from completor.visualize_well import visualize_well
 from completor.wells import Lateral, Well
 
 
-def format_output(well: Well, case: ReadCasefile, figure_name: str | None = None) -> tuple[str, str, str, str]:
+def format_output(well: Well, case: ReadCasefile, pdf: PdfPages | None = None) -> tuple[str, str, str, str]:
     """Formats the finished output string to be written to a file.
 
     Args:
         well: Well data.
         case: Case data.
-        figure_name: The name of the figure, if None, no figure is printed. Defaults to None.
+        pdf: The name of the figure, if None, no figure is printed. Defaults to None.
 
     Returns:
         Properly formatted output data for completion data, well segments, completion segments, and bonus.
@@ -41,7 +42,10 @@ def format_output(well: Well, case: ReadCasefile, figure_name: str | None = None
     print_autonomous_inflow_control_device = ""
     print_inflow_control_device = ""
     print_density_driven = ""
+    print_density_driven_include = ""
+    print_injection_valve = ""
     print_dual_rate_controlled_production = ""
+    print_density_driven_pyaction = ""
 
     start_segment = 2
     start_branch = 1
@@ -111,6 +115,7 @@ def format_output(well: Well, case: ReadCasefile, figure_name: str | None = None
             well.well_name, lateral.df_well, lateral.df_device
         )
         df_density_driven = prepare_outputs.prepare_density_driven(well.well_name, lateral.df_well, lateral.df_device)
+        df_injection_valve = prepare_outputs.prepare_injection_valve(well.well_name, lateral.df_well, lateral.df_device)
         df_dual_rate_controlled_production = prepare_outputs.prepare_dual_rate_controlled_production(
             well.well_name, lateral.df_well, lateral.df_device
         )
@@ -145,22 +150,35 @@ def format_output(well: Well, case: ReadCasefile, figure_name: str | None = None
         print_inflow_control_valve += _format_inflow_control_valve(
             well.well_name, lateral.lateral_number, df_inflow_control_valve, first
         )
-        print_density_driven += _format_density_driven(well.well_number, df_density_driven)
+        print_injection_valve += _format_injection_valve(well.well_number, df_injection_valve)
         print_dual_rate_controlled_production += _format_dual_rate_controlled_production(
             well.well_number, df_dual_rate_controlled_production
         )
+        # output using ACTIONX (if-else) logic is dual RCP, density driven, and injection valve
+        if case.python_dependent:
+            # print the python file out
+            # append all laterals for density driven, dual RCP, and injection valve
+            # TODO(#274): Add functionality for dual RCP
+            print_density_driven_pyaction = _format_density_driven_pyaction(df_density_driven)
+            output_directory = prepare_outputs.print_python_file(
+                print_density_driven_pyaction, str(case.output_file), well.well_name, lateral.lateral_number
+            )
+            print_density_driven_include += prepare_outputs.print_wsegdensity_include(
+                output_directory, well.well_name, lateral.lateral_number
+            )
+        else:
+            print_density_driven += _format_density_driven(well.well_number, df_density_driven)
 
-        if figure_name is not None:
-            logger.info(f"Creating figure for lateral {lateral.lateral_number}.")
-            with PdfPages(figure_name) as figure:
-                figure.savefig(
-                    visualize_well(
-                        well.well_name, well.df_well_all_laterals, well.df_reservoir_all_laterals, case.segment_length
-                    ),
-                    orientation="landscape",
-                )
-            logger.info("Creating schematics: %s.pdf", figure_name)
+        if pdf is not None:
+            logger.info(f"Creating figure for well {well.well_name}, lateral {lateral.lateral_number}.")
+            fig = visualize_well(
+                well.well_name, well.df_well_all_laterals, well.df_reservoir_all_laterals, case.segment_length
+            )
+            pdf.savefig(fig, orientation="landscape")
+            plt.close(fig)
+            logger.info("Creating schematics: %s", pdf)
         first = False
+
     print_completion_data = "\n".join(completion_data_list)
     if print_well_segments:
         print_well_segments = f"{print_well_segments}\n/\n\n"
@@ -182,7 +200,7 @@ def format_output(well: Well, case: ReadCasefile, figure_name: str | None = None
     if print_density_driven:
         metadata = (
             f"{'-' * 100}\n"
-            "-- This is how we model DENSITY technology using sets of ACTIONX keywords.\n"
+            "-- This is how we model density driven technology using sets of ACTIONX keywords.\n"
             "-- The segment dP curves changes according to the segment water-\n"
             "-- and gas volume fractions at downhole condition.\n"
             "-- The value of Cv is adjusted according to the segment length and the number of\n"
@@ -191,15 +209,37 @@ def format_output(well: Well, case: ReadCasefile, figure_name: str | None = None
             f"{'-' * 100}\n\n\n"
         )
         bonus.append(metadata + print_density_driven + "\n\n\n\n")
+    if print_injection_valve:
+        metadata = (
+            f"{'-' * 100}\n"
+            "-- This is how we model autonomous injection valve technology using sets of ACTIONX keywords.\n"
+            "-- The DP paramaters changes according to the trigger parameter.-\n"
+            "-- The value of Cv is adjusted according to the segment length and the number of\n"
+            "-- devices per joint. The constriction area will change if the parameter is triggered.\n"
+            f"{'-' * 100}\n\n\n"
+        )
+        bonus.append(metadata + print_injection_valve + "\n\n\n\n")
     if print_dual_rate_controlled_production:
         metadata = (
             f"{'-' * 100}\n"
-            "-- This is how we model DUALRCP technology using sets of ACTIONX keyword\n"
+            "-- This is how we model dual RCP curves using sets of ACTIONX keyword\n"
             "-- the DP parameters change according to the segment water cut (at downhole condition )\n"
             "-- and gas volume fraction (at downhole condition)\n"
             f"{'-' * 100}\n\n\n"
         )
         bonus.append(metadata + print_dual_rate_controlled_production + "\n\n\n\n")
+    if print_density_driven_pyaction:
+        metadata = (
+            f"{'-' * 100}\n"
+            "-- This is how we model density driven technology for python dependent keyword.\n"
+            "-- The segment dP curves changes according to the segment water-\n"
+            "-- and gas volume fractions at downhole condition.\n"
+            "-- The value of Cv is adjusted according to the segment length and the number of\n"
+            "-- devices per joint. The constriction area varies according to values of\n"
+            "-- volume fractions.\n"
+            f"{'-' * 100}\n\n\n"
+        )
+        bonus.append(metadata + print_density_driven_include + "\n\n\n\n")
 
     return print_completion_data, print_well_segments, print_completion_segments, "".join(bonus)
 
@@ -450,6 +490,35 @@ def _format_density_driven(well_number: int, df_wsegdensity: pd.DataFrame) -> st
     return prepare_outputs.print_wsegdensity(df_wsegdensity, well_number + 1)
 
 
+def _format_density_driven_pyaction(df_wsegdensity: pd.DataFrame) -> str:
+    """Formats well-segments for density driven valve.
+
+    Args:
+        df_wsegdensity: Data to print.
+
+    Returns:
+        Formatted string.
+    """
+    if df_wsegdensity.empty:
+        return ""
+    return prepare_outputs.print_wsegdensity_pyaction(df_wsegdensity)
+
+
+def _format_injection_valve(well_number: int, df_wseginjv: pd.DataFrame) -> str:
+    """Formats well-segments for injection valve.
+
+    Args:
+        well_number: The well's number
+        df_wsegdinjv: Data to print.
+
+    Returns:
+        Formatted string.
+    """
+    if df_wseginjv.empty:
+        return ""
+    return prepare_outputs.print_wseginjv(df_wseginjv, well_number + 1)
+
+
 def _format_dual_rate_controlled_production(well_number: int, df_wsegdualrcp: pd.DataFrame) -> str:
     """Formats the DUALRCP section.
 

{completor-1.1.3 → completor-1.3.0}/completor/input_validation.py

@@ -173,7 +173,7 @@ def _check_for_errors(df_comp: pd.DataFrame, well_name: str, idx: int) -> None:
     if df_comp[Headers.DEVICE_TYPE].iloc[idx] not in Content.DEVICE_TYPES:
         raise CompletorError(
             f"{df_comp[Headers.DEVICE_TYPE].iloc[idx]} is not a valid device type. "
-            "Valid types are PERF, AICD, ICD, VALVE, DENSITY, DUALRCP, and ICV."
+            "Valid types are PERF, AICD, ICD, VALVE, DENSITY, INJV, DUALRCP, and ICV."
         )
     if df_comp[Headers.ANNULUS].iloc[idx] not in Content.ANNULUS_TYPES:
         raise CompletorError(
@@ -290,6 +290,25 @@ def set_format_wsegdensity(df_temp: pd.DataFrame) -> pd.DataFrame:
     return df_temp
 
 
+def set_format_wseginjv(df_temp: pd.DataFrame) -> pd.DataFrame:
+    """Format the well segments Injection Valve (INJV) data.
+
+    Args:
+        df_temp: Well segments INJV device data.
+
+    Returns:
+        Updated data.
+    """
+    df_temp[Headers.DEVICE_NUMBER] = df_temp[Headers.DEVICE_NUMBER].astype(np.int64)
+    # left out devicenumber and trigger parameter because devicenumber has been formatted as integer
+    # trigger parameter is a string
+    columns = df_temp.columns.to_numpy()[2:]
+    df_temp[columns] = df_temp[columns].astype(np.float64)
+    # Create ID device column
+    df_temp.insert(0, Headers.DEVICE_TYPE, np.full(df_temp.shape[0], Content.INJECTION_VALVE))
+    return df_temp
+
+
 def set_format_wsegdualrcp(df_temp: pd.DataFrame) -> pd.DataFrame:
     """Format the well segments Dual RCP (DUALRCP) table.
 

{completor-1.1.3 → completor-1.3.0}/completor/main.py

@@ -5,8 +5,10 @@ from __future__ import annotations
 import logging
 import os
 import re
+import sys
 import time
 
+from matplotlib.backends.backend_pdf import PdfPages  # type: ignore
 from tqdm import tqdm
 
 from completor import create_output, parse, read_schedule, utils
@@ -89,6 +91,7 @@ def create(
     """
     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)
+    pdf = None
     figure_name = None
     if show_fig:
         figure_no = 1
@@ -96,6 +99,7 @@ def create(
         while os.path.isfile(figure_name):
             figure_no += 1
             figure_name = f"Well_schematic_{figure_no:03d}.pdf"
+        pdf = PdfPages(figure_name)
 
     err: Exception | None = None
     well = None
@@ -122,13 +126,13 @@ def create(
         for chunk in find_keyword_data(Keywords.COMPLETION_SEGMENTS, schedule):
             clean_data = clean_raw_data(chunk, Keywords.COMPLETION_SEGMENTS)
             meaningful_data = read_schedule.set_compsegs(meaningful_data, clean_data)
-        for i, well_name in tqdm(enumerate(active_wells.tolist()), total=len(active_wells)):
+        for i, well_name in tqdm(enumerate(active_wells.tolist()), total=len(active_wells), file=sys.stdout):
             try:
                 well = Well(well_name, i, case, meaningful_data[well_name])
             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, figure_name)
+            compdat, welsegs, compsegs, bonus = create_output.format_output(well, case, pdf)
             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:
@@ -156,6 +160,8 @@ def create(
         schedule = replace_preprocessing_names(schedule, case.mapper)
         with open(new_file, "w", encoding="utf-8") as file:
             file.write(schedule)
+        if pdf is not None:
+            pdf.close()
 
     if err is not None:
         raise err

{completor-1.1.3 → completor-1.3.0}/completor/prepare_outputs.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import math
 from collections.abc import MutableMapping
+from pathlib import Path
 from typing import Any
 
 import numpy as np
@@ -120,6 +121,7 @@ def dataframe_tostring(
             "END_MD": "{:.3f}".format,
             Headers.FLOW_COEFFICIENT: "{:.10g}".format,
             "CV": "{:.10g}".format,
+            Headers.CROSS: "{:.3e}".format,
             Headers.FLOW_CROSS_SECTIONAL_AREA: "{:.3e}".format,
             "FLOW_CROSS_SECTIONAL_AREA": "{:.3e}".format,
             Headers.OIL_FLOW_CROSS_SECTIONAL_AREA: "{:.3e}".format,
@@ -135,6 +137,13 @@ def dataframe_tostring(
             Headers.ALPHA_PILOT: "{:.10g}".format,
         }
 
+        # Cast floats to str befor headers are messed up (pandas formatter does not work reliably with MultiIndex headers).
+        for column, formatter in formatters.items():
+            try:
+                df_temp[column] = df_temp[column].map(formatter)
+            except (KeyError, ValueError):
+                pass
+
         if header:
             # Modify headers to reduce width.
             column_splits = [tuple(column.split("_")) for column in df_temp.columns]
@@ -173,9 +182,7 @@ def dataframe_tostring(
                 df_temp.columns = pd.MultiIndex.from_frame(new_cols)
 
     try:
-        output_string = df_temp.to_string(
-            index=False, justify="justify", formatters=formatters, header=header, sparsify=False
-        )
+        output_string = df_temp.to_string(index=False, justify="justify", header=header, sparsify=False)
     except ValueError:
         if df_temp.isnull().values.any():
             raise CompletorError("Got NaN values in table, please report if encountered!")
@@ -184,18 +191,14 @@ def dataframe_tostring(
         df_temp = df_temp.replace("1*", np.nan, inplace=False)
         # Probably find columns where this is the case and cast to numeric after replacing with nan?
         df_temp[columns_with_1_star] = df_temp[columns_with_1_star].astype(np.float64, errors="ignore")
-        output_string = df_temp.to_string(
-            index=False, justify="justify", formatters=formatters, header=header, sparsify=False, na_rep="1*"
-        )
+        output_string = df_temp.to_string(index=False, justify="justify", header=header, sparsify=False, na_rep="1*")
 
     if output_string is None:
         return ""
 
     too_long_lines = check_width_lines(output_string, limit)
     if too_long_lines:
-        output_string = df_temp.to_string(
-            index=False, justify="left", formatters=formatters, header=header, sparsify=False
-        )
+        output_string = df_temp.to_string(index=False, justify="left", header=header, sparsify=False)
         if output_string is None:
             return ""
         too_long_lines2 = check_width_lines(output_string, limit)
@@ -454,7 +457,11 @@ def prepare_device_layer(df_well: pd.DataFrame, df_tubing: pd.DataFrame, device_
                             df_well[Headers.DEVICE_TYPE] == Content.DUAL_RATE_CONTROLLED_PRODUCTION,
                             "/ -- DUALRCP types",
                             np.where(
-                                df_well[Headers.DEVICE_TYPE] == Content.INFLOW_CONTROL_VALVE, "/ -- ICV types", ""
+                                df_well[Headers.DEVICE_TYPE] == Content.INJECTION_VALVE,
+                                "/ -- INJV types",
+                                np.where(
+                                    df_well[Headers.DEVICE_TYPE] == Content.INFLOW_CONTROL_VALVE, "/ -- ICV types", ""
+                                ),
                             ),
                         ),
                     ),
@@ -1068,6 +1075,8 @@ def prepare_autonomous_inflow_control_device(
         wsegaicd[Headers.D] = df_merge[Headers.D].to_numpy()
         wsegaicd[Headers.E] = df_merge[Headers.E].to_numpy()
         wsegaicd[Headers.F] = df_merge[Headers.F].to_numpy()
+        if Headers.Z in df_merge.columns:
+            wsegaicd[Headers.Z] = df_merge[Headers.Z].to_numpy()
         wsegaicd[Headers.EMPTY] = "/"
     return wsegaicd
 
@@ -1303,6 +1312,48 @@ def prepare_density_driven(well_name: str, df_well: pd.DataFrame, df_device: pd.
     return wsegdensity
 
 
+def prepare_injection_valve(well_name: str, df_well: pd.DataFrame, df_device: pd.DataFrame) -> pd.DataFrame:
+    """Prepare data frame for INJECTION VALVE.
+
+    Args:
+        well_name: Well name.
+        df_well: Well data.
+        df_device: Device data for this well and lateral.
+
+    Returns:
+        DataFrame for INJECTION VALVE.
+    """
+    df_well = df_well[(df_well[Headers.DEVICE_TYPE] == Content.PERFORATED) | (df_well[Headers.NUMBER_OF_DEVICES] > 0)]
+    if df_well.shape[0] == 0:
+        return pd.DataFrame()
+    df_merge = pd.merge_asof(
+        left=df_device,
+        right=df_well,
+        left_on=[Headers.MEASURED_DEPTH],
+        right_on=[Headers.TUBING_MEASURED_DEPTH],
+        direction="nearest",
+    )
+    df_merge = df_merge[df_merge[Headers.DEVICE_TYPE] == Content.INJECTION_VALVE]
+    wseginjv = pd.DataFrame()
+    if df_merge.shape[0] > 0:
+        wseginjv[Headers.WELL] = [well_name] * df_merge.shape[0]
+        wseginjv[Headers.START_SEGMENT_NUMBER] = df_merge[Headers.START_SEGMENT_NUMBER].to_numpy()
+        # the Cv is already corrected by the scaling factor
+        wseginjv[Headers.FLOW_COEFFICIENT] = df_merge[Headers.FLOW_COEFFICIENT].to_numpy()
+        wseginjv[Headers.PRIMARY_FLOW_CROSS_SECTIONAL_AREA] = df_merge[
+            Headers.PRIMARY_FLOW_CROSS_SECTIONAL_AREA
+        ].to_numpy()
+        wseginjv[Headers.SECONDARY_FLOW_CROSS_SECTIONAL_AREA] = df_merge[
+            Headers.SECONDARY_FLOW_CROSS_SECTIONAL_AREA
+        ].to_numpy()
+        wseginjv[Headers.TRIGGER_PARAMETER] = df_merge[Headers.TRIGGER_PARAMETER].to_numpy()
+        wseginjv[Headers.TRIGGER_VALUE] = df_merge[Headers.TRIGGER_VALUE].to_numpy()
+        wseginjv[Headers.DEFAULTS] = "5*"
+        wseginjv[Headers.MAX_FLOW_CROSS_SECTIONAL_AREA] = wseginjv[Headers.PRIMARY_FLOW_CROSS_SECTIONAL_AREA].to_numpy()
+        wseginjv[Headers.EMPTY] = "/"
+    return wseginjv
+
+
 def prepare_dual_rate_controlled_production(
     well_name: str, df_well: pd.DataFrame, df_device: pd.DataFrame
 ) -> pd.DataFrame:
@@ -1513,6 +1564,168 @@ def print_wsegdensity(df_wsegdensity: pd.DataFrame, well_number: int) -> str:
     return action
 
 
+def print_wseginjv(df_wseginjv: pd.DataFrame, well_number: int) -> str:
+    """Print INJECTION VALVE devices.
+
+    Args:
+        df_wseginjv: Output from function prepare_wseginjv.
+        well_number: Well number.
+
+    Returns:
+        Formatted actions to be included in the output file.
+
+    Raises:
+        CompletorError: If there are to many wells and/or segments with INJECTION VALVE.
+    """
+    header = [
+        [
+            Headers.WELL,
+            Headers.START_SEGMENT_NUMBER,
+            Headers.FLOW_COEFFICIENT,
+            Headers.SECONDARY_FLOW_CROSS_SECTIONAL_AREA,
+            Headers.DEFAULTS,
+            Headers.MAX_FLOW_CROSS_SECTIONAL_AREA,
+        ],
+        [
+            Headers.WELL,
+            Headers.START_SEGMENT_NUMBER,
+            Headers.FLOW_COEFFICIENT,
+            Headers.PRIMARY_FLOW_CROSS_SECTIONAL_AREA,
+            Headers.DEFAULTS,
+            Headers.MAX_FLOW_CROSS_SECTIONAL_AREA,
+        ],
+    ]
+
+    sign = ["<", ">="]
+    suvtrig = ["0", "1"]
+    action = "UDQ\n"
+    for idx in range(df_wseginjv.shape[0]):
+        segment_number = df_wseginjv[Headers.START_SEGMENT_NUMBER].iloc[idx]
+        well_name = df_wseginjv[Headers.WELL].iloc[idx]
+        action += f"  ASSIGN SUVTRIG {well_name} {segment_number} 0 /\n"
+    action += "/\n\n"
+    iaction = 1
+    action += Keywords.WELL_SEGMENTS_VALVE + "\n"
+    header_string = "--"
+    for itm in header[iaction]:
+        header_string += "  " + itm
+    action += header_string.rstrip() + "\n"
+    for idx in range(df_wseginjv.shape[0]):
+        segment_number = df_wseginjv[Headers.START_SEGMENT_NUMBER].iloc[idx]
+        print_df = df_wseginjv[df_wseginjv[Headers.START_SEGMENT_NUMBER] == segment_number]
+        print_df = print_df[header[iaction]]
+        print_df = dataframe_tostring(print_df, True, False, False) + "\n"
+        action += print_df
+    action += "/\n\n"
+    for idx in range(df_wseginjv.shape[0]):
+        segment_number = df_wseginjv[Headers.START_SEGMENT_NUMBER].iloc[idx]
+        well_name = df_wseginjv[Headers.WELL].iloc[idx]
+        # Trigger paramater is segment water rate
+        if df_wseginjv[Headers.TRIGGER_PARAMETER].iloc[idx] == "SWFR":
+            water_segment_rate_cutoff = -1 * df_wseginjv[Headers.TRIGGER_VALUE].iloc[idx]
+            iaction = 0
+            act_number = iaction + 1
+            act_name = f"INJVOP{well_number:03d}{segment_number:03d}{act_number:1d}"
+            if len(act_name) > 13:
+                raise CompletorError("Too many wells and/or too many segments with Injection Valve")
+            action += (
+                f"ACTIONX\n{act_name} 1000000 /\n"
+                f"SWFR '{well_name}' {segment_number} "
+                f"{sign[iaction]} {water_segment_rate_cutoff} AND /\n"
+                f"SUVTRIG '{well_name}' {segment_number} "
+                f"= {suvtrig[iaction]} /\n/\n\n"
+            )
+            print_df = df_wseginjv[df_wseginjv[Headers.START_SEGMENT_NUMBER] == segment_number]
+            print_df = print_df[header[iaction]]  # type: ignore
+            header_string = Keywords.WELL_SEGMENTS_VALVE + "\n--"
+
+            for item in header[iaction]:
+                header_string += "  " + item
+            header_string = header_string.rstrip() + "\n"
+            print_df = header_string + dataframe_tostring(print_df, True, False, False)  # type: ignore
+            print_df += "\n/\n"
+            print_df += f"\nUDQ\n  ASSIGN SUVTRIG {well_name} {segment_number} 1 /\n/\n"
+            action += print_df + "\nENDACTIO\n\n"
+
+            iaction = 1
+            act_number = iaction + 1
+            act_name = f"INJVCL{well_number:03d}{segment_number:03d}{act_number:1d}"
+            if len(act_name) > 13:
+                raise CompletorError("Too many wells and/or too many segments with Injection Valve")
+            action += (
+                f"ACTIONX\n{act_name} 1000000 /\n"
+                f"SWFR '{well_name}' {segment_number} "
+                f"{sign[iaction]} {water_segment_rate_cutoff} AND /\n"
+                f"SUVTRIG '{well_name}' {segment_number} "
+                f"= {suvtrig[iaction]} /\n/\n\n"
+            )
+            print_df = df_wseginjv[df_wseginjv[Headers.START_SEGMENT_NUMBER] == segment_number]
+            print_df = print_df[header[iaction]]  # type: ignore
+            header_string = Keywords.WELL_SEGMENTS_VALVE + "\n--"
+
+            for item in header[iaction]:
+                header_string += "  " + item
+            header_string = header_string.rstrip() + "\n"
+            print_df = header_string + dataframe_tostring(print_df, True, False, False)  # type: ignore
+            print_df += "\n/\n"
+            print_df += f"\nUDQ\n  ASSIGN SUVTRIG {well_name} {segment_number} 0 /\n/\n"
+            action += print_df + "\nENDACTIO\n\n"
+
+        # Trigger parameter is segment pressure drop
+        elif df_wseginjv[Headers.TRIGGER_PARAMETER].iloc[idx] == "SPRD":
+            pressure_drop_cutoff = -1 * df_wseginjv[Headers.TRIGGER_VALUE].iloc[idx]
+            iaction = 0
+            act_number = iaction + 1
+            act_name = f"INJVOP{well_number:03d}{segment_number:03d}{act_number:1d}"
+            if len(act_name) > 13:
+                raise CompletorError("Too many wells and/or too many segments with Injection Valve")
+            action += (
+                f"ACTIONX\n{act_name} 1000000 /\n"
+                f"SPRD '{well_name}' {segment_number} "
+                f"{sign[iaction]} {pressure_drop_cutoff} AND /\n"
+                f"SUVTRIG '{well_name}' {segment_number} "
+                f"= {suvtrig[iaction]} /\n/\n\n"
+            )
+            print_df = df_wseginjv[df_wseginjv[Headers.START_SEGMENT_NUMBER] == segment_number]
+            print_df = print_df[header[iaction]]  # type: ignore
+            header_string = Keywords.WELL_SEGMENTS_VALVE + "\n--"
+
+            for item in header[iaction]:
+                header_string += "  " + item
+            header_string = header_string.rstrip() + "\n"
+            print_df = header_string + dataframe_tostring(print_df, True, False, False)  # type: ignore
+            print_df += "\n/\n"
+            print_df += f"\nUDQ\n  ASSIGN SUVTRIG {well_name} {segment_number} 1 /\n/\n"
+            action += print_df + "\nENDACTIO\n\n"
+
+            iaction = 1
+            act_number = iaction + 1
+            act_name = f"INJVCL{well_number:03d}{segment_number:03d}{act_number:1d}"
+            if len(act_name) > 13:
+                raise CompletorError("Too many wells and/or too many segments with Injection Valve")
+            action += (
+                f"ACTIONX\n{act_name} 1000000 /\n"
+                f"SPRD '{well_name}' {segment_number} "
+                f"{sign[iaction]} {pressure_drop_cutoff} AND /\n"
+                f"SUVTRIG '{well_name}' {segment_number} "
+                f"= {suvtrig[iaction]} /\n/\n\n"
+            )
+            print_df = df_wseginjv[df_wseginjv[Headers.START_SEGMENT_NUMBER] == segment_number]
+            print_df = print_df[header[iaction]]  # type: ignore
+            header_string = Keywords.WELL_SEGMENTS_VALVE + "\n--"
+
+            for item in header[iaction]:
+                header_string += "  " + item
+            header_string = header_string.rstrip() + "\n"
+            print_df = header_string + dataframe_tostring(print_df, True, False, False)  # type: ignore
+            print_df += "\n/\n"
+            print_df += f"\nUDQ\n  ASSIGN SUVTRIG {well_name} {segment_number} 0 /\n/\n"
+            action += print_df + "\nENDACTIO\n\n"
+        else:
+            raise CompletorError("Trigger paramater given is not supported")
+    return action
+
+
 def print_wsegdualrcp(df_wsegdualrcp: pd.DataFrame, well_number: int) -> str:
     """Print for DUALRCP devices.
 
@@ -1616,3 +1829,143 @@ def print_wsegdualrcp(df_wsegdualrcp: pd.DataFrame, well_number: int) -> str:
             print_df = Keywords.AUTONOMOUS_INFLOW_CONTROL_DEVICE + "\n" + dataframe_tostring(print_df, True)
             action += f"{print_df}\n/\nENDACTIO\n\n"
     return action
+
+
+def print_wsegdensity_pyaction(df_wsegdensity: pd.DataFrame) -> str:
+    """Create PYACTION code.
+
+    Args:
+        df_wsegdensity: Output from function prepare_wsegdensity.
+
+    Returns:
+        Final code output formatted in PYACTION.
+    """
+    data_dict = df_wsegdensity.to_dict(orient="list")
+    final_code = f"""
+import opm_embedded
+
+ecl_state = opm_embedded.current_ecl_state
+schedule = opm_embedded.current_schedule
+report_step = opm_embedded.current_report_step
+summary_state = opm_embedded.current_summary_state
+
+if 'setup_done' not in locals():
+    execution_counter = dict()
+    executed = False
+    setup_done = True
+
+data={data_dict}
+
+for i in range(len(data["WELL"])):
+    well_name = data["WELL"][i]
+    segment_number = data["START_SEGMENT_NUMBER"][i]
+    flow_coefficient = data["FLOW_COEFFICIENT"][i]
+    oil_flow_area = data["OIL_FLOW_CROSS_SECTIONAL_AREA"][i]
+    gas_flow_area = data["GAS_FLOW_CROSS_SECTIONAL_AREA"][i]
+    water_flow_area = data["WATER_FLOW_CROSS_SECTIONAL_AREA"][i]
+    max_flow_area = data["MAX_FLOW_CROSS_SECTIONAL_AREA"][i]
+    water_low = data["WATER_HOLDUP_FRACTION_LOW_CUTOFF"][i]
+    water_high = data["WATER_HOLDUP_FRACTION_HIGH_CUTOFF"][i]
+    gas_low = data["GAS_HOLDUP_FRACTION_LOW_CUTOFF"][i]
+    gas_high = data["GAS_HOLDUP_FRACTION_HIGH_CUTOFF"][i]
+    defaults = data["DEFAULTS"][i]
+
+    swhf = summary_state[f"SWHF:{{well_name}}:{{segment_number}}"]
+    sghf = summary_state[f"SGHF:{{well_name}}:{{segment_number}}"]
+    suvtrig = summary_state[f"SUVTRIG:{{well_name}}:{{segment_number}}"]
+
+    keyword_oil = (
+        f"WSEGVALV\\n"
+        f"  '{{well_name}}' {{segment_number}} {{flow_coefficient}} {{oil_flow_area}} {{defaults}} {{max_flow_area}} /\\n/"
+    )
+    keyword_water = (
+        f"WSEGVALV\\n"
+        f"  '{{well_name}}' {{segment_number}} {{flow_coefficient}} {{water_flow_area}} {{defaults}} {{max_flow_area}} /\\n/"
+    )
+    keyword_gas = (
+        f"WSEGVALV\\n"
+        f"  '{{well_name}}' {{segment_number}} {{flow_coefficient}} {{gas_flow_area}} {{defaults}} {{max_flow_area}} /\\n/"
+    )
+
+    key = (well_name, segment_number)
+    execution_counter.setdefault(key, 0)
+
+    if execution_counter[key] == 0:
+        schedule.insert_keywords(keyword_oil, report_step)
+        summary_state[f"SUVTRIG:{{well_name}}:{{segment_number}}"] = 0
+
+    if execution_counter[key] < 1000000:
+        if swhf is not None and sghf is not None:
+            if swhf <= water_high and sghf > gas_high and suvtrig == 0:
+                schedule.insert_keywords(keyword_gas, report_step)
+                summary_state[f"SUVTRIG:{{well_name}}:{{segment_number}}"] = 1
+                execution_counter[key] += 1
+
+            elif swhf > water_high and sghf <= gas_high and suvtrig == 0:
+                schedule.insert_keywords(keyword_water, report_step)
+                summary_state[f"SUVTRIG:{{well_name}}:{{segment_number}}"] = 2
+                execution_counter[key] += 1
+
+            elif sghf < gas_low and suvtrig == 1:
+                schedule.insert_keywords(keyword_oil, report_step)
+                summary_state[f"SUVTRIG:{{well_name}}:{{segment_number}}"] = 0
+                execution_counter[key] += 1
+
+            elif swhf < water_low and suvtrig == 2:
+                schedule.insert_keywords(keyword_oil, report_step)
+                summary_state[f"SUVTRIG:{{well_name}}:{{segment_number}}"] = 0
+                execution_counter[key] += 1
+    """
+    return final_code
+
+
+def print_python_file(code: str, dir: str, well_name: str, lateral_number: int) -> str:
+    """Print Python PYACTION file.
+
+    Args:
+        code: Final code output formatted in PYACTION.
+        dir: Output path.
+        well_name: Well name.
+        lateral_number: Lateral number.
+
+    Returns:
+        Python file with PYACTION format, output directory with FMU format.
+    """
+    base_dir = Path.cwd() if Path(dir).parent == Path(".") else Path(dir).parent
+    fmu_path = Path("eclipse/include/")
+    if str(fmu_path) in str(base_dir):
+        base_include_path = Path("../include/schedule")
+    else:
+        base_include_path = Path("")
+    output_directory = f"{base_include_path}/wsegdensity_{well_name}_{lateral_number}.py"
+    python_file = base_dir / f"wsegdensity_{well_name}_{lateral_number}.py"
+    with open(python_file, "w") as file:
+        file.writelines(code)
+    return output_directory
+
+
+def print_wsegdensity_include(output_directory: str, well_name: str, lateral_number: int) -> str:
+    """Formatted PYACTION include in the output file.
+
+    Args:
+        output_directory: Include file path in FMU relative format.
+        well_name: Well name.
+        lateral_number: Lateral number.
+
+    Returns:
+        Include file output for the output file.
+    """
+    action = f"""
+-------------------------------------
+-- START OF PYACTION SECTION
+
+PYACTION
+WSEGDENSITY_{well_name}_{lateral_number} UNLIMITED /
+
+'{output_directory}' /
+
+-- END OF PYACTION SECTION
+-------------------------------------
+"""
+
+    return action

{completor-1.1.3 → completor-1.3.0}/completor/read_casefile.py

@@ -48,7 +48,7 @@ class ReadCasefile:
     This class reads the case/input file of the Completor program.
     It reads the following keywords:
     COMPLETION, SEGMENTLENGTH, JOINTLENGTH, AUTONOMOUS_INFLOW_CONTROL_DEVICE, WELL_SEGMENTS_VALVE,
-    INFLOW_CONTROL_DEVICE, DENSITY_DRIVEN, DUAL_RATE_CONTROLLED_PRODUCTION, INFLOW_CONTROL_VALVE.
+    INFLOW_CONTROL_DEVICE, DENSITY_DRIVEN, INJECTION_VALVE, DUAL_RATE_CONTROLLED_PRODUCTION, INFLOW_CONTROL_VALVE.
     In the absence of some keywords, the program uses the default values.
 
     Attributes:
@@ -64,6 +64,7 @@ class ReadCasefile:
         wsegvalv_table (pd.DataFrame): WELL_SEGMENTS_VALVE.
         wsegicv_table (pd.DataFrame): INFLOW_CONTROL_VALVE.
         wsegdensity_table (pd.DataFrame): DENSITY_DRIVEN.
+        wseginjv_table (pd.DataFrame): INJECTION_VALVE.
         wsegdualrcp_table (pd.DataFrame): DUAL_RATE_CONTROLLED_PRODUCTION.
         strict (bool): USE_STRICT. If TRUE it will exit if any lateral is not defined in the case-file. Default to TRUE.
         lat2device (pd.DataFrame): LATERAL_TO_DEVICE.
@@ -90,6 +91,7 @@ class ReadCasefile:
         self.minimum_segment_length: float = 0.0
         self.strict = True
         self.gp_perf_devicelayer = False
+        self.python_dependent = False
         self.schedule_file = schedule_file
         self.output_file = output_file
         self.completion_table = pd.DataFrame()
@@ -99,6 +101,7 @@ class ReadCasefile:
         self.wsegsicd_table = pd.DataFrame()
         self.wsegvalv_table = pd.DataFrame()
         self.wsegdensity_table = pd.DataFrame()
+        self.wseginjv_table = pd.DataFrame()
         self.wsegdualrcp_table = pd.DataFrame()
         self.wsegicv_table = pd.DataFrame()
         self.lat2device = pd.DataFrame()
@@ -117,6 +120,8 @@ class ReadCasefile:
         self.read_wsegvalv()
         self.read_wsegsicd()
         self.read_wsegdensity()
+        self.read_python_dependent()
+        self.read_wseginjv()
         self.read_wsegdualrcp()
         self.read_wsegicv()
         self.read_lat2device()
@@ -449,10 +454,14 @@ class ReadCasefile:
                 Headers.F,
                 Headers.AICD_CALIBRATION_FLUID_DENSITY,
                 Headers.AICD_FLUID_VISCOSITY,
+                Headers.Z,
             ]
-            self.wsegaicd_table = input_validation.set_format_wsegaicd(
-                self._create_dataframe_with_columns(header, start_index, end_index)
-            )
+            try:
+                df_temp = self._create_dataframe_with_columns(header, start_index, end_index)
+            except CaseReaderFormatError:
+                header.remove(Headers.Z)
+                df_temp = self._create_dataframe_with_columns(header, start_index, end_index)
+            self.wsegaicd_table = input_validation.set_format_wsegaicd(df_temp)
             device_checks = self.completion_table[
                 self.completion_table[Headers.DEVICE_TYPE] == Content.AUTONOMOUS_INFLOW_CONTROL_DEVICE
             ][Headers.DEVICE_NUMBER].to_numpy()
@@ -514,6 +523,52 @@ class ReadCasefile:
             if not check_contents(device_checks, self.wsegdensity_table[Headers.DEVICE_NUMBER].to_numpy()):
                 raise CompletorError(f"Not all device in COMPLETION is specified in {key}")
 
+    def read_wseginjv(self) -> None:
+        """Read the INJECTION_VALVE keyword in the case file.
+
+        Raises:
+            CompletorError: If INJECTION_VALVE is not defined and INJV is used in COMPLETION,
+                or if the device number is not found.
+                If not all devices in COMPLETION are specified in INJECTION_VALVE.
+        """
+        start_index, end_index = parse.locate_keyword(self.content, Keywords.INJECTION_VALVE)
+        if start_index == end_index:
+            if Content.INJECTION_VALVE in self.completion_table[Headers.DEVICE_TYPE]:
+                raise CompletorError(
+                    f"{Keywords.INJECTION_VALVE} keyword must be defined, if INJV is used in the completion."
+                )
+        else:
+            # Table headers
+            header = [
+                Headers.DEVICE_NUMBER,
+                Headers.TRIGGER_PARAMETER,
+                Headers.TRIGGER_VALUE,
+                Headers.FLOW_COEFFICIENT,
+                Headers.PRIMARY_FLOW_CROSS_SECTIONAL_AREA,
+                Headers.SECONDARY_FLOW_CROSS_SECTIONAL_AREA,
+            ]
+            self.wseginjv_table = input_validation.set_format_wseginjv(
+                self._create_dataframe_with_columns(header, start_index, end_index)
+            )
+            # Check if the device in COMPLETION is exist in INJECTION_VALVE
+            device_checks = self.completion_table[
+                self.completion_table[Headers.DEVICE_TYPE] == Content.INJECTION_VALVE
+            ][Headers.DEVICE_NUMBER].to_numpy()
+            if not check_contents(device_checks, self.wseginjv_table[Headers.DEVICE_NUMBER].to_numpy()):
+                raise CompletorError(f"Not all device in COMPLETION is specified in {Keywords.INJECTION_VALVE}")
+
+    def read_python_dependent(self) -> None:
+        """Read PYTHON keyword. Accepts TRUE or just '/' as True."""
+        start_index, end_index = parse.locate_keyword(self.content, Keywords.PYTHON_DEPENDENT)
+
+        if end_index == start_index + 1:
+            # Keyword followed directly by '/', no value = True
+            self.python_dependent = True
+        elif end_index == start_index + 2:
+            val = self.content[start_index + 1]
+            if val.upper() == "TRUE":
+                self.python_dependent = True
+
     def read_wsegdualrcp(self) -> None:
         """Read the DUALRCP keyword in the case file.
 

{completor-1.1.3 → completor-1.3.0}/completor/utils.py

@@ -193,6 +193,7 @@ def get_active_wells(completion_table: pd.DataFrame, gp_perf_devicelayer: bool)
                 Content.AUTONOMOUS_INFLOW_CONTROL_DEVICE,
                 Content.DUAL_RATE_CONTROLLED_PRODUCTION,
                 Content.DENSITY,
+                Content.INJECTION_VALVE,
                 Content.INFLOW_CONTROL_DEVICE,
                 Content.VALVE,
                 Content.INFLOW_CONTROL_VALVE,

{completor-1.1.3 → completor-1.3.0}/completor/visualize_well.py

@@ -48,6 +48,8 @@ def visualize_device(axs: Axes, df_well: pd.DataFrame) -> Axes:
             axs.plot(xpar, ypar, "rv-", markevery=[1])
         elif df_device[Headers.DEVICE_TYPE].iloc[idx] == Content.DENSITY:
             axs.plot(xpar, ypar, "rP-", markevery=[1])
+        elif df_device[Headers.DEVICE_TYPE].iloc[idx] == Content.INJECTION_VALVE:
+            axs.plot(xpar, ypar, "rP-", markevery=[1])
         elif df_device[Headers.DEVICE_TYPE].iloc[idx] == Content.DUAL_RATE_CONTROLLED_PRODUCTION:
             axs.plot(xpar, ypar, "r*-", markevery=[1])
     return axs

{completor-1.1.3 → completor-1.3.0}/completor/wells.py

@@ -220,6 +220,8 @@ class Lateral:
             df_well = completion.get_device(df_well, case.wsegaicd_table, Content.AUTONOMOUS_INFLOW_CONTROL_DEVICE)
         if Content.DENSITY in active_devices:
             df_well = completion.get_device(df_well, case.wsegdensity_table, Content.DENSITY)
+        if Content.INJECTION_VALVE in active_devices:
+            df_well = completion.get_device(df_well, case.wseginjv_table, Content.INJECTION_VALVE)
         if Content.DUAL_RATE_CONTROLLED_PRODUCTION in active_devices:
             df_well = completion.get_device(df_well, case.wsegdualrcp_table, Content.DUAL_RATE_CONTROLLED_PRODUCTION)
         if Content.INFLOW_CONTROL_VALVE in active_devices:

{completor-1.1.3 → completor-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "completor"
-version = "1.1.3"
+version = "1.3.0"
 description = "Advanced multi-segmented well completion tool."
 authors = ["Equinor ASA <opensource@equinor.com>"]
 repository = "https://github.com/equinor/completor"
@@ -13,21 +13,22 @@ classifiers = [
     "Operating System :: OS Independent",
     "Natural Language :: English",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
 ]
 
 [tool.poetry.urls]
 "Bug Tracker" = "https://github.com/equinor/completor/issues"
 
 [tool.poetry.dependencies]
-python = "^3.11"
+python = ">=3.11, <3.14"
 matplotlib = "^3.9"
-numpy = ">=1.26, <3.0"
+numpy = "^2.0"
 pandas = "^2.2"
-scipy = "^1.14"
 tqdm = "^4.66"
 
 rstcheck-core = {version="^1.2", optional=true}
-ert = {version="^12", optional=true}
+ert = {version="^14", optional=true}
 pytest = {version="^8.3", optional=true}
 pytest-xdist = {version="^3.6", optional=true}
 pytest-env = {version="^1", optional=true}