completor 1.1.1__py3-none-any.whl → 1.1.3__py3-none-any.whl

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/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/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/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/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/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/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/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/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.dist-info → completor-1.1.3.dist-info}/METADATA

@@ -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.dist-info → completor-1.1.3.dist-info}/RECORD

@@ -1,27 +1,27 @@
 completor/__init__.py,sha256=k6amf7jhp7KkBIlaw93-NZITxyZjPSzA5McFAZh8yv8,76
-completor/completion.py,sha256=COtRZpEdmuf3X_uOvEYYLz428nQSn1Z8QH-7TTREyus,30485
+completor/completion.py,sha256=--c2tN1ItE8r7YjxxOrTeZ71tz0KCVStxzWkjU-ERy4,30925
 completor/config_jobs/run_completor,sha256=XePKj2xocfGF0XFRqr7sqfpZGrjgWcfaZLHIhVvGFCQ,600
-completor/constants.py,sha256=Th7fzID5NPUhyV2RRc5h9qRQ963cKGT3TVCX_bsAtHA,12802
-completor/create_output.py,sha256=3IIndoE0aE1ZTKVnjMLi56mJLVbgrYTWkEJs4XkqZDU,23028
+completor/constants.py,sha256=N1u1SrsZap8hSvd4Cs9LCsNZBBIJy_3P2wd9djdTrgg,13028
+completor/create_output.py,sha256=T9W_uNdPzPkW1IyTAXWV38hF8ZvZs5ZrmrxvNHuS-mM,22909
 completor/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 completor/exceptions/clean_exceptions.py,sha256=uQ2jgGfvUDAoS56JBWh-8ZCPIMB4hvYxLF-snA-_-pg,373
 completor/exceptions/exceptions.py,sha256=eS00mVzmC4gQ7MUyGSknvKotmo2XzNGyp007mhjLMy0,5081
 completor/get_version.py,sha256=LMzybu7m-O203lUSZvyu86J4bMobbjE9A23fWLDlxaM,168
 completor/hook_implementations/jobs.py,sha256=8Ao8UadfJzEY7jWzj6C_OXm18fHmfXrbCB2_jS7KHiU,2180
-completor/input_validation.py,sha256=OGY5oCdctlqzeg5Z2l4cmRb3ITtSjLp1Ufp0Joj7aKA,13495
+completor/input_validation.py,sha256=jNqYeAZFxrGJy5-xwK-n1Y0t9EKvJ12aA_z6yzN3N5E,14315
 completor/launch_args_parser.py,sha256=gb3FcyufZlRnKS3BZkFmgVH1VoSxMD0MbCLsHZKmz4c,1413
 completor/logger.py,sha256=gYDbPL8ca5qT_MqYlDKEMKcSfIXW_59QklX8Gss5b2U,4784
 completor/main.py,sha256=ipARMDXXqPYRtBxYQnlj5MohepwkgrQkX3s2IJEaEcI,9151
 completor/parse.py,sha256=EGlt9CgkrXPqa7woyWQ5t_nh6OWsFrc2SJr8aFr_KsQ,20133
-completor/prepare_outputs.py,sha256=fenEo3UfDzXF4jaxi9vDI-g-BkYSti0LxILJf7lO84A,72081
-completor/read_casefile.py,sha256=ZJj-xrpcTeagJmqqi72UIOIcq9uQJaEZClbCA1lW4yw,34081
+completor/prepare_outputs.py,sha256=GAQsRFrz7SwilExCq0w6f1tZE-4TmpHIeMS6_CwdbCM,72547
+completor/read_casefile.py,sha256=ToE7wGh0bKlS8hNFlRN21sPAufPuhRAvadkZGwB2ky4,35452
 completor/read_schedule.py,sha256=IYyCubOggFGg664h1flTl7MUJhJWyibr6JsptnURjUA,18101
-completor/utils.py,sha256=JFzTvt4wLZm-VUoamneQgUBVfdoPJmNAlgdQ80qOL5Y,13576
+completor/utils.py,sha256=ieqgLXfjbjDXHHSW283bliznj04Qep5KRUYGi_BXQRI,13557
 completor/visualization.py,sha256=ObxThqIyW3fsvVIupxVsgySFI_54n_Di-HTzFtDMSgo,4580
-completor/visualize_well.py,sha256=I2kp2rnM2eFV4RUWnTTysPTqQKNEBicF2S9Z3rrAsNA,8672
-completor/wells.py,sha256=oj3e65tSIDFJEpfOKkr_j4H3RyFKpdjZBAcef7sUoaY,12124
-completor-1.1.1.dist-info/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
-completor-1.1.1.dist-info/METADATA,sha256=TIfdCVY0R8QPFW2nNseFcfgflD7GVu-vNKwP8VcRU_c,7880
-completor-1.1.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-completor-1.1.1.dist-info/entry_points.txt,sha256=co5L2_CC2QQWVdEALeMp-NIC4mx4nRpcLcvpVXMYdeI,106
-completor-1.1.1.dist-info/RECORD,,
+completor/visualize_well.py,sha256=fkrjlEtSLsRrmSHoPYtCKIrCeEvXg4LsYyEEPryAB0I,8653
+completor/wells.py,sha256=GgZyfRa5wpSMIJUl5CPi5F1zdmU0XK6QjSduTzuh2NI,12093
+completor-1.1.3.dist-info/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+completor-1.1.3.dist-info/METADATA,sha256=TAE2gJSk-z2H0sRan100EzToaDlrisCAdlo_jVOVFzA,7979
+completor-1.1.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+completor-1.1.3.dist-info/entry_points.txt,sha256=co5L2_CC2QQWVdEALeMp-NIC4mx4nRpcLcvpVXMYdeI,106
+completor-1.1.3.dist-info/RECORD,,