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

completor/wells.py

@@ -0,0 +1,273 @@
+"""Classes to keep track of Well objects."""
+
+from __future__ import annotations
+
+import numpy as np
+import numpy.typing as npt
+import pandas as pd
+
+from completor import completion, read_schedule
+from completor.constants import Content, Headers, Method, WellData
+from completor.read_casefile import ReadCasefile
+
+
+class Well:
+    """A well containing one or more laterals.
+
+    Attributes:
+        well_name: The name of the well.
+        well_number: The number of the well.
+        lateral_numbers: Numbers for each lateral.
+        active_laterals: List of laterals.
+        df_well_all_laterals: DataFrame containing all the laterals' well-layer data.
+        df_reservoir_all_laterals: DataFrame containing all the laterals' reservoir-layer data.
+        df_welsegs_header_all_laterals: DataFrame containing all the laterals' well-segments header data.
+        df_welsegs_content_all_laterals: DataFrame containing all the laterals' well-segments content.
+    """
+
+    well_name: str
+    well_number: int
+    df_well_all_laterals: pd.DataFrame
+    df_reservoir_all_laterals: pd.DataFrame
+    lateral_numbers: npt.NDArray[np.int64]
+    active_laterals: list[Lateral]
+    df_welsegs_header_all_laterals: pd.DataFrame
+    df_welsegs_content_all_laterals: pd.DataFrame
+
+    def __init__(self, well_name: str, well_number: int, case: ReadCasefile, well_data: WellData):
+        """Create well.
+
+        Args:
+            well_name: Well name.
+            case: Data from the case file.
+            well_data: Data from the schedule file.
+        """
+        # Note: Important to run this check before creating wells as it fixes potential problems with cases.
+        case.check_input(well_name, well_data)
+        self.well_name = well_name
+        self.well_number = well_number
+
+        lateral_numbers = self._get_active_laterals(well_name, case.completion_table)
+        self.active_laterals = [Lateral(num, well_name, case, well_data) for num in lateral_numbers]
+
+        self.df_well_all_laterals = pd.DataFrame()
+        self.df_reservoir_all_laterals = pd.DataFrame()
+        self.df_well_all_laterals = pd.concat([lateral.df_well for lateral in self.active_laterals], sort=False)
+        self.df_reservoir_all_laterals = pd.concat(
+            [lateral.df_reservoir for lateral in self.active_laterals], sort=False
+        )
+        self.df_welsegs_header_all_laterals = pd.concat(
+            [lateral.df_welsegs_header for lateral in self.active_laterals], sort=False
+        )
+        self.df_welsegs_content_all_laterals = pd.concat(
+            [lateral.df_welsegs_content for lateral in self.active_laterals], sort=False
+        )
+
+    @staticmethod
+    def _get_active_laterals(well_name: str, df_completion: pd.DataFrame) -> npt.NDArray[np.int_]:
+        """Get a list of lateral numbers for the well.
+
+        Args:
+            well_name: The well name.
+            df_completion: The completion information from case data.
+
+        Returns:
+            The active laterals.
+        """
+        return np.array(df_completion[df_completion[Headers.WELL] == well_name][Headers.BRANCH].unique())
+
+
+class Lateral:
+    """Lateral containing data related to a specific well's branch.
+
+    Attributes:
+        lateral_number: Current lateral number.
+        df_completion: Completion data.
+        df_welsegs_header: Header for welsegs.
+        df_welsegs_content: Content for welsegs.
+        df_reservoir_header: Reservoir header data.
+        df_measured_true_vertical_depth: Data for measured and true vertical depths.
+        df_tubing: Data for tubing segments.
+        df_well: Data for well-layer.
+        df_reservoir: Data for reservoir-layer.
+        df_tubing: Tubing data.
+        df_device: Device data.
+    """
+
+    lateral_number: int
+    df_completion: pd.DataFrame
+    df_welsegs_header: pd.DataFrame
+    df_welsegs_content: pd.DataFrame
+    df_reservoir_header: pd.DataFrame
+    df_measured_true_vertical_depth: pd.DataFrame
+    df_well: pd.DataFrame
+    df_reservoir: pd.DataFrame
+    df_tubing: pd.DataFrame
+    df_device: pd.DataFrame
+
+    def __init__(self, lateral_number: int, well_name: str, case: ReadCasefile, well_data: WellData):
+        """Create Lateral.
+
+        Args:
+            lateral_number: Number of the current lateral/branch.
+            well_name: The well's name.
+            case: The case data.
+            well_data: This wells' schedule data.
+        """
+        self.lateral_number = lateral_number
+        self.df_completion = case.get_completion(well_name, lateral_number)
+        self.df_welsegs_header, self.df_welsegs_content = read_schedule.get_well_segments(well_data, lateral_number)
+
+        self.df_device = pd.DataFrame()
+
+        self.df_reservoir = self._select_well(well_name, well_data, lateral_number)
+        if self.df_reservoir.empty:
+            print("")
+        self.df_measured_true_vertical_depth = completion.well_trajectory(
+            self.df_welsegs_header, self.df_welsegs_content
+        )
+        self.df_completion = completion.define_annulus_zone(self.df_completion)
+        self.df_tubing = self._create_tubing_segments(
+            self.df_reservoir, self.df_completion, self.df_measured_true_vertical_depth, case
+        )
+        self.df_tubing = completion.insert_missing_segments(self.df_tubing, well_name)
+        self.df_well = completion.complete_the_well(self.df_tubing, self.df_completion, case.joint_length)
+        self.df_well = self._get_devices(self.df_completion, self.df_well, case)
+        self.df_well = completion.correct_annulus_zone(self.df_well)
+        self.df_reservoir = self._connect_cells_to_segments(
+            self.df_reservoir, self.df_well, self.df_tubing, case.method
+        )
+        self.df_well[Headers.WELL] = well_name
+        self.df_reservoir[Headers.WELL] = well_name
+        self.df_well[Headers.LATERAL] = lateral_number
+        self.df_reservoir[Headers.LATERAL] = lateral_number
+
+    @staticmethod
+    def _select_well(well_name: str, well_data: WellData, lateral: int) -> pd.DataFrame:
+        """Filter the reservoir data for this well and its laterals.
+
+        Args:
+            well_name: The name of the well.
+            well_data: Multisegmented well segment data.
+            lateral: The lateral number.
+
+        Returns:
+            Filtered reservoir data.
+        """
+        df_compsegs = read_schedule.get_completion_segments(well_data, well_name, lateral)
+        df_compdat = read_schedule.get_completion_data(well_data)
+        df_reservoir = pd.merge(df_compsegs, df_compdat, how="inner", on=[Headers.I, Headers.J, Headers.K])
+
+        # Remove WELL column in the df_reservoir.
+        df_reservoir = df_reservoir.drop([Headers.WELL], axis=1)
+        # If multiple occurrences of same IJK in compdat/compsegs --> keep the last one.
+        df_reservoir = df_reservoir.drop_duplicates(subset=Headers.START_MEASURED_DEPTH, keep="last")
+        return df_reservoir.reset_index()
+
+    @staticmethod
+    def _connect_cells_to_segments(
+        df_reservoir: pd.DataFrame, df_well: pd.DataFrame, df_tubing_segments: pd.DataFrame, method: Method
+    ) -> pd.DataFrame:
+        """Connect cells to the well.
+
+        Notes:
+            Only some columns from well DataFrame are needed: MEASURED_DEPTH, NDEVICES, DEVICETYPE, and ANNULUS_ZONE.
+            ICV placement forces different methods in segment creation as USER defined.
+
+        Args:
+            df_reservoir: Reservoir data.
+            df_well: Well data.
+            df_tubing_segments: Tubing information.
+            method: The method to use for creating segments.
+
+        Returns:
+            Reservoir data with additional info on connected cells.
+        """
+        # drop BRANCH column, not needed
+        df_reservoir = df_reservoir.drop([Headers.BRANCH], axis=1)
+        icv_device = (
+            df_well[Headers.DEVICE_TYPE].nunique() > 1
+            and (df_well[Headers.DEVICE_TYPE] == Content.INFLOW_CONTROL_VALVE).any()
+            and not df_well[Headers.NUMBER_OF_DEVICES].empty
+        )
+        method = Method.USER if icv_device else method
+        df_well = df_well[
+            [Headers.TUBING_MEASURED_DEPTH, Headers.NUMBER_OF_DEVICES, Headers.DEVICE_TYPE, Headers.ANNULUS_ZONE]
+        ]
+        return completion.connect_cells_to_segments(df_well, df_reservoir, df_tubing_segments, method)
+
+    @staticmethod
+    def _get_devices(df_completion: pd.DataFrame, df_well: pd.DataFrame, case: ReadCasefile) -> pd.DataFrame:
+        """Complete the well with the device information.
+
+        Args:
+            df_completion: Completion information.
+            df_well: Well data.
+            case: Case data.
+
+        Returns:
+            Well data with device information.
+        """
+        if not case.completion_icv_tubing.empty:
+            active_devices = pd.concat(
+                [df_completion[Headers.DEVICE_TYPE], case.completion_icv_tubing[Headers.DEVICE_TYPE]]
+            ).unique()
+        else:
+            active_devices = df_completion[Headers.DEVICE_TYPE].unique()
+        if Content.VALVE in active_devices:
+            df_well = completion.get_device(df_well, case.wsegvalv_table, Content.VALVE)
+        if Content.INFLOW_CONTROL_DEVICE in active_devices:
+            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.INFLOW_CONTROL_VALVE in active_devices:
+            df_well = completion.get_device(df_well, case.wsegicv_table, Content.INFLOW_CONTROL_VALVE)
+        return df_well
+
+    @staticmethod
+    def _create_tubing_segments(
+        df_reservoir: pd.DataFrame, df_completion: pd.DataFrame, df_mdtvd: pd.DataFrame, case: ReadCasefile
+    ) -> pd.DataFrame:
+        """Create tubing segments based on the method and presence of Inflow Control Valves (ICVs).
+
+        The behavior of the df_tubing_segments will vary depending on the existence of the ICV keyword.
+        When the ICV keyword is present, it always creates a lumped tubing segment on its interval,
+        whereas other types of devices follow the default input.
+        If there is a combination of ICV and other devices (with devicetype > 1),
+        it results in a combination of ICV segment length with segment lumping,
+        and default segment length on other devices.
+
+        Args:
+            df_reservoir: Reservoir data.
+            df_completion: Completion information.
+            df_mdtvd: Measured and true vertical depths.
+            case: Case data, including the Method used to create segments.
+
+        Returns:
+            Tubing data.
+        """
+        df_tubing_segments_cells = completion.create_tubing_segments(
+            df_reservoir, df_completion, df_mdtvd, case.method, case.segment_length, case.minimum_segment_length
+        )
+
+        df_tubing_segments_user = completion.create_tubing_segments(
+            df_reservoir, df_completion, df_mdtvd, Method.USER, case.segment_length, case.minimum_segment_length
+        )
+
+        if (pd.unique(df_completion[Headers.DEVICE_TYPE]).size > 1) & (
+            (df_completion[Headers.DEVICE_TYPE] == Content.INFLOW_CONTROL_VALVE)
+            & (df_completion[Headers.VALVES_PER_JOINT] > 0)
+        ).any():
+            return read_schedule.fix_compsegs_by_priority(
+                df_completion, df_tubing_segments_cells, df_tubing_segments_user
+            )
+
+        # If all the devices are ICVs, lump the segments.
+        if (df_completion[Headers.DEVICE_TYPE] == Content.INFLOW_CONTROL_VALVE).all():
+            return df_tubing_segments_user
+        # If none of the devices are ICVs use defined method.
+        return df_tubing_segments_cells

{completor-0.1.2.dist-info → completor-1.0.0.dist-info}/METADATA

@@ -1,29 +1,28 @@
 Metadata-Version: 2.1
 Name: completor
-Version: 0.1.2
+Version: 1.0.0
 Summary: Advanced mulit-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.8.1,<3.12
+Requires-Python: >=3.11,<3.12
 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.9
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.8
 Provides-Extra: ert
 Requires-Dist: docutils (==0.20.1) ; extra == "ert"
 Requires-Dist: ert (>=10.1.2,<11.0.0) ; extra == "ert"
-Requires-Dist: matplotlib (>=3.7,<4.0)
-Requires-Dist: numpy (>=1.24,<2.0)
-Requires-Dist: pandas (>=2.0,<3.0)
+Requires-Dist: matplotlib (>=3.9.2,<4.0.0)
+Requires-Dist: numpy (>=1.26.4,<2.0.0)
+Requires-Dist: pandas (>=2.2.2,<3.0.0)
 Requires-Dist: pyqt5-qt5 (==5.15.2) ; extra == "ert"
+Requires-Dist: pytest-env (>=1.1.4,<2.0.0)
 Requires-Dist: rstcheck-core (>=1.2.1,<2.0.0) ; extra == "ert"
-Requires-Dist: scipy (>=1.10,<2.0)
+Requires-Dist: scipy (>=1.14.1,<2.0.0)
+Requires-Dist: tqdm (>=4.66.5,<5.0.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
@@ -43,7 +42,7 @@ Detailed documentation for usage of completor can be found at https://equinor.gi
 ## Getting started as a user
 
 ### Prerequisites
-* [Python](https://www.python.org/), version 3.8 to 3.11
+* [Python](https://www.python.org/), version 3.11
 * [ERT](https://github.com/equinor/ert) (optional, and only available on Linux.)
 
 ### Installation
@@ -84,7 +83,7 @@ and making a pull request.
 See [Contribution Document](documentation/docs/contribution_guide.mdx) on how to contribute.
 
 ### Install completor as dev
-In order to run Completor® you need to have versions of [Python 3.8 to 3.11](https://www.python.org/downloads/) installed.
+In order to run Completor® you need to have versions of [Python 3.11](https://www.python.org/downloads/) installed.
 #### Source code
 Clone the [Completor® repository](https://github.com/equinor/completor) to get the source code.
 ```bash

completor-1.0.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+completor/__init__.py,sha256=k6amf7jhp7KkBIlaw93-NZITxyZjPSzA5McFAZh8yv8,76
+completor/completion.py,sha256=aNraZwUQs0jJX080ryPsiaTQUeYbtBP4vLlL0oaqUUs,30829
+completor/config_jobs/run_completor,sha256=XePKj2xocfGF0XFRqr7sqfpZGrjgWcfaZLHIhVvGFCQ,600
+completor/constants.py,sha256=Th7fzID5NPUhyV2RRc5h9qRQ963cKGT3TVCX_bsAtHA,12802
+completor/create_output.py,sha256=ZYFIJCawb51m_7FuCStvs2fv1FTmz02-_QrjOD9cFBo,23174
+completor/exceptions/__init__.py,sha256=Aj_N17UnldYBA-UgxYSYwIh5ib_fZmqqvzf4yFz_DzY,186
+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=7yJg-OD5_JwUPfsvn15suWKhY8XAsCLlR6zBTZckDJY,2120
+completor/input_validation.py,sha256=Jsk96_r61so8q-c-aCPrqivdl0nxBRDGS5NUmpembGs,13478
+completor/launch_args_parser.py,sha256=gb3FcyufZlRnKS3BZkFmgVH1VoSxMD0MbCLsHZKmz4c,1413
+completor/logger.py,sha256=gYDbPL8ca5qT_MqYlDKEMKcSfIXW_59QklX8Gss5b2U,4784
+completor/main.py,sha256=5rDozysrKRD98eq8VD5ZM3oi64tisujCT0A145x0pbI,9020
+completor/parse.py,sha256=EGlt9CgkrXPqa7woyWQ5t_nh6OWsFrc2SJr8aFr_KsQ,20133
+completor/prepare_outputs.py,sha256=8xE7ph2VKllRCQdE5xAbIfBFSfENm7JvFb5VKaqjar0,72064
+completor/read_casefile.py,sha256=0e7zE9QeQnT63oCin9BgtS2vItXUhfp760RIfl1cpYI,34021
+completor/read_schedule.py,sha256=IYyCubOggFGg664h1flTl7MUJhJWyibr6JsptnURjUA,18101
+completor/utils.py,sha256=oiUyYKxFFHpUYOiwsXQCY_e6uQHwsUBzImD3wYbJPDg,14538
+completor/visualization.py,sha256=ObxThqIyW3fsvVIupxVsgySFI_54n_Di-HTzFtDMSgo,4580
+completor/visualize_well.py,sha256=I2kp2rnM2eFV4RUWnTTysPTqQKNEBicF2S9Z3rrAsNA,8672
+completor/wells.py,sha256=G8hjBpV4paUrjlM3aUWREqtdXwGlnm614qvE3V6YtNM,12182
+completor-1.0.0.dist-info/LICENSE,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+completor-1.0.0.dist-info/METADATA,sha256=w9aQgLvvcESvHJe6b6Jzrv-eqQK5_W2dH4Df1IMA5pQ,7922
+completor-1.0.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+completor-1.0.0.dist-info/entry_points.txt,sha256=co5L2_CC2QQWVdEALeMp-NIC4mx4nRpcLcvpVXMYdeI,106
+completor-1.0.0.dist-info/RECORD,,

completor/create_wells.py

@@ -1,314 +0,0 @@
-"""Module for creating completion structure."""
-
-from __future__ import annotations
-
-import numpy as np
-import pandas as pd
-
-from completor import completion
-from completor.constants import Headers, Method
-from completor.logger import logger
-from completor.read_casefile import ReadCasefile
-from completor.read_schedule import fix_compsegs_by_priority
-
-try:
-    import numpy.typing as npt
-except ImportError:
-    pass
-
-
-class CreateWells:
-    """Class for creating well completion structure.
-
-    Args:
-        case: ReadCasefile class.
-
-    Attributes:
-        active_wells: Active wells defined in the case file.
-        method: Method for segment creation.
-        well_name: Well name (in loop).
-        laterals: List of lateral number of the well in loop.
-        df_completion: Completion data frame in loop.
-        df_reservoir: COMPDAT and COMPSEGS data frame fusion in loop.
-        df_welsegs_header: WELSEGS first record.
-        df_welsegs_content: WELSEGS second record.
-        df_mdtvd: Data frame of MD and TVD relationship.
-        df_tubing_segments: Tubing segment data frame.
-        df_well: Data frame after completion.
-        df_well_all: Data frame (df_well) for all laterals after completion.
-        df_reservoir_all: df_reservoir for all laterals.
-    """
-
-    def __init__(self, case: ReadCasefile):
-        """Initialize CreateWells."""
-        self.well_name: str | None = None
-        self.df_reservoir = pd.DataFrame()
-        self.df_mdtvd = pd.DataFrame()
-        self.df_completion = pd.DataFrame()
-        self.df_tubing_segments = pd.DataFrame()
-        self.df_well = pd.DataFrame()
-        self.df_compdat = pd.DataFrame()
-        self.df_well_all = pd.DataFrame()
-        self.df_reservoir_all = pd.DataFrame()
-        self.df_welsegs_header = pd.DataFrame()
-        self.df_welsegs_content = pd.DataFrame()
-        self.laterals: list[int] = []
-
-        self.case: ReadCasefile = case
-        self.active_wells = self._active_wells()
-        self.method = self._method()
-
-    def update(self, well_name: str, schedule: completion.WellSchedule) -> None:
-        """Update class variables in CreateWells.
-
-        Args:
-            well_name: Well name.
-            schedule: ReadSchedule object.
-        """
-        self.well_name = well_name
-        self._active_laterals()
-        for lateral in self.laterals:
-            self.select_well(schedule, lateral)
-            self.well_trajectory()
-            self.define_annulus_zone()
-            self.create_tubing_segments()
-            self.insert_missing_segments()
-            self.complete_the_well()
-            self.get_devices()
-            self.correct_annulus_zone()
-            self.connect_cells_to_segments()
-            self.add_well_lateral_column(lateral)
-            self.combine_df(lateral)
-
-    def _active_wells(self) -> npt.NDArray[np.unicode_]:
-        """Get a list of active wells specified by users.
-
-        If the well has annulus content with gravel pack and the well is perforated,
-        Completor will not add a device layer.
-        Completor does nothing to gravel-packed perforated wells by default.
-        This behavior can be changed by setting the GP_PERF_DEVICELAYER keyword in the case file to true.
-
-        Returns:
-            Active wells.
-        """
-        # Need to check completion of all wells in completion table to remove GP-PERF type wells
-        active_wells = list(set(self.case.completion_table[Headers.WELL]))
-        # We cannot update a list while iterating of it
-        for well_name in active_wells.copy():
-            # Annulus content of each well
-            ann_series = self.case.completion_table[self.case.completion_table[Headers.WELL] == well_name][
-                Headers.ANNULUS
-            ]
-            type_series = self.case.completion_table[self.case.completion_table[Headers.WELL] == well_name][
-                Headers.DEVICE_TYPE
-            ]
-            gp_check = not ann_series.isin(["OA"]).any()
-            perf_check = not type_series.isin(["AICD", "AICV", "DAR", "ICD", "VALVE", "ICV"]).any()
-            if gp_check and perf_check and not self.case.gp_perf_devicelayer:
-                # De-activate wells with GP_PERF if instructed to do so:
-                active_wells.remove(well_name)
-            if not active_wells:
-                logger.warning(
-                    "There are no active wells for Completor to work on. E.g. all wells are defined with Gravel Pack "
-                    "(GP) and valve type PERF. If you want these wells to be active set GP_PERF_DEVICELAYER to TRUE."
-                )
-                return np.array([])
-        return np.array(active_wells)
-
-    def _method(self) -> Method:
-        """Define how the user wants to create segments.
-
-        Returns:
-            Creation method enum.
-
-        Raises:
-            ValueError: If method is not one of the defined methods.
-        """
-        if isinstance(self.case.segment_length, float):
-            if float(self.case.segment_length) > 0.0:
-                return Method.FIX
-            if float(self.case.segment_length) == 0.0:
-                return Method.CELLS
-            if self.case.segment_length < 0.0:
-                return Method.USER
-            else:
-                raise ValueError(
-                    f"Unrecognized method '{self.case.segment_length}' in SEGMENTLENGTH keyword. "
-                    "The value should be one of: 'WELSEGS', 'CELLS', 'USER', or a number: -1 for 'USER', "
-                    "0 for 'CELLS', or a positive number for 'FIX'."
-                )
-
-        elif isinstance(self.case.segment_length, str):
-            if "welsegs" in self.case.segment_length.lower() or "infill" in self.case.segment_length.lower():
-                return Method.WELSEGS
-            if "cell" in self.case.segment_length.lower():
-                return Method.CELLS
-            if "user" in self.case.segment_length.lower():
-                return Method.USER
-            else:
-                raise ValueError(
-                    f"Unrecognized method '{self.case.segment_length}' in SEGMENTLENGTH keyword. "
-                    "The value should be one of: "
-                    "'WELSEGS', 'CELLS', 'USER', or a number: -1 for 'USER', 0 for 'CELLS', positive number for 'FIX'."
-                )
-        else:
-            raise ValueError(
-                f"Unrecognized type of '{self.case.segment_length}' in SEGMENTLENGTH keyword. "
-                "The keyword must either be float or string."
-            )
-
-    def _active_laterals(self) -> None:
-        """Get a list of lateral numbers for the well.
-
-        ``get_active_laterals`` uses the case class DataFrame property
-        ``completion_table`` with a format as shown in the function
-        ``read_casefile.ReadCasefile.read_completion``.
-        """
-        self.laterals = list(
-            self.case.completion_table[self.case.completion_table[Headers.WELL] == self.well_name][
-                Headers.BRANCH
-            ].unique()
-        )
-
-    def select_well(self, schedule: completion.WellSchedule, lateral: int) -> None:
-        """Filter all the required DataFrames for this well and its laterals."""
-        if self.well_name is None:
-            raise ValueError("No well name given")
-
-        self.df_completion = self.case.get_completion(self.well_name, lateral)
-        self.df_welsegs_header, self.df_welsegs_content = schedule.get_well_segments(self.well_name, lateral)
-        df_compsegs = schedule.get_compsegs(self.well_name, lateral)
-        df_compdat = schedule.get_compdat(self.well_name)
-        self.df_reservoir = pd.merge(df_compsegs, df_compdat, how="inner", on=[Headers.I, Headers.J, Headers.K])
-
-        # Remove WELL column in the df_reservoir.
-        self.df_reservoir.drop([Headers.WELL], inplace=True, axis=1)
-        # If multiple occurrences of same IJK in compdat/compsegs --> keep the last one.
-        self.df_reservoir.drop_duplicates(subset=Headers.START_MEASURED_DEPTH, keep="last", inplace=True)
-        self.df_reservoir.reset_index(inplace=True)
-
-    def well_trajectory(self) -> None:
-        """Create trajectory DataFrame relations between measured depth and true vertical depth."""
-        self.df_mdtvd = completion.well_trajectory(self.df_welsegs_header, self.df_welsegs_content)
-
-    def define_annulus_zone(self) -> None:
-        """Define an annulus zone if specified."""
-        self.df_completion = completion.define_annulus_zone(self.df_completion)
-
-    def create_tubing_segments(self) -> None:
-        """Create tubing segments as the basis.
-
-        The function creates a class property DataFrame df_tubing_segments
-        from the class property DataFrames df_reservoir, df_completion, and df_mdtvd.
-
-        The behavior of the df_tubing_segments will vary depending on the existence of the ICV keyword.
-        When the ICV keyword is present, it always creates a lumped tubing segment on its interval,
-        whereas other types of devices follow the default input.
-        If there is a combination of an ICV and other devices (with devicetype >1),
-        this results in a combination of ICV segment length with segment lumping,
-        and default segment length on other devices.
-        """
-        df_tubing_cells = completion.create_tubing_segments(
-            self.df_reservoir,
-            self.df_completion,
-            self.df_mdtvd,
-            self.method,
-            self.case.segment_length,
-            self.case.minimum_segment_length,
-        )
-
-        df_tubing_user = completion.create_tubing_segments(
-            self.df_reservoir,
-            self.df_completion,
-            self.df_mdtvd,
-            Method.USER,
-            self.case.segment_length,
-            self.case.minimum_segment_length,
-        )
-
-        if (len(self.df_completion[Headers.DEVICE_TYPE].unique()) > 1) & (
-            (self.df_completion[Headers.DEVICE_TYPE] == "ICV") & (self.df_completion[Headers.VALVES_PER_JOINT] > 0)
-        ).any():
-            self.df_tubing_segments = fix_compsegs_by_priority(self.df_completion, df_tubing_cells, df_tubing_user)
-
-        # If all the devices are ICVs, lump the segments.
-        elif (self.df_completion[Headers.DEVICE_TYPE] == "ICV").all():
-            self.df_tubing_segments = df_tubing_user
-        # If none of the devices are ICVs use defined method.
-        else:
-            self.df_tubing_segments = df_tubing_cells
-
-    def insert_missing_segments(self) -> None:
-        """Create a placeholder segment for inactive cells."""
-        self.df_tubing_segments = completion.insert_missing_segments(self.df_tubing_segments, self.well_name)
-
-    def complete_the_well(self) -> None:
-        """Complete the well with users' completion design."""
-        self.df_well = completion.complete_the_well(self.df_tubing_segments, self.df_completion, self.case.joint_length)
-        self.df_well[Headers.ROUGHNESS] = self.df_well[Headers.ROUGHNESS].apply(lambda x: f"{x:.3E}")
-
-    def get_devices(self) -> None:
-        """Complete the well with the device information.
-
-        Updates the class property DataFrame df_well described in ``complete_the_well``.
-        """
-        if not self.case.completion_icv_tubing.empty:
-            active_devices = pd.concat(
-                [self.df_completion[Headers.DEVICE_TYPE], self.case.completion_icv_tubing[Headers.DEVICE_TYPE]]
-            ).unique()
-        else:
-            active_devices = self.df_completion[Headers.DEVICE_TYPE].unique()
-        if "VALVE" in active_devices:
-            self.df_well = completion.get_device(self.df_well, self.case.wsegvalv_table, "VALVE")
-        if "ICD" in active_devices:
-            self.df_well = completion.get_device(self.df_well, self.case.wsegsicd_table, "ICD")
-        if "AICD" in active_devices:
-            self.df_well = completion.get_device(self.df_well, self.case.wsegaicd_table, "AICD")
-        if "DAR" in active_devices:
-            self.df_well = completion.get_device(self.df_well, self.case.wsegdar_table, "DAR")
-        if "AICV" in active_devices:
-            self.df_well = completion.get_device(self.df_well, self.case.wsegaicv_table, "AICV")
-        if "ICV" in active_devices:
-            self.df_well = completion.get_device(self.df_well, self.case.wsegicv_table, "ICV")
-
-    def correct_annulus_zone(self) -> None:
-        """Remove the annulus zone if there is no connection to the tubing."""
-        self.df_well = completion.correct_annulus_zone(self.df_well)
-
-    def connect_cells_to_segments(self) -> None:
-        """Connect cells to the well.
-
-        We only need the following columns from the well DataFrame: MD, NDEVICES, DEVICETYPE, and ANNULUS_ZONE.
-
-        ICV placement forces different methods in segment creation as USER defined.
-        """
-        # drop BRANCH column, not needed
-        self.df_reservoir.drop([Headers.BRANCH], axis=1, inplace=True)
-        icv_device = (
-            self.df_well[Headers.DEVICE_TYPE].nunique() > 1
-            and (self.df_well[Headers.DEVICE_TYPE] == "ICV").any()
-            and not self.df_well[Headers.NUMBER_OF_DEVICES].empty
-        )
-        method = Method.USER if icv_device else self.method
-        self.df_reservoir = completion.connect_cells_to_segments(
-            self.df_well[[Headers.TUB_MD, Headers.NUMBER_OF_DEVICES, Headers.DEVICE_TYPE, Headers.ANNULUS_ZONE]],
-            self.df_reservoir,
-            self.df_tubing_segments,
-            method,
-        )
-
-    def add_well_lateral_column(self, lateral: int) -> None:
-        """Add well and lateral column in df_well and df_compsegs."""
-        self.df_well[Headers.WELL] = self.well_name
-        self.df_reservoir[Headers.WELL] = self.well_name
-        self.df_well[Headers.LATERAL] = lateral
-        self.df_reservoir[Headers.LATERAL] = lateral
-
-    def combine_df(self, lateral: int) -> None:
-        """Combine all DataFrames for this well."""
-        if lateral == self.laterals[0]:
-            self.df_well_all = self.df_well.copy(deep=True)
-            self.df_reservoir_all = self.df_reservoir.copy(deep=True)
-        else:
-            self.df_well_all = pd.concat([self.df_well_all, self.df_well], sort=False)
-            self.df_reservoir_all = pd.concat([self.df_reservoir_all, self.df_reservoir], sort=False)