completor 1.1.1__tar.gz → 1.1.3__tar.gz

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

@@ -1,28 +1,30 @@
 Metadata-Version: 2.1
 Name: completor
-Version: 1.1.1
-Summary: Advanced mulit-segmented well completion tool.
+Version: 1.1.3
+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,<3.12
+Requires-Python: >=3.11,<4.0
 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
 Provides-Extra: ert
-Requires-Dist: docutils (==0.20.1) ; extra == "ert"
-Requires-Dist: ert (>11.1.0) ; extra == "ert"
-Requires-Dist: matplotlib (>=3.6,<4.0)
-Requires-Dist: numpy (<2)
-Requires-Dist: pandas (>=2.1.4,<3.0.0)
-Requires-Dist: pyqt5-qt5 (==5.15.2) ; extra == "ert"
-Requires-Dist: pytest-env (>=1,<2)
-Requires-Dist: rstcheck-core (>=1.2.1,<2.0.0) ; extra == "ert"
-Requires-Dist: scipy (>=1.10,<2.0)
-Requires-Dist: tqdm (>=4.50,<5.0)
+Provides-Extra: test
+Requires-Dist: ert (>=12,<13) ; extra == "ert"
+Requires-Dist: matplotlib (>=3.9,<4.0)
+Requires-Dist: numpy (>=1.26,<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
 Project-URL: Repository, https://github.com/equinor/completor

{completor-1.1.1 → completor-1.1.3}/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`, `DAR`, `VALVE`, `AICV`, `ICV`.
+        device_type: Device type. `AICD`, `ICD`, `DENSITY`, `VALVE`, `DUALRCP`, `ICV`.
 
     Returns:
         Updated well information with device characteristics.
@@ -561,7 +561,14 @@ def get_device(df_well: pd.DataFrame, df_device: pd.DataFrame, device_type: str)
     """
     columns = [Headers.DEVICE_TYPE, Headers.DEVICE_NUMBER]
     try:
-        df_well = pd.merge(df_well, df_device, how="left", on=columns)
+        df_well = pd.merge(df_well, df_device, how="left", on=columns, suffixes=("", "_drop"))
+        # check for duplicates if merging two WSEGVALV-es
+        for col in df_well.columns:
+            if col.endswith("_drop"):
+                base_col = col.replace("_drop", "")
+                if base_col in df_well.columns:
+                    df_well[base_col] = df_well[base_col].fillna(df_well[col])  # Fill NaN values
+        df_well = df_well.drop(columns=[col for col in df_well.columns if col.endswith("_drop")])
     except KeyError as err:
         if f"'{Headers.DEVICE_TYPE}'" in str(err):
             raise ValueError(f"Missing keyword 'DEVICETYPE {device_type}' in input files.") from err
@@ -570,7 +577,7 @@ 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.DENSITY_ACTIVATED_RECOVERY:
+    elif device_type == Content.DENSITY:
         # 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]

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

@@ -153,7 +153,7 @@ class _Headers:
     # 11. The length of the valve, lVAL (Scale factor).
     # 12. An integer which determines how the flow scaling factor is calculated.
 
-    # Density Activated Recovery Well Segments (WSEGDAR)
+    # Density Driven Well Segments (WSEGDENSITY)
     # DEVICE_NUMBER
     # FLOW_COEFFICIENT / Cv
     # FLOW_CROSS_SECTIONAL_AREA
@@ -186,10 +186,10 @@ class _Headers:
     LATERAL = "LATERAL"
     NUMBER_OF_DEVICES = "NUMBER_OF_DEVICES"
     SEGMENT_DESC = "SEGMENT_DESC"
-    AICV_WATER_CUT = "AICV_WATER_CUT"
-    AICV_GAS_HOLDUP_FRACTION = "AICV_GAS_HOLDUP_FRACTION"
-    AICV_CALIBRATION_FLUID_DENSITY = "AICV_CALIBRATION_FLUID_DENSITY"
-    AICV_FLUID_VISCOSITY = "AICV_FLUID_VISCOSITY"
+    DUALRCP_WATER_CUT = "DUALRCP_WATER_CUT"
+    DUALRCP_GAS_HOLDUP_FRACTION = "DUALRCP_GAS_HOLDUP_FRACTION"
+    DUALRCP_CALIBRATION_FLUID_DENSITY = "DUALRCP_CALIBRATION_FLUID_DENSITY"
+    DUALRCP_FLUID_VISCOSITY = "DUALRCP_FLUID_VISCOSITY"
     AICD_CALIBRATION_FLUID_DENSITY = "AICD_CALIBRATION_FLUID_DENSITY"
     AICD_FLUID_VISCOSITY = "AICD_FLUID_VISCOSITY"
     ALPHA_MAIN = "ALPHA_MAIN"
@@ -239,9 +239,11 @@ class _Keywords:
     WELL_SEGMENTS_LINK = "WSEGLINK"
     WELL_SEGMENTS_VALVE = "WSEGVALV"
     AUTONOMOUS_INFLOW_CONTROL_DEVICE = "WSEGAICD"
+    DUAL_RATE_CONTROLLED_PRODUCTION = "WSEGDUALRCP"
     AUTONOMOUS_INFLOW_CONTROL_VALVE = "WSEGAICV"
     INFLOW_CONTROL_VALVE = "WSEGICV"
     INFLOW_CONTROL_DEVICE = "WSEGSICD"
+    DENSITY = "WSEGDENSITY"
     DENSITY_ACTIVATED_RECOVERY = "WSEGDAR"
     LATERAL_TO_DEVICE = "LATERAL_TO_DEVICE"
     JOINT_LENGTH = "JOINTLENGTH"
@@ -282,14 +284,18 @@ class _Content:
 
     PERFORATED = "PERF"
     INFLOW_CONTROL_VALVE = "ICV"
+    DUAL_RATE_CONTROLLED_PRODUCTION = "DUALRCP"
     AUTONOMOUS_INFLOW_CONTROL_VALVE = "AICV"
     INFLOW_CONTROL_DEVICE = "ICD"
     AUTONOMOUS_INFLOW_CONTROL_DEVICE = "AICD"
+    DENSITY = "DENSITY"
     DENSITY_ACTIVATED_RECOVERY = "DAR"
     VALVE = "VALVE"
     DEVICE_TYPES = [
         AUTONOMOUS_INFLOW_CONTROL_DEVICE,
+        DUAL_RATE_CONTROLLED_PRODUCTION,
         AUTONOMOUS_INFLOW_CONTROL_VALVE,
+        DENSITY,
         DENSITY_ACTIVATED_RECOVERY,
         INFLOW_CONTROL_DEVICE,
         VALVE,

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

@@ -40,8 +40,8 @@ def format_output(well: Well, case: ReadCasefile, figure_name: str | None = None
     print_inflow_control_valve = ""
     print_autonomous_inflow_control_device = ""
     print_inflow_control_device = ""
-    print_density_activated_recovery = ""
-    print_autonomous_inflow_control_valve = ""
+    print_density_driven = ""
+    print_dual_rate_controlled_production = ""
 
     start_segment = 2
     start_branch = 1
@@ -110,10 +110,8 @@ def format_output(well: Well, case: ReadCasefile, figure_name: str | None = None
         df_autonomous_inflow_control_device = prepare_outputs.prepare_autonomous_inflow_control_device(
             well.well_name, lateral.df_well, lateral.df_device
         )
-        df_density_activated_recovery = prepare_outputs.prepare_density_activated_recovery(
-            well.well_name, lateral.df_well, lateral.df_device
-        )
-        df_autonomous_inflow_control_valve = prepare_outputs.prepare_autonomous_inflow_control_valve(
+        df_density_driven = prepare_outputs.prepare_density_driven(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
         )
         df_inflow_control_valve = prepare_outputs.prepare_inflow_control_valve(
@@ -147,11 +145,9 @@ 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_activated_recovery += _format_density_activated_recovery(
-            well.well_number, df_density_activated_recovery
-        )
-        print_autonomous_inflow_control_valve += _format_autonomous_inflow_control_valve(
-            well.well_number, df_autonomous_inflow_control_valve
+        print_density_driven += _format_density_driven(well.well_number, df_density_driven)
+        print_dual_rate_controlled_production += _format_dual_rate_controlled_production(
+            well.well_number, df_dual_rate_controlled_production
         )
 
         if figure_name is not None:
@@ -183,10 +179,10 @@ def format_output(well: Well, case: ReadCasefile, figure_name: str | None = None
         bonus.append(f"{Keywords.AUTONOMOUS_INFLOW_CONTROL_DEVICE}{print_autonomous_inflow_control_device}\n/\n\n\n")
     if print_inflow_control_valve:
         bonus.append(f"{Keywords.WELL_SEGMENTS_VALVE}{print_inflow_control_valve}\n/\n\n\n")
-    if print_density_activated_recovery:
+    if print_density_driven:
         metadata = (
             f"{'-' * 100}\n"
-            "-- This is how we model DAR technology using sets of ACTIONX keywords.\n"
+            "-- This is how we model DENSITY 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"
@@ -194,16 +190,16 @@ def format_output(well: Well, case: ReadCasefile, figure_name: str | None = None
             "-- volume fractions.\n"
             f"{'-' * 100}\n\n\n"
         )
-        bonus.append(metadata + print_density_activated_recovery + "\n\n\n\n")
-    if print_autonomous_inflow_control_valve:
+        bonus.append(metadata + print_density_driven + "\n\n\n\n")
+    if print_dual_rate_controlled_production:
         metadata = (
             f"{'-' * 100}\n"
-            "-- This is how we model AICV technology using sets of ACTIONX keyword\n"
+            "-- This is how we model DUALRCP technology 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_autonomous_inflow_control_valve + "\n\n\n\n")
+        bonus.append(metadata + print_dual_rate_controlled_production + "\n\n\n\n")
 
     return print_completion_data, print_well_segments, print_completion_segments, "".join(bonus)
 
@@ -439,34 +435,34 @@ def _format_inflow_control_valve(well_name: str, lateral_number: int, df_wsegicv
     )
 
 
-def _format_density_activated_recovery(well_number: int, df_wsegdar: pd.DataFrame) -> str:
-    """Formats well-segments for density activated recovery valve.
+def _format_density_driven(well_number: int, df_wsegdensity: pd.DataFrame) -> str:
+    """Formats well-segments for density driven valve.
 
     Args:
         well_number: The well's number
-        df_wsegdar: Data to print.
+        df_wsegdensity: Data to print.
 
     Returns:
         Formatted string.
     """
-    if df_wsegdar.empty:
+    if df_wsegdensity.empty:
         return ""
-    return prepare_outputs.print_wsegdar(df_wsegdar, well_number + 1)
+    return prepare_outputs.print_wsegdensity(df_wsegdensity, well_number + 1)
 
 
-def _format_autonomous_inflow_control_valve(well_number: int, df_wsegaicv: pd.DataFrame) -> str:
-    """Formats the AICV section.
+def _format_dual_rate_controlled_production(well_number: int, df_wsegdualrcp: pd.DataFrame) -> str:
+    """Formats the DUALRCP section.
 
     Args:
         well_number: The well's number
-        df_wsegaicv: Data to print.
+        df_wsegdualrcp: Data to print.
 
     Returns:
         Formatted string.
     """
-    if df_wsegaicv.empty:
+    if df_wsegdualrcp.empty:
         return ""
-    return prepare_outputs.print_wsegaicv(df_wsegaicv, well_number + 1)
+    return prepare_outputs.print_wsegdualrcp(df_wsegdualrcp, well_number + 1)
 
 
 def _branch_revision(

{completor-1.1.1 → completor-1.1.3}/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, DAR, AICV, and ICV."
+            "Valid types are PERF, AICD, ICD, VALVE, DENSITY, DUALRCP, and ICV."
         )
     if df_comp[Headers.ANNULUS].iloc[idx] not in Content.ANNULUS_TYPES:
         raise CompletorError(
@@ -181,6 +181,36 @@ def _check_for_errors(df_comp: pd.DataFrame, well_name: str, idx: int) -> None:
         )
 
 
+def set_density_based(df_comp: pd.DataFrame) -> pd.DataFrame:
+    """Set the column data format.
+    Args:
+        df_comp: Completion data.
+    Returns:
+        Updated device type to all density based.
+    """
+    df_comp[Headers.DEVICE_TYPE] = np.where(
+        df_comp[Headers.DEVICE_TYPE] == Content.DENSITY_ACTIVATED_RECOVERY,
+        Content.DENSITY,
+        df_comp[Headers.DEVICE_TYPE],
+    )
+    return df_comp
+
+
+def set_dualrcp(df_comp: pd.DataFrame) -> pd.DataFrame:
+    """Set the column data format.
+    Args:
+        df_comp: Completion data.
+    Returns:
+        Updated device type to all dual RCP based.
+    """
+    df_comp[Headers.DEVICE_TYPE] = np.where(
+        df_comp[Headers.DEVICE_TYPE] == Content.AUTONOMOUS_INFLOW_CONTROL_VALVE,
+        Content.DUAL_RATE_CONTROLLED_PRODUCTION,
+        df_comp[Headers.DEVICE_TYPE],
+    )
+    return df_comp
+
+
 def set_format_wsegvalv(df_temp: pd.DataFrame) -> pd.DataFrame:
     """Format the Well Segments Valve (WELSEGS) table.
 
@@ -242,11 +272,11 @@ def set_format_wsegaicd(df_temp: pd.DataFrame) -> pd.DataFrame:
     return df_temp
 
 
-def set_format_wsegdar(df_temp: pd.DataFrame) -> pd.DataFrame:
-    """Format the well segments Density Activated Recovery (DAR) data.
+def set_format_wsegdensity(df_temp: pd.DataFrame) -> pd.DataFrame:
+    """Format the well segments Density Driven (DENSITY) data.
 
     Args:
-        df_temp: Well segments DAR device data.
+        df_temp: Well segments DENSITY device data.
 
     Returns:
         Updated data.
@@ -256,15 +286,15 @@ def set_format_wsegdar(df_temp: pd.DataFrame) -> pd.DataFrame:
     columns = df_temp.columns.to_numpy()[1:]
     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.DENSITY_ACTIVATED_RECOVERY))
+    df_temp.insert(0, Headers.DEVICE_TYPE, np.full(df_temp.shape[0], Content.DENSITY))
     return df_temp
 
 
-def set_format_wsegaicv(df_temp: pd.DataFrame) -> pd.DataFrame:
-    """Format the well segments Automatic Inflow Control Valve (AICV) table.
+def set_format_wsegdualrcp(df_temp: pd.DataFrame) -> pd.DataFrame:
+    """Format the well segments Dual RCP (DUALRCP) table.
 
     Args:
-        df_temp: Well segments automatic inflow control valve table.
+        df_temp: Well segments dual RCP table.
 
     Returns:
         Updated data.
@@ -274,7 +304,7 @@ def set_format_wsegaicv(df_temp: pd.DataFrame) -> pd.DataFrame:
     columns = df_temp.columns.to_numpy()[1:]
     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.AUTONOMOUS_INFLOW_CONTROL_VALVE))
+    df_temp.insert(0, Headers.DEVICE_TYPE, np.full(df_temp.shape[0], Content.DUAL_RATE_CONTROLLED_PRODUCTION))
     return df_temp
 
 

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

@@ -448,11 +448,11 @@ def prepare_device_layer(df_well: pd.DataFrame, df_tubing: pd.DataFrame, device_
                     df_well[Headers.DEVICE_TYPE] == Content.VALVE,
                     "/ -- Valve types",
                     np.where(
-                        df_well[Headers.DEVICE_TYPE] == Content.DENSITY_ACTIVATED_RECOVERY,
-                        "/ -- DAR types",
+                        df_well[Headers.DEVICE_TYPE] == Content.DENSITY,
+                        "/ -- DENSITY types",
                         np.where(
-                            df_well[Headers.DEVICE_TYPE] == Content.AUTONOMOUS_INFLOW_CONTROL_VALVE,
-                            "/ -- AICV types",
+                            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", ""
                             ),
@@ -852,6 +852,7 @@ def prepare_completion_segments(
             }
         )
     compseg[Headers.EMPTY] = "/"
+    compseg.sort_values(Headers.START_MEASURED_DEPTH, inplace=True)
     return compseg
 
 
@@ -1249,8 +1250,8 @@ def prepare_inflow_control_valve(
     return wsegicv
 
 
-def prepare_density_activated_recovery(well_name: str, df_well: pd.DataFrame, df_device: pd.DataFrame) -> pd.DataFrame:
-    """Prepare data frame for DAR.
+def prepare_density_driven(well_name: str, df_well: pd.DataFrame, df_device: pd.DataFrame) -> pd.DataFrame:
+    """Prepare data frame for DENSITY.
 
     Args:
         well_name: Well name.
@@ -1258,7 +1259,7 @@ def prepare_density_activated_recovery(well_name: str, df_well: pd.DataFrame, df
         df_device: Device data for this well and lateral.
 
     Returns:
-        DataFrame for DAR.
+        DataFrame for DENSITY.
     """
     df_well = df_well[(df_well[Headers.DEVICE_TYPE] == Content.PERFORATED) | (df_well[Headers.NUMBER_OF_DEVICES] > 0)]
     if df_well.shape[0] == 0:
@@ -1270,34 +1271,42 @@ def prepare_density_activated_recovery(well_name: str, df_well: pd.DataFrame, df
         right_on=[Headers.TUBING_MEASURED_DEPTH],
         direction="nearest",
     )
-    df_merge = df_merge[df_merge[Headers.DEVICE_TYPE] == Content.DENSITY_ACTIVATED_RECOVERY]
-    wsegdar = pd.DataFrame()
+    df_merge = df_merge[df_merge[Headers.DEVICE_TYPE] == Content.DENSITY]
+    wsegdensity = pd.DataFrame()
     if df_merge.shape[0] > 0:
-        wsegdar[Headers.WELL] = [well_name] * df_merge.shape[0]
-        wsegdar[Headers.START_SEGMENT_NUMBER] = df_merge[Headers.START_SEGMENT_NUMBER].to_numpy()
+        wsegdensity[Headers.WELL] = [well_name] * df_merge.shape[0]
+        wsegdensity[Headers.START_SEGMENT_NUMBER] = df_merge[Headers.START_SEGMENT_NUMBER].to_numpy()
         # the Cv is already corrected by the scaling factor
-        wsegdar[Headers.FLOW_COEFFICIENT] = df_merge[Headers.FLOW_COEFFICIENT].to_numpy()
-        wsegdar[Headers.OIL_FLOW_CROSS_SECTIONAL_AREA] = df_merge[Headers.OIL_FLOW_CROSS_SECTIONAL_AREA].to_numpy()
-        wsegdar[Headers.GAS_FLOW_CROSS_SECTIONAL_AREA] = df_merge[Headers.GAS_FLOW_CROSS_SECTIONAL_AREA].to_numpy()
-        wsegdar[Headers.WATER_FLOW_CROSS_SECTIONAL_AREA] = df_merge[Headers.WATER_FLOW_CROSS_SECTIONAL_AREA].to_numpy()
-        wsegdar[Headers.WATER_HOLDUP_FRACTION_LOW_CUTOFF] = df_merge[
+        wsegdensity[Headers.FLOW_COEFFICIENT] = df_merge[Headers.FLOW_COEFFICIENT].to_numpy()
+        wsegdensity[Headers.OIL_FLOW_CROSS_SECTIONAL_AREA] = df_merge[Headers.OIL_FLOW_CROSS_SECTIONAL_AREA].to_numpy()
+        wsegdensity[Headers.GAS_FLOW_CROSS_SECTIONAL_AREA] = df_merge[Headers.GAS_FLOW_CROSS_SECTIONAL_AREA].to_numpy()
+        wsegdensity[Headers.WATER_FLOW_CROSS_SECTIONAL_AREA] = df_merge[
+            Headers.WATER_FLOW_CROSS_SECTIONAL_AREA
+        ].to_numpy()
+        wsegdensity[Headers.WATER_HOLDUP_FRACTION_LOW_CUTOFF] = df_merge[
             Headers.WATER_HOLDUP_FRACTION_LOW_CUTOFF
         ].to_numpy()
-        wsegdar[Headers.WATER_HOLDUP_FRACTION_HIGH_CUTOFF] = df_merge[
+        wsegdensity[Headers.WATER_HOLDUP_FRACTION_HIGH_CUTOFF] = df_merge[
             Headers.WATER_HOLDUP_FRACTION_HIGH_CUTOFF
         ].to_numpy()
-        wsegdar[Headers.GAS_HOLDUP_FRACTION_LOW_CUTOFF] = df_merge[Headers.GAS_HOLDUP_FRACTION_LOW_CUTOFF].to_numpy()
-        wsegdar[Headers.GAS_HOLDUP_FRACTION_HIGH_CUTOFF] = df_merge[Headers.GAS_HOLDUP_FRACTION_HIGH_CUTOFF].to_numpy()
-        wsegdar[Headers.DEFAULTS] = "5*"
-        wsegdar[Headers.MAX_FLOW_CROSS_SECTIONAL_AREA] = wsegdar[Headers.OIL_FLOW_CROSS_SECTIONAL_AREA].to_numpy()
-        wsegdar[Headers.EMPTY] = "/"
-    return wsegdar
+        wsegdensity[Headers.GAS_HOLDUP_FRACTION_LOW_CUTOFF] = df_merge[
+            Headers.GAS_HOLDUP_FRACTION_LOW_CUTOFF
+        ].to_numpy()
+        wsegdensity[Headers.GAS_HOLDUP_FRACTION_HIGH_CUTOFF] = df_merge[
+            Headers.GAS_HOLDUP_FRACTION_HIGH_CUTOFF
+        ].to_numpy()
+        wsegdensity[Headers.DEFAULTS] = "5*"
+        wsegdensity[Headers.MAX_FLOW_CROSS_SECTIONAL_AREA] = wsegdensity[
+            Headers.OIL_FLOW_CROSS_SECTIONAL_AREA
+        ].to_numpy()
+        wsegdensity[Headers.EMPTY] = "/"
+    return wsegdensity
 
 
-def prepare_autonomous_inflow_control_valve(
+def prepare_dual_rate_controlled_production(
     well_name: str, df_well: pd.DataFrame, df_device: pd.DataFrame
 ) -> pd.DataFrame:
-    """Prepare data frame for AICV.
+    """Prepare data frame for DUALRCP.
 
     Args:
         well_name: Well name.
@@ -1305,7 +1314,7 @@ def prepare_autonomous_inflow_control_valve(
         df_device: Device data for this well and lateral.
 
     Returns:
-        DataFrame for AICV.
+        DataFrame for DUALRCP.
     """
     df_well = df_well[(df_well[Headers.DEVICE_TYPE] == Content.PERFORATED) | (df_well[Headers.NUMBER_OF_DEVICES] > 0)]
     if df_well.shape[0] == 0:
@@ -1317,53 +1326,53 @@ def prepare_autonomous_inflow_control_valve(
         right_on=[Headers.TUBING_MEASURED_DEPTH],
         direction="nearest",
     )
-    df_merge = df_merge[df_merge[Headers.DEVICE_TYPE] == Content.AUTONOMOUS_INFLOW_CONTROL_VALVE]
-    wsegaicv = pd.DataFrame()
+    df_merge = df_merge[df_merge[Headers.DEVICE_TYPE] == Content.DUAL_RATE_CONTROLLED_PRODUCTION]
+    wsegdualrcp = pd.DataFrame()
     if df_merge.shape[0] > 0:
-        wsegaicv[Headers.WELL] = [well_name] * df_merge.shape[0]
-        wsegaicv[Headers.START_SEGMENT_NUMBER] = df_merge[Headers.START_SEGMENT_NUMBER].to_numpy()
-        wsegaicv[Headers.END_SEGMENT_NUMBER] = df_merge[Headers.START_SEGMENT_NUMBER].to_numpy()
-        wsegaicv[Headers.ALPHA_MAIN] = df_merge[Headers.ALPHA_MAIN].to_numpy()
-        wsegaicv[Headers.SCALE_FACTOR] = df_merge[Headers.SCALE_FACTOR].to_numpy()
-        wsegaicv[Headers.CALIBRATION_FLUID_DENSITY] = df_merge[Headers.AICV_CALIBRATION_FLUID_DENSITY].to_numpy()
-        wsegaicv[Headers.CALIBRATION_FLUID_VISCOSITY] = df_merge[Headers.AICV_FLUID_VISCOSITY].to_numpy()
-        wsegaicv[Headers.DEF] = ["5*"] * df_merge.shape[0]
-        wsegaicv[Headers.X_MAIN] = df_merge[Headers.X_MAIN].to_numpy()
-        wsegaicv[Headers.Y_MAIN] = df_merge[Headers.Y_MAIN].to_numpy()
-        wsegaicv[Headers.FLAG] = [Headers.OPEN] * df_merge.shape[0]
-        wsegaicv[Headers.A_MAIN] = df_merge[Headers.A_MAIN].to_numpy()
-        wsegaicv[Headers.B_MAIN] = df_merge[Headers.B_MAIN].to_numpy()
-        wsegaicv[Headers.C_MAIN] = df_merge[Headers.C_MAIN].to_numpy()
-        wsegaicv[Headers.D_MAIN] = df_merge[Headers.D_MAIN].to_numpy()
-        wsegaicv[Headers.E_MAIN] = df_merge[Headers.E_MAIN].to_numpy()
-        wsegaicv[Headers.F_MAIN] = df_merge[Headers.F_MAIN].to_numpy()
-        wsegaicv[Headers.ALPHA_PILOT] = df_merge[Headers.ALPHA_PILOT].to_numpy()
-        wsegaicv[Headers.X_PILOT] = df_merge[Headers.X_PILOT].to_numpy()
-        wsegaicv[Headers.Y_PILOT] = df_merge[Headers.Y_PILOT].to_numpy()
-        wsegaicv[Headers.A_PILOT] = df_merge[Headers.A_PILOT].to_numpy()
-        wsegaicv[Headers.B_PILOT] = df_merge[Headers.B_PILOT].to_numpy()
-        wsegaicv[Headers.C_PILOT] = df_merge[Headers.C_PILOT].to_numpy()
-        wsegaicv[Headers.D_PILOT] = df_merge[Headers.D_PILOT].to_numpy()
-        wsegaicv[Headers.E_PILOT] = df_merge[Headers.E_PILOT].to_numpy()
-        wsegaicv[Headers.F_PILOT] = df_merge[Headers.F_PILOT].to_numpy()
-        wsegaicv[Headers.AICV_WATER_CUT] = df_merge[Headers.AICV_WATER_CUT].to_numpy()
-        wsegaicv[Headers.AICV_GAS_HOLDUP_FRACTION] = df_merge[Headers.AICV_GAS_HOLDUP_FRACTION].to_numpy()
-        wsegaicv[Headers.EMPTY] = "/"
-    return wsegaicv
-
-
-def print_wsegdar(df_wsegdar: pd.DataFrame, well_number: int) -> str:
-    """Print DAR devices.
+        wsegdualrcp[Headers.WELL] = [well_name] * df_merge.shape[0]
+        wsegdualrcp[Headers.START_SEGMENT_NUMBER] = df_merge[Headers.START_SEGMENT_NUMBER].to_numpy()
+        wsegdualrcp[Headers.END_SEGMENT_NUMBER] = df_merge[Headers.START_SEGMENT_NUMBER].to_numpy()
+        wsegdualrcp[Headers.ALPHA_MAIN] = df_merge[Headers.ALPHA_MAIN].to_numpy()
+        wsegdualrcp[Headers.SCALE_FACTOR] = df_merge[Headers.SCALE_FACTOR].to_numpy()
+        wsegdualrcp[Headers.CALIBRATION_FLUID_DENSITY] = df_merge[Headers.DUALRCP_CALIBRATION_FLUID_DENSITY].to_numpy()
+        wsegdualrcp[Headers.CALIBRATION_FLUID_VISCOSITY] = df_merge[Headers.DUALRCP_FLUID_VISCOSITY].to_numpy()
+        wsegdualrcp[Headers.DEF] = ["5*"] * df_merge.shape[0]
+        wsegdualrcp[Headers.X_MAIN] = df_merge[Headers.X_MAIN].to_numpy()
+        wsegdualrcp[Headers.Y_MAIN] = df_merge[Headers.Y_MAIN].to_numpy()
+        wsegdualrcp[Headers.FLAG] = [Headers.OPEN] * df_merge.shape[0]
+        wsegdualrcp[Headers.A_MAIN] = df_merge[Headers.A_MAIN].to_numpy()
+        wsegdualrcp[Headers.B_MAIN] = df_merge[Headers.B_MAIN].to_numpy()
+        wsegdualrcp[Headers.C_MAIN] = df_merge[Headers.C_MAIN].to_numpy()
+        wsegdualrcp[Headers.D_MAIN] = df_merge[Headers.D_MAIN].to_numpy()
+        wsegdualrcp[Headers.E_MAIN] = df_merge[Headers.E_MAIN].to_numpy()
+        wsegdualrcp[Headers.F_MAIN] = df_merge[Headers.F_MAIN].to_numpy()
+        wsegdualrcp[Headers.ALPHA_PILOT] = df_merge[Headers.ALPHA_PILOT].to_numpy()
+        wsegdualrcp[Headers.X_PILOT] = df_merge[Headers.X_PILOT].to_numpy()
+        wsegdualrcp[Headers.Y_PILOT] = df_merge[Headers.Y_PILOT].to_numpy()
+        wsegdualrcp[Headers.A_PILOT] = df_merge[Headers.A_PILOT].to_numpy()
+        wsegdualrcp[Headers.B_PILOT] = df_merge[Headers.B_PILOT].to_numpy()
+        wsegdualrcp[Headers.C_PILOT] = df_merge[Headers.C_PILOT].to_numpy()
+        wsegdualrcp[Headers.D_PILOT] = df_merge[Headers.D_PILOT].to_numpy()
+        wsegdualrcp[Headers.E_PILOT] = df_merge[Headers.E_PILOT].to_numpy()
+        wsegdualrcp[Headers.F_PILOT] = df_merge[Headers.F_PILOT].to_numpy()
+        wsegdualrcp[Headers.DUALRCP_WATER_CUT] = df_merge[Headers.DUALRCP_WATER_CUT].to_numpy()
+        wsegdualrcp[Headers.DUALRCP_GAS_HOLDUP_FRACTION] = df_merge[Headers.DUALRCP_GAS_HOLDUP_FRACTION].to_numpy()
+        wsegdualrcp[Headers.EMPTY] = "/"
+    return wsegdualrcp
+
+
+def print_wsegdensity(df_wsegdensity: pd.DataFrame, well_number: int) -> str:
+    """Print DENSITY devices.
 
     Args:
-        df_wsegdar: Output from function prepare_wsegdar.
+        df_wsegdensity: Output from function prepare_wsegdensity.
         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 DAR.
+        CompletorError: If there are to many wells and/or segments with DENSITY.
     """
     header = [
         [
@@ -1403,9 +1412,9 @@ def print_wsegdar(df_wsegdar: pd.DataFrame, well_number: int) -> str:
     sign_gas = [">", "<=", "<", ""]
     suvtrig = ["0", "0", "1", "2"]
     action = "UDQ\n"
-    for idx in range(df_wsegdar.shape[0]):
-        segment_number = df_wsegdar[Headers.START_SEGMENT_NUMBER].iloc[idx]
-        well_name = df_wsegdar[Headers.WELL].iloc[idx]
+    for idx in range(df_wsegdensity.shape[0]):
+        segment_number = df_wsegdensity[Headers.START_SEGMENT_NUMBER].iloc[idx]
+        well_name = df_wsegdensity[Headers.WELL].iloc[idx]
         action += f"  ASSIGN SUVTRIG {well_name} {segment_number} 0 /\n"
     action += "/\n\n"
     iaction = 3
@@ -1414,25 +1423,25 @@ def print_wsegdar(df_wsegdar: pd.DataFrame, well_number: int) -> str:
     for itm in header[iaction]:
         header_string += "  " + itm
     action += header_string.rstrip() + "\n"
-    for idx in range(df_wsegdar.shape[0]):
-        segment_number = df_wsegdar[Headers.START_SEGMENT_NUMBER].iloc[idx]
-        print_df = df_wsegdar[df_wsegdar[Headers.START_SEGMENT_NUMBER] == segment_number]
+    for idx in range(df_wsegdensity.shape[0]):
+        segment_number = df_wsegdensity[Headers.START_SEGMENT_NUMBER].iloc[idx]
+        print_df = df_wsegdensity[df_wsegdensity[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_wsegdar.shape[0]):
-        segment_number = df_wsegdar[Headers.START_SEGMENT_NUMBER].iloc[idx]
-        well_name = df_wsegdar[Headers.WELL].iloc[idx]
-        water_holdup_fraction_low_cutoff = df_wsegdar[Headers.WATER_HOLDUP_FRACTION_LOW_CUTOFF].iloc[idx]
-        water_holdup_fraction_high_cutoff = df_wsegdar[Headers.WATER_HOLDUP_FRACTION_HIGH_CUTOFF].iloc[idx]
-        gas_holdup_fraction_low_cutoff = df_wsegdar[Headers.GAS_HOLDUP_FRACTION_LOW_CUTOFF].iloc[idx]
-        gas_holdup_fraction_high_cutoff = df_wsegdar[Headers.GAS_HOLDUP_FRACTION_HIGH_CUTOFF].iloc[idx]
+    for idx in range(df_wsegdensity.shape[0]):
+        segment_number = df_wsegdensity[Headers.START_SEGMENT_NUMBER].iloc[idx]
+        well_name = df_wsegdensity[Headers.WELL].iloc[idx]
+        water_holdup_fraction_low_cutoff = df_wsegdensity[Headers.WATER_HOLDUP_FRACTION_LOW_CUTOFF].iloc[idx]
+        water_holdup_fraction_high_cutoff = df_wsegdensity[Headers.WATER_HOLDUP_FRACTION_HIGH_CUTOFF].iloc[idx]
+        gas_holdup_fraction_low_cutoff = df_wsegdensity[Headers.GAS_HOLDUP_FRACTION_LOW_CUTOFF].iloc[idx]
+        gas_holdup_fraction_high_cutoff = df_wsegdensity[Headers.GAS_HOLDUP_FRACTION_HIGH_CUTOFF].iloc[idx]
         for iaction in range(2):
             act_number = iaction + 1
             act_name = f"D{well_number:03d}{segment_number:03d}{act_number:1d}"
             if len(act_name) > 8:
-                raise CompletorError("Too many wells and/or too many segments with DAR")
+                raise CompletorError("Too many wells and/or too many segments with DENSITY")
             action += (
                 f"ACTIONX\n{act_name} 1000000 /\n"
                 f"SWHF '{well_name}' {segment_number} "
@@ -1442,7 +1451,7 @@ def print_wsegdar(df_wsegdar: pd.DataFrame, well_number: int) -> str:
                 f"SUVTRIG '{well_name}' {segment_number} "
                 f"= {suvtrig[iaction]} /\n/\n\n"
             )
-            print_df = df_wsegdar[df_wsegdar[Headers.START_SEGMENT_NUMBER] == segment_number]
+            print_df = df_wsegdensity[df_wsegdensity[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]:
@@ -1460,7 +1469,7 @@ def print_wsegdar(df_wsegdar: pd.DataFrame, well_number: int) -> str:
         act_number = iaction + 1
         act_name = f"D{well_number:03d}{segment_number:03d}{act_number:1d}"
         if len(act_name) > 8:
-            raise CompletorError("Too many wells and/or too many segments with DAR")
+            raise CompletorError("Too many wells and/or too many segments with DENSITY")
         action += (
             f"ACTIONX\n{act_name} 1000000 /\n"
             f"SGHF '{well_name}' {segment_number} "
@@ -1468,7 +1477,7 @@ def print_wsegdar(df_wsegdar: pd.DataFrame, well_number: int) -> str:
             f"SUVTRIG '{well_name}' {segment_number} "
             f"= {suvtrig[iaction]} /\n/\n\n"
         )
-        print_df = df_wsegdar[df_wsegdar[Headers.START_SEGMENT_NUMBER] == segment_number]
+        print_df = df_wsegdensity[df_wsegdensity[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]:
@@ -1483,7 +1492,7 @@ def print_wsegdar(df_wsegdar: pd.DataFrame, well_number: int) -> str:
         act_number = iaction + 1
         act_name = f"D{well_number:03d}{segment_number:03d}{act_number:1d}"
         if len(act_name) > 8:
-            raise CompletorError("Too many wells and/or too many segments with DAR")
+            raise CompletorError("Too many wells and/or too many segments with DENSITY")
         action += (
             f"ACTIONX\n{act_name} 1000000 /\n"
             f"SWHF '{well_name}' {segment_number} "
@@ -1491,7 +1500,7 @@ def print_wsegdar(df_wsegdar: pd.DataFrame, well_number: int) -> str:
             f"SUVTRIG '{well_name}' {segment_number} "
             f"= {suvtrig[iaction]} /\n/\n\n"
         )
-        print_df = df_wsegdar[df_wsegdar[Headers.START_SEGMENT_NUMBER] == segment_number]
+        print_df = df_wsegdensity[df_wsegdensity[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]:
@@ -1504,18 +1513,18 @@ def print_wsegdar(df_wsegdar: pd.DataFrame, well_number: int) -> str:
     return action
 
 
-def print_wsegaicv(df_wsegaicv: pd.DataFrame, well_number: int) -> str:
-    """Print for AICV devices.
+def print_wsegdualrcp(df_wsegdualrcp: pd.DataFrame, well_number: int) -> str:
+    """Print for DUALRCP devices.
 
     Args:
-        df_wsegaicv: Output from function prepare_wsegaicv.
+        df_wsegdualrcp: Output from function prepare_wsegdualrcp.
         well_number: Well number.
 
     Returns:
         Formatted actions to be included in the output file.
 
     Raises:
-        CompletorError: If there are too many wells and/or segments with AICV.
+        CompletorError: If there are too many wells and/or segments with DUALRCP.
     """
     header = [
         [
@@ -1583,17 +1592,17 @@ def print_wsegaicv(df_wsegaicv: pd.DataFrame, well_number: int) -> str:
     sign_gas = ["<", ">="]
     operator = ["AND", "OR"]
     action = ""
-    for idx in range(df_wsegaicv.shape[0]):
-        segment_number = df_wsegaicv[Headers.START_SEGMENT_NUMBER].iloc[idx]
-        well_name = df_wsegaicv[Headers.WELL].iloc[idx]
-        wct = df_wsegaicv[Headers.AICV_WATER_CUT].iloc[idx]
-        ghf = df_wsegaicv[Headers.AICV_GAS_HOLDUP_FRACTION].iloc[idx]
+    for idx in range(df_wsegdualrcp.shape[0]):
+        segment_number = df_wsegdualrcp[Headers.START_SEGMENT_NUMBER].iloc[idx]
+        well_name = df_wsegdualrcp[Headers.WELL].iloc[idx]
+        wct = df_wsegdualrcp[Headers.DUALRCP_WATER_CUT].iloc[idx]
+        ghf = df_wsegdualrcp[Headers.DUALRCP_GAS_HOLDUP_FRACTION].iloc[idx]
         # LOWWCT_LOWGHF
         for iaction in range(2):
             act_number = iaction + 1
             act_name = f"V{well_number:03d}{segment_number:03d}{act_number:1d}"
             if len(act_name) > 8:
-                raise CompletorError("Too many wells and/or too many segments with AICV")
+                raise CompletorError("Too many wells and/or too many segments with DUALRCP")
             action += (
                 f"ACTIONX\n{act_name} 1000000 /\n"
                 f"SUWCT '{well_name}' {segment_number} {sign_water[iaction]} "
@@ -1601,7 +1610,7 @@ def print_wsegaicv(df_wsegaicv: pd.DataFrame, well_number: int) -> str:
                 f"SGHF '{well_name}' {segment_number} {sign_gas[iaction]} {ghf} /\n/\n"
             )
 
-            print_df = df_wsegaicv[df_wsegaicv[Headers.START_SEGMENT_NUMBER] == segment_number]
+            print_df = df_wsegdualrcp[df_wsegdualrcp[Headers.START_SEGMENT_NUMBER] == segment_number]
             print_df = print_df[header[iaction]]
             print_df.columns = new_column
             print_df = Keywords.AUTONOMOUS_INFLOW_CONTROL_DEVICE + "\n" + dataframe_tostring(print_df, True)

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

@@ -47,8 +47,8 @@ class ReadCasefile:
 
     This class reads the case/input file of the Completor program.
     It reads the following keywords:
-    SCHEDULE_FILE, OUT_FILE, COMPLETION, SEGMENTLENGTH, JOINTLENGTH AUTONOMOUS_INFLOW_CONTROL_DEVICE, WELL_SEGMENTS_VALVE,
-    INFLOW_CONTROL_DEVICE, DENSITY_ACTIVATED_RECOVERY, AUTONOMOUS_INFLOW_CONTROL_VALVE, INFLOW_CONTROL_VALVE, PVTFILE, PVTTABLE.
+    COMPLETION, SEGMENTLENGTH, JOINTLENGTH, AUTONOMOUS_INFLOW_CONTROL_DEVICE, WELL_SEGMENTS_VALVE,
+    INFLOW_CONTROL_DEVICE, DENSITY_DRIVEN, DUAL_RATE_CONTROLLED_PRODUCTION, INFLOW_CONTROL_VALVE.
     In the absence of some keywords, the program uses the default values.
 
     Attributes:
@@ -63,8 +63,8 @@ class ReadCasefile:
         wsegsicd_table (pd.DataFrame): INFLOW_CONTROL_DEVICE.
         wsegvalv_table (pd.DataFrame): WELL_SEGMENTS_VALVE.
         wsegicv_table (pd.DataFrame): INFLOW_CONTROL_VALVE.
-        wsegdar_table (pd.DataFrame): DENSITY_ACTIVATED_RECOVERY.
-        wsegaicv_table (pd.DataFrame): AUTONOMOUS_INFLOW_CONTROL_VALVE.
+        wsegdensity_table (pd.DataFrame): DENSITY_DRIVEN.
+        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.
         gp_perf_devicelayer (bool): GRAVEL_PACKED_PERFORATED_DEVICELAYER. If TRUE all wells with
@@ -98,8 +98,8 @@ class ReadCasefile:
         self.wsegaicd_table = pd.DataFrame()
         self.wsegsicd_table = pd.DataFrame()
         self.wsegvalv_table = pd.DataFrame()
-        self.wsegdar_table = pd.DataFrame()
-        self.wsegaicv_table = pd.DataFrame()
+        self.wsegdensity_table = pd.DataFrame()
+        self.wsegdualrcp_table = pd.DataFrame()
         self.wsegicv_table = pd.DataFrame()
         self.lat2device = pd.DataFrame()
         self.mapfile: pd.DataFrame | str | None = None
@@ -116,8 +116,8 @@ class ReadCasefile:
         self.read_wsegaicd()
         self.read_wsegvalv()
         self.read_wsegsicd()
-        self.read_wsegdar()
-        self.read_wsegaicv()
+        self.read_wsegdensity()
+        self.read_wsegdualrcp()
         self.read_wsegicv()
         self.read_lat2device()
         self.read_minimum_segment_length()
@@ -155,6 +155,10 @@ class ReadCasefile:
         df_temp = input_validation.check_default_non_packer(df_temp)
         # Fix the data types format
         df_temp = input_validation.set_format_completion(df_temp)
+        # Fix the Density based
+        df_temp = input_validation.set_density_based(df_temp)
+        # Fix the Dual RCP
+        df_temp = input_validation.set_dualrcp(df_temp)
         # Check overall user inputs on completion
         input_validation.assess_completion(df_temp)
         df_temp = self.read_icv_tubing(df_temp)
@@ -457,19 +461,25 @@ class ReadCasefile:
                     f"Not all device in COMPLETION is specified in {Keywords.AUTONOMOUS_INFLOW_CONTROL_DEVICE}"
                 )
 
-    def read_wsegdar(self) -> None:
-        """Read the DENSITY_ACTIVATED_RECOVERY keyword in the case file.
+    def read_wsegdensity(self) -> None:
+        """Read the DENSITY keyword in the case file.
 
         Raises:
-            ValueError: If there are invalid entries in DENSITY_ACTIVATED_RECOVERY.
-            CompletorError: If not all device in COMPLETION is specified in DENSITY_ACTIVATED_RECOVERY.
-                If DENSITY_ACTIVATED_RECOVERY keyword not defined, when DAR is used in the completion.
+            ValueError: If there are invalid entries in DENSITY.
+            CompletorError: If not all device in COMPLETION is specified in DENSITY.
+                If DENSITY keyword not defined, when DENSITY is used in the completion.
         """
-        start_index, end_index = parse.locate_keyword(self.content, Keywords.DENSITY_ACTIVATED_RECOVERY)
-        if start_index == end_index:
-            if Content.DENSITY_ACTIVATED_RECOVERY in self.completion_table[Headers.DEVICE_TYPE]:
+        density_index_start, density_index_end = parse.locate_keyword(self.content, Keywords.DENSITY)
+        dar_index_start, dar_index_end = parse.locate_keyword(self.content, Keywords.DENSITY_ACTIVATED_RECOVERY)
+
+        # Determine which keyword is present
+        if density_index_start == density_index_end and dar_index_start == dar_index_end:
+            if (
+                Content.DENSITY in self.completion_table[Headers.DEVICE_TYPE]
+                or Content.DENSITY_ACTIVATED_RECOVERY in self.completion_table[Headers.DEVICE_TYPE]
+            ):
                 raise CompletorError(
-                    f"{Keywords.DENSITY_ACTIVATED_RECOVERY} keyword must be defined, if DAR is used in the completion"
+                    f"{Keywords.DENSITY} keyword must be defined, if DENSITY is used in the completion."
                 )
         else:
             # Table headers
@@ -485,42 +495,56 @@ class ReadCasefile:
                 Headers.GAS_HOLDUP_FRACTION_HIGH_CUTOFF,
             ]
 
+            # Get start and end index from correct keyword
+            if not density_index_start == density_index_end:
+                start_index, end_index = density_index_start, density_index_end
+                key = Keywords.DENSITY
+                content = Content.DENSITY
+            else:
+                start_index, end_index = dar_index_start, dar_index_end
+                key = Keywords.DENSITY_ACTIVATED_RECOVERY
+                content = Content.DENSITY_ACTIVATED_RECOVERY
             # Fix table format
-            if self.completion_table[Headers.DEVICE_TYPE].str.contains(Content.DENSITY_ACTIVATED_RECOVERY).any():
-                self.wsegdar_table = input_validation.set_format_wsegdar(
-                    self._create_dataframe_with_columns(header, start_index, end_index)
-                )
-                device_checks = self.completion_table[
-                    self.completion_table[Headers.DEVICE_TYPE] == Content.DENSITY_ACTIVATED_RECOVERY
-                ][Headers.DEVICE_NUMBER].to_numpy()
-                if not check_contents(device_checks, self.wsegdar_table[Headers.DEVICE_NUMBER].to_numpy()):
-                    raise CompletorError(
-                        f"Not all device in COMPLETION is specified in {Keywords.DENSITY_ACTIVATED_RECOVERY}"
-                    )
+            self.wsegdensity_table = input_validation.set_format_wsegdensity(
+                self._create_dataframe_with_columns(header, start_index, end_index)
+            )
+            device_checks = self.completion_table[self.completion_table[Headers.DEVICE_TYPE] == content][
+                Headers.DEVICE_NUMBER
+            ].to_numpy()
+            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_wsegaicv(self) -> None:
-        """Read the AUTONOMOUS_INFLOW_CONTROL_VALVE keyword in the case file.
+    def read_wsegdualrcp(self) -> None:
+        """Read the DUALRCP keyword in the case file.
 
         Raises:
-            ValueError: If invalid entries in AUTONOMOUS_INFLOW_CONTROL_VALVE.
-            CompletorError: AUTONOMOUS_INFLOW_CONTROL_VALVE keyword not defined when AICV is used in completion.
-                If all devices in COMPLETION are not specified in AUTONOMOUS_INFLOW_CONTROL_VALVE.
+            ValueError: If invalid entries in DUALRCP.
+            CompletorError: DUALRCP keyword not defined when DUALRCP is used in completion.
+                If all devices in COMPLETION are not specified in DUALRCP.
         """
-        start_index, end_index = parse.locate_keyword(self.content, Keywords.AUTONOMOUS_INFLOW_CONTROL_VALVE)
-        if start_index == end_index:
-            if Content.AUTONOMOUS_INFLOW_CONTROL_VALVE in self.completion_table[Headers.DEVICE_TYPE]:
+        dualrcp_index_start, dualrcp_index_end = parse.locate_keyword(
+            self.content, Keywords.DUAL_RATE_CONTROLLED_PRODUCTION
+        )
+        aicv_index_start, aicv_index_end = parse.locate_keyword(self.content, Keywords.AUTONOMOUS_INFLOW_CONTROL_VALVE)
+
+        # Determine which keyword is present
+        if dualrcp_index_start == dualrcp_index_end and aicv_index_start == aicv_index_end:
+            if (
+                Content.DUAL_RATE_CONTROLLED_PRODUCTION in self.completion_table[Headers.DEVICE_TYPE]
+                or Content.AUTONOMOUS_INFLOW_CONTROL_VALVE in self.completion_table[Headers.DEVICE_TYPE]
+            ):
                 raise CompletorError(
-                    f"{Keywords.AUTONOMOUS_INFLOW_CONTROL_VALVE} keyword must be defined, "
-                    "if AICV is used in the completion."
+                    f"{Keywords.DUAL_RATE_CONTROLLED_PRODUCTION} keyword must be defined, "
+                    "if DUALRCP is used in the completion."
                 )
         else:
             # Table headers
             header = [
                 Headers.DEVICE_NUMBER,
-                Headers.AICV_WATER_CUT,
-                Headers.AICV_GAS_HOLDUP_FRACTION,
-                Headers.AICV_CALIBRATION_FLUID_DENSITY,
-                Headers.AICV_FLUID_VISCOSITY,
+                Headers.DUALRCP_WATER_CUT,
+                Headers.DUALRCP_GAS_HOLDUP_FRACTION,
+                Headers.DUALRCP_CALIBRATION_FLUID_DENSITY,
+                Headers.DUALRCP_FLUID_VISCOSITY,
                 Headers.ALPHA_MAIN,
                 Headers.X_MAIN,
                 Headers.Y_MAIN,
@@ -540,18 +564,25 @@ class ReadCasefile:
                 Headers.E_PILOT,
                 Headers.F_PILOT,
             ]
+            # Get start and end index from correct keyword
+            if not dualrcp_index_start == dualrcp_index_end:
+                start_index, end_index = dualrcp_index_start, dualrcp_index_end
+                key = Keywords.DUAL_RATE_CONTROLLED_PRODUCTION
+                content = Content.DUAL_RATE_CONTROLLED_PRODUCTION
+            else:
+                start_index, end_index = aicv_index_start, aicv_index_end
+                key = Keywords.AUTONOMOUS_INFLOW_CONTROL_VALVE
+                content = Content.AUTONOMOUS_INFLOW_CONTROL_VALVE
             # Fix table format
-            self.wsegaicv_table = input_validation.set_format_wsegaicv(
+            self.wsegdualrcp_table = input_validation.set_format_wsegdualrcp(
                 self._create_dataframe_with_columns(header, start_index, end_index)
             )
-            # Check if the device in COMPLETION is exist in AUTONOMOUS_INFLOW_CONTROL_VALVE
-            device_checks = self.completion_table[
-                self.completion_table[Headers.DEVICE_TYPE] == Content.AUTONOMOUS_INFLOW_CONTROL_VALVE
-            ][Headers.DEVICE_NUMBER].to_numpy()
-            if not check_contents(device_checks, self.wsegaicv_table[Headers.DEVICE_NUMBER].to_numpy()):
-                raise CompletorError(
-                    f"Not all devices in COMPLETION are specified in {Keywords.AUTONOMOUS_INFLOW_CONTROL_VALVE}"
-                )
+            # Check if the device in COMPLETION is exist in DUALRCP
+            device_checks = self.completion_table[self.completion_table[Headers.DEVICE_TYPE] == content][
+                Headers.DEVICE_NUMBER
+            ].to_numpy()
+            if not check_contents(device_checks, self.wsegdualrcp_table[Headers.DEVICE_NUMBER].to_numpy()):
+                raise CompletorError(f"Not all devices in COMPLETION are specified in {key}")
 
     def read_wsegicv(self) -> None:
         """Read INFLOW_CONTROL_VALVE keyword in the case file.

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

@@ -191,8 +191,8 @@ def get_active_wells(completion_table: pd.DataFrame, gp_perf_devicelayer: bool)
         perf_check = completion_table[Headers.DEVICE_TYPE].isin(
             [
                 Content.AUTONOMOUS_INFLOW_CONTROL_DEVICE,
-                Content.AUTONOMOUS_INFLOW_CONTROL_VALVE,
-                Content.DENSITY_ACTIVATED_RECOVERY,
+                Content.DUAL_RATE_CONTROLLED_PRODUCTION,
+                Content.DENSITY,
                 Content.INFLOW_CONTROL_DEVICE,
                 Content.VALVE,
                 Content.INFLOW_CONTROL_VALVE,

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

@@ -46,9 +46,9 @@ def visualize_device(axs: Axes, df_well: pd.DataFrame) -> Axes:
             axs.plot(xpar, ypar, "rs-", markevery=[1])
         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] == Content.DENSITY_ACTIVATED_RECOVERY:
+        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.AUTONOMOUS_INFLOW_CONTROL_VALVE:
+        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.1 → completor-1.1.3}/completor/wells.py

@@ -218,10 +218,10 @@ class Lateral:
             df_well = completion.get_device(df_well, case.wsegsicd_table, Content.INFLOW_CONTROL_DEVICE)
         if Content.AUTONOMOUS_INFLOW_CONTROL_DEVICE in active_devices:
             df_well = completion.get_device(df_well, case.wsegaicd_table, Content.AUTONOMOUS_INFLOW_CONTROL_DEVICE)
-        if Content.DENSITY_ACTIVATED_RECOVERY in active_devices:
-            df_well = completion.get_device(df_well, case.wsegdar_table, Content.DENSITY_ACTIVATED_RECOVERY)
-        if Content.AUTONOMOUS_INFLOW_CONTROL_VALVE in active_devices:
-            df_well = completion.get_device(df_well, case.wsegaicv_table, Content.AUTONOMOUS_INFLOW_CONTROL_VALVE)
+        if Content.DENSITY in active_devices:
+            df_well = completion.get_device(df_well, case.wsegdensity_table, Content.DENSITY)
+        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:
             df_well = completion.get_device(df_well, case.wsegicv_table, Content.INFLOW_CONTROL_VALVE)
         return df_well

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

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "completor"
-version = "1.1.1"
-description = "Advanced mulit-segmented well completion tool."
+version = "1.1.3"
+description = "Advanced multi-segmented well completion tool."
 authors = ["Equinor ASA <opensource@equinor.com>"]
 repository = "https://github.com/equinor/completor"
 documentation = "https://equinor.github.io/completor"
@@ -19,28 +19,31 @@ classifiers = [
 "Bug Tracker" = "https://github.com/equinor/completor/issues"
 
 [tool.poetry.dependencies]
-python = ">=3.11, <3.12"
-matplotlib = "^3.6"
-numpy = "<2"
-pandas = "^2.1.4"
-scipy = "^1.10"
-tqdm = "^4.50"
-pytest-env = "^1"
+python = "^3.11"
+matplotlib = "^3.9"
+numpy = ">=1.26, <3.0"
+pandas = "^2.2"
+scipy = "^1.14"
+tqdm = "^4.66"
 
-docutils = {version="0.20.1", optional=true} # Pinned due to problems with OS spesific builds
-rstcheck-core = {version="^1.2.1", optional=true}
-ert = {version=">11.1.0", optional=true}
-pyqt5-qt5 = {version="5.15.2", optional=true} # Pinned due to problems with OS spesific builds
+rstcheck-core = {version="^1.2", optional=true}
+ert = {version="^12", optional=true}
+pytest = {version="^8.3", optional=true}
+pytest-xdist = {version="^3.6", optional=true}
+pytest-env = {version="^1", optional=true}
 
 [tool.poetry.group.dev.dependencies]
-black = "^24.4.2"
-flake8 = "^7.0.0"
-pre-commit = "^4.0.1"
-pytest = "^8.3.3"
-pytest-xdist = "^3.6.1"
+black = "^24.4"
+flake8 = "^7.0"
+pre-commit = "^4.0"
+pytest = "^8.3"
+pytest-xdist = "^3.6"
+pytest-env = "^1.1"
+rstcheck-core = "^1.2"
 
 [tool.poetry.extras]
-ert = ["rstcheck-core", "ert", "pyqt5-qt5", "docutils"]
+ert = ["ert"]
+test = ["pytest", "pytest-xdist", "pytest-env", "rstcheck-core"]
 
 [tool.poetry.scripts]
 completor = "completor.main:main"