completor 0.1.3__py3-none-any.whl → 1.0.1__py3-none-any.whl

completor/create_output.py

@@ -5,458 +5,586 @@ from __future__ import annotations
 import getpass
 from datetime import datetime
 
-import matplotlib  # type: ignore
+import numpy as np
+import numpy.typing as npt
+import pandas as pd
+from matplotlib.backends.backend_pdf import PdfPages  # type: ignore
 
-from completor import prepare_outputs as po
-from completor.completion import WellSchedule
+from completor import prepare_outputs
 from completor.constants import Headers, Keywords
-from completor.create_wells import CreateWells
+from completor.exceptions.clean_exceptions import CompletorError
+from completor.get_version import get_version
 from completor.logger import logger
-from completor.pvt_model import CORRELATION_UDQ
 from completor.read_casefile import ReadCasefile
 from completor.visualize_well import visualize_well
+from completor.wells import Lateral, Well
 
 
-class CreateOutput:
-    """Create output files from completor.
-
-    There are two output files from completor:
-        1. Well schedule file (text file) for input to reservoir simulator.
-        2. Well diagram (pdf file), i.e. a well completion schematic.
+def format_output(well: Well, case: ReadCasefile, figure_name: str | None = None) -> tuple[str, str, str, str]:
+    """Formats the finished output string to be written to a file.
 
     Args:
-        case: ReadCasefile object.
-        schedule: ReadSchedule object.
-        wells: CreateWells object.
-        well_name: Well name.
-        iwell: Well number used in creating WSEGAICV and WSEGDAR output.
-        version: Completor version information.
-        show_figure: Flag for pdf export of well completion schematic.
-        figure_no: Figure number.
-        write_welsegs: Flag to write WELSEGS.
+        well: Well data.
+        case: Case data.
+        figure_name: The name of the figure, if None, no figure is printed. Defaults to None.
+
+    Returns:
+        Properly formatted output data for completion data, well segments, completion segments, and bonus.
     """
 
-    def __init__(
-        self,
-        case: ReadCasefile,
-        schedule: WellSchedule,
-        wells: CreateWells,
-        well_name: str,
-        iwell: int,
-        completor_version: str,
-        show_figure: bool = False,
-        figure_name: matplotlib.backends.backend_pdf.PdfPages | None = None,  # type: ignore
-        write_welsegs: bool = True,
-        paths: tuple[str, str] | None = None,
-    ):
-        """Initialize CreateOutput class.
-
-        Args:
-            case: ReadCasefile object.
-            schedule: ReadSchedule object.
-            wells: CreateWells object.
-            completor_version: Completor version information.
-            figure_no: Must be set if show_figure.
-            show_figure: True if the user wants to create well diagram file.
-        """
-        self.case = case
-        self.schedule = schedule
-        self.case_path: str | None
-        self.schedule_path: str | None
-        if paths:
-            self.case_path, self.schedule_path = paths
-        else:
-            self.case_path = None
-            self.schedule_path = None
-        self.wells = wells
-        self.well_name = well_name
-        self.iwell = iwell
-        self.version = completor_version
-        self.write_welsegs = write_welsegs
-        self.show_figure = show_figure
-
-        # different line connection
-        self.newline1 = "\n\n\n"
-        self.newline2 = "\n/" + self.newline1
-        self.newline3 = "/" + self.newline1
-
-        # create final print
-        self.header = self.make_completor_header()
-
-        # Prints the UDQ statement if a PVT file and
-        # PVT table are specified in the case file.
-        self.print_udq = False
-        self.udq_correlation = ""
-        self.udq_parameter: dict[str, str] = {}
-        if self.case.completion_table[Headers.DEVICE_TYPE].isin(["AICV"]).any():
-            self.print_udq = True
-            self.udq_correlation = CORRELATION_UDQ
-
-        # Start printing all wells
-        self.finalprint = self.header
-        # print udq equation if relevant
-        if self.print_udq:
-            self.finalprint += self.udq_correlation
-
-        self.df_reservoir = wells.df_reservoir_all[wells.df_reservoir_all[Headers.WELL] == self.well_name]
-        self.df_well = wells.df_well_all[wells.df_well_all[Headers.WELL] == self.well_name]
-        self.laterals = self.df_well[self.df_well[Headers.WELL] == self.well_name][Headers.LATERAL].unique()
-
-        # Start printing per well.
-        self.welsegs_header, _ = self.schedule.get_well_segments(self.well_name, branch=1)
-        self.check_welsegs1()
-        self.print_welsegs = f"{Keywords.WELSEGS}\n{po.dataframe_tostring(self.welsegs_header, True)}\n"
-        self.print_welsegsinit = self.print_welsegs
-        self.print_wseglink = f"{Keywords.WSEGLINK}\n"
-        self.print_wseglinkinit = self.print_wseglink
-        self.print_compsegs = f"{Keywords.COMPSEGS}\n'{self.well_name}' /\n"
-        self.print_compsegsinit = self.print_compsegs
-        self.print_compdat = f"{Keywords.COMPDAT}\n"
-        self.print_compdatinit = self.print_compdat
-        self.print_wsegvalv = f"{Keywords.WSEGVALV}\n"
-        self.print_wsegvalvinit = self.print_wsegvalv
-        self.print_wsegicv = f"{Keywords.WSEGVALV}\n"
-        self.print_wsegicvinit = self.print_wsegicv
-        self.print_wsegaicd = f"{Keywords.WSEGAICD}\n"
-        self.print_wsegaicdinit = self.print_wsegaicd
-        self.print_wsegsicd = f"{Keywords.WSEGSICD}\n"
-        self.print_wsegsicdinit = self.print_wsegsicd
-        self.print_wsegdar = f"""\
-{'-' * 100}
--- This is how we model DAR technology using sets of ACTIONX keywords.
--- The segment dP curves changes according to the segment water-
--- and gas volume fractions at downhole condition.
--- The value of Cv is adjusted according to the segment length and the number of
--- devices per joint. The constriction area varies according to values of
--- volume fractions.
-{"-" * 100}{self.newline1}"""
-
-        self.print_wsegdarinit = self.print_wsegdar
-        self.print_wsegaicv = f"""\
-{"-" * 100}
--- This is how we model AICV technology using sets of ACTIONX keyword
--- the DP parameters change according to the segment water cut (at downhole condition )
--- and gas volume fraction (at downhole condition)
-{"-" * 100}{self.newline1}"""
-
-        self.print_wsegaicvinit = self.print_wsegaicv
-        self.start_segment = 2
-        self.start_branch = 1
-        # pre-preparations
-        data = {}  # just a container. need to to loop twice to make connect_lateral work
-        for lateral in self.laterals:
-            self.df_tubing, top = po.prepare_tubing_layer(
-                self.schedule,
-                self.well_name,
-                lateral,
-                self.df_well,
-                self.start_segment,
-                self.start_branch,
-                self.case.completion_table,
-            )
-            self.df_device = po.prepare_device_layer(self.well_name, lateral, self.df_well, self.df_tubing)
-            self.df_annulus, self.df_wseglink = po.prepare_annulus_layer(
-                self.well_name, lateral, self.df_well, self.df_device
-            )
-            self.update_segmentbranch()
-            self.check_segments(lateral)
-            data[lateral] = (self.df_tubing, self.df_device, self.df_annulus, self.df_wseglink, top)
-        # attach lateral to their proper segments (in overburden, potentially)
-        for lateral in data:
-            po.connect_lateral(self.well_name, lateral, data, self.case)
-        # main preparations
-        for lateral in self.laterals:
-            self.df_tubing, self.df_device, self.df_annulus, self.df_wseglink = data[lateral][:4]
-
-            self.branch_revision(lateral)
-
-            completion_table_well = case.completion_table[case.completion_table[Headers.WELL] == self.well_name]
-            completion_table_lateral = completion_table_well[completion_table_well[Headers.BRANCH] == lateral]
-            self.df_compsegs = po.prepare_compsegs(
-                self.well_name,
-                lateral,
-                self.df_reservoir,
-                self.df_device,
-                self.df_annulus,
-                completion_table_lateral,
-                self.case.segment_length,
+    completion_data_list = []
+    print_well_segments = ""
+    print_well_segments_link = ""
+    print_completion_segments = ""
+    print_valve = ""
+    print_inflow_control_valve = ""
+    print_autonomous_inflow_control_device = ""
+    print_inflow_control_device = ""
+    print_density_activated_recovery = ""
+    print_autonomous_inflow_control_valve = ""
+
+    start_segment = 2
+    start_branch = 1
+
+    header_written = False
+    first = True
+    for lateral in well.active_laterals:
+        _check_well_segments_header(
+            lateral.df_welsegs_header, well.df_reservoir_all_laterals[Headers.START_MEASURED_DEPTH].iloc[0]
+        )
+
+        if not header_written:
+            print_well_segments += (
+                f"{Keywords.WELL_SEGMENTS}\n{prepare_outputs.dataframe_tostring(lateral.df_welsegs_header, True)}"
             )
-            self.df_compdat = po.prepare_compdat(self.well_name, lateral, self.df_reservoir, completion_table_lateral)
-            self.df_wsegvalv = po.prepare_wsegvalv(self.well_name, lateral, self.df_well, self.df_device)
-            self.df_wsegsicd = po.prepare_wsegsicd(self.well_name, lateral, self.df_well, self.df_device)
-            self.df_wsegaicd = po.prepare_wsegaicd(self.well_name, lateral, self.df_well, self.df_device)
-            self.df_wsegdar = po.prepare_wsegdar(self.well_name, lateral, self.df_well, self.df_device)
-            self.df_wsegaicv = po.prepare_wsegaicv(self.well_name, lateral, self.df_well, self.df_device)
-            self.df_wsegicv = po.prepare_wsegicv(
-                self.well_name,
-                lateral,
-                self.df_well,
-                self.df_device,
-                self.df_tubing,
-                self.case.completion_icv_tubing,
-                self.case.wsegicv_table,
+            header_written = True
+
+        lateral.df_tubing, top = prepare_outputs.prepare_tubing_layer(
+            well, lateral, start_segment, start_branch, case.completion_table
+        )
+        lateral.df_device = prepare_outputs.prepare_device_layer(lateral.df_well, lateral.df_tubing)
+
+        if lateral.df_device.empty:
+            logger.warning(
+                "No connection from reservoir to tubing in Well : %s Lateral : %d",
+                well.well_name,
+                lateral.lateral_number,
             )
-            self.make_compdat(lateral)
-            self.make_welsegs(lateral)
-            self.make_wseglink(lateral)
-            self.make_compsegs(lateral)
-            self.make_wsegvalv(lateral)
-            self.make_wsegsicd(lateral)
-            self.make_wsegaicd(lateral)
-            self.make_wsegicv(lateral)
-            self.make_wsegdar()
-            self.make_wsegaicv()
-
-            if show_figure and figure_name is not None:
-                logger.info(f"Creating figure for lateral {lateral}.")
-                figure_name.savefig(
-                    visualize_well(self.well_name, self.df_well, self.df_reservoir, self.case.segment_length),
+        df_annulus, df_well_segments_link = prepare_outputs.prepare_annulus_layer(
+            well.well_name, lateral.df_well, lateral.df_device
+        )
+        if df_annulus.empty:
+            logger.info("No annular flow in Well : %s Lateral : %d", well.well_name, lateral.lateral_number)
+
+        start_segment, start_branch = _update_segmentbranch(lateral.df_device, df_annulus)
+
+        lateral.df_tubing = _connect_lateral(well.well_name, lateral, top, well, case)
+
+        lateral.df_tubing[Headers.BRANCH] = lateral.lateral_number
+        active_laterals = [lateral.lateral_number for lateral in well.active_laterals]
+        lateral.df_device, df_annulus = _branch_revision(
+            lateral.lateral_number, active_laterals, lateral.df_device, df_annulus
+        )
+
+        completion_table_well = case.completion_table[case.completion_table[Headers.WELL] == well.well_name]
+        completion_table_lateral = completion_table_well[
+            completion_table_well[Headers.BRANCH] == lateral.lateral_number
+        ]
+        df_completion_segments = prepare_outputs.prepare_completion_segments(
+            well.well_name,
+            lateral.lateral_number,
+            well.df_reservoir_all_laterals,
+            lateral.df_device,
+            df_annulus,
+            completion_table_lateral,
+            case.segment_length,
+        )
+        df_completion_data = prepare_outputs.prepare_completion_data(
+            well.well_name, lateral.lateral_number, well.df_reservoir_all_laterals, completion_table_lateral
+        )
+        df_valve = prepare_outputs.prepare_valve(well.well_name, lateral.df_well, lateral.df_device)
+        df_inflow_control_device = prepare_outputs.prepare_inflow_control_device(
+            well.well_name, lateral.df_well, lateral.df_device
+        )
+        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(
+            well.well_name, lateral.df_well, lateral.df_device
+        )
+        df_inflow_control_valve = prepare_outputs.prepare_inflow_control_valve(
+            well.well_name,
+            lateral.lateral_number,
+            well.df_well_all_laterals,
+            lateral.df_device,
+            lateral.df_tubing,
+            case.completion_icv_tubing,
+            case.wsegicv_table,
+        )
+        completion_data_list.append(
+            _format_completion_data(well.well_name, lateral.lateral_number, df_completion_data, first)
+        )
+        print_well_segments += _format_well_segments(
+            well.well_name, lateral.lateral_number, lateral.df_tubing, lateral.df_device, df_annulus, first
+        )
+        print_well_segments_link += _format_well_segments_link(
+            well.well_name, lateral.lateral_number, df_well_segments_link, first
+        )
+        print_completion_segments += _format_completion_segments(
+            well.well_name, lateral.lateral_number, df_completion_segments, first
+        )
+        print_valve += _format_valve(well.well_name, lateral.lateral_number, df_valve, first)
+        print_inflow_control_device += _format_inflow_control_device(
+            well.well_name, lateral.lateral_number, df_inflow_control_device, first
+        )
+        print_autonomous_inflow_control_device += _format_autonomous_inflow_control_device(
+            well.well_name, lateral.lateral_number, df_autonomous_inflow_control_device, first
+        )
+        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
+        )
+
+        if figure_name is not None:
+            logger.info(f"Creating figure for lateral {lateral.lateral_number}.")
+            with PdfPages(figure_name) as figure:
+                figure.savefig(
+                    visualize_well(
+                        well.well_name, well.df_well_all_laterals, well.df_reservoir_all_laterals, case.segment_length
+                    ),
                     orientation="landscape",
                 )
-                logger.info("creating schematics: %s.pdf", figure_name)
-            elif show_figure and figure_name is None:
-                raise ValueError("Cannot show figure without filename supplied.")
-        self.fix_printing()
-        self.print_per_well()
-
-    def make_completor_header(self) -> str:
-        """Print header note."""
-        header = f"{'-' * 100}\n"
-        header += f"-- Output from completor {self.version}\n"
-        try:
-            header += f"-- Case file : {self.case_path}\n"
-        except AttributeError:
-            header += "-- Case file : No path found \n"
-            logger.warning("Could not resolve case-file path to output file")
-        header += f"-- Schedule file : {self.schedule_path}\n"
-
-        header += f"""\
--- Created by : {(getpass.getuser()).upper()}
--- Created at : {datetime.now().strftime('%Y %B %d %H:%M')}
-{'-' * 100}{self.newline1}
-"""
-        return header
-
-    def check_welsegs1(self) -> None:
-        """Check whether the measured depth of the first segment is deeper than the first cells start measured depth.
-
-        In this case, adjust segments measured depth to be 1 meter shallower.
-        """
-        start_md = self.df_reservoir[Headers.START_MEASURED_DEPTH].iloc[0]
-        if self.welsegs_header[Headers.SEGMENTMD].iloc[0] > start_md:
-            self.welsegs_header[Headers.SEGMENTMD] = start_md - 1.0
-
-    def check_segments(self, lateral: int) -> None:
-        """Check whether there is annular flow in the well.
-
-        Also check if there are any connections from the reservoir to the tubing in a well.
-        """
-        if self.df_annulus.shape[0] == 0:
-            logger.info("No annular flow in Well : %s Lateral : %d", self.well_name, lateral)
-        if self.df_device.shape[0] == 0:
-            logger.warning("No connection from reservoir to tubing in Well : %s Lateral : %d", self.well_name, lateral)
-
-    def update_segmentbranch(self) -> None:
-        """Update the numbering of the tubing segment and branch."""
-
-        if self.df_annulus.shape[0] == 0 and self.df_device.shape[0] > 0:
-            self.start_segment = max(self.df_device[Headers.SEG].to_numpy()) + 1
-            self.start_branch = max(self.df_device[Headers.BRANCH].to_numpy()) + 1
-        elif self.df_annulus.shape[0] > 0:
-            self.start_segment = max(self.df_annulus[Headers.SEG].to_numpy()) + 1
-            self.start_branch = max(self.df_annulus[Headers.BRANCH].to_numpy()) + 1
-
-    def make_compdat(self, lateral: int) -> None:
-        """Print completion data to file."""
-        nchar = po.get_number_of_characters(self.df_compdat)
-        if self.df_compdat.shape[0] > 0:
-            self.print_compdat += (
-                po.get_header(self.well_name, Keywords.COMPDAT, lateral, "", nchar)
-                + po.dataframe_tostring(self.df_compdat, True)
-                + "\n"
-            )
+            logger.info("Creating schematics: %s.pdf", figure_name)
+        first = False
+    print_completion_data = "\n".join(completion_data_list)
+    if print_well_segments:
+        print_well_segments = f"{print_well_segments}\n/\n\n"
+    if print_completion_segments:
+        print_completion_segments = (
+            f"{Keywords.COMPLETION_SEGMENTS}\n'{well.well_name}' /{print_completion_segments}\n/\n\n\n"
+        )
+    bonus = []
+    if print_well_segments_link:
+        bonus.append(f"{Keywords.WELL_SEGMENTS_LINK}{print_well_segments_link}\n/\n\n\n")
+    if print_valve:
+        bonus.append(f"{Keywords.WELL_SEGMENTS_VALVE}{print_valve}\n/\n\n\n")
+    if print_inflow_control_device:
+        bonus.append(f"{Keywords.INFLOW_CONTROL_DEVICE}{print_inflow_control_device}\n/\n\n\n")
+    if print_autonomous_inflow_control_device:
+        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:
+        metadata = (
+            f"{'-' * 100}\n"
+            "-- This is how we model DAR 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"
+            "-- devices per joint. The constriction area varies according to values of\n"
+            "-- volume fractions.\n"
+            f"{'-' * 100}\n\n\n"
+        )
+        bonus.append(metadata + print_density_activated_recovery + "\n\n\n\n")
+    if print_autonomous_inflow_control_valve:
+        metadata = (
+            f"{'-' * 100}\n"
+            "-- This is how we model AICV 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")
 
-    def make_welsegs(self, lateral: int) -> None:
-        """Print well segments to file."""
-        nchar = po.get_number_of_characters(self.df_tubing)
-        if self.df_device.shape[0] > 0:
-            self.print_welsegs += (
-                po.get_header(self.well_name, Keywords.WELSEGS, lateral, "Tubing", nchar)
-                + po.dataframe_tostring(self.df_tubing, True)
-                + "\n"
-            )
-        if self.df_device.shape[0] > 0:
-            nchar = po.get_number_of_characters(self.df_tubing)
-            self.print_welsegs += (
-                po.get_header(self.well_name, Keywords.WELSEGS, lateral, "Device", nchar)
-                + po.dataframe_tostring(self.df_device, True)
-                + "\n"
-            )
-        if self.df_annulus.shape[0] > 0:
-            nchar = po.get_number_of_characters(self.df_tubing)
-            self.print_welsegs += (
-                po.get_header(self.well_name, Keywords.WELSEGS, lateral, "Annulus", nchar)
-                + po.dataframe_tostring(self.df_annulus, True)
-                + "\n"
-            )
+    return print_completion_data, print_well_segments, print_completion_segments, "".join(bonus)
 
-    def make_wseglink(self, lateral: int) -> None:
-        """Print WSEGLINK to file."""
-        if self.df_wseglink.shape[0] > 0:
-            nchar = po.get_number_of_characters(self.df_wseglink)
-            self.print_wseglink += (
-                po.get_header(self.well_name, Keywords.WSEGLINK, lateral, "", nchar)
-                + po.dataframe_tostring(self.df_wseglink, True)
-                + "\n"
-            )
 
-    def make_compsegs(self, lateral: int) -> None:
-        """Print completion segments to file."""
-        nchar = po.get_number_of_characters(self.df_compsegs)
-        if self.df_compsegs.shape[0] > 0:
-            self.print_compsegs += (
-                po.get_header(self.well_name, Keywords.COMPSEGS, lateral, "", nchar)
-                + po.dataframe_tostring(self.df_compsegs, True)
-                + "\n"
-            )
+def _check_well_segments_header(welsegs_header: pd.DataFrame, start_measured_depths: pd.Series) -> pd.DataFrame:
+    """Check whether the measured depth of the first segment is deeper than the first cells start measured depth.
 
-    def make_wsegaicd(self, lateral: int) -> None:
-        """Print WSEGAICD to file."""
-        if self.df_wsegaicd.shape[0] > 0:
-            nchar = po.get_number_of_characters(self.df_wsegaicd)
-            self.print_wsegaicd += (
-                po.get_header(self.well_name, Keywords.WSEGAICD, lateral, "", nchar)
-                + po.dataframe_tostring(self.df_wsegaicd, True)
-                + "\n"
-            )
+    In this case, adjust segments measured depth to be 1 meter shallower.
 
-    def make_wsegsicd(self, lateral: int) -> None:
-        """Print WSEGSICD to file."""
-        if self.df_wsegsicd.shape[0] > 0:
-            nchar = po.get_number_of_characters(self.df_wsegsicd)
-            self.print_wsegsicd += (
-                po.get_header(self.well_name, Keywords.WSEGSICD, lateral, "", nchar)
-                + po.dataframe_tostring(self.df_wsegsicd, True)
-                + "\n"
-            )
+    Args:
+        welsegs_header: The header for well segments.
+        start_measured_depths: The measured depths of the first cells from the reservoir.
 
-    def make_wsegvalv(self, lateral: int) -> None:
-        """Print WSEGVALV to file."""
-        if self.df_wsegvalv.shape[0] > 0:
-            nchar = po.get_number_of_characters(self.df_wsegvalv)
-            self.print_wsegvalv += (
-                po.get_header(self.well_name, Keywords.WSEGVALV, lateral, "", nchar)
-                + po.dataframe_tostring(self.df_wsegvalv, True)
-                + "\n"
-            )
+    Returns:
+        Corrected measured depths if well segments header.
+    """
+    if welsegs_header[Headers.MEASURED_DEPTH].iloc[0] > start_measured_depths:
+        welsegs_header[Headers.MEASURED_DEPTH] = start_measured_depths - 1.0
+    return welsegs_header
 
-    def make_wsegicv(self, lateral: int) -> None:
-        """Print WSEGICV to file."""
-        if self.df_wsegicv.shape[0] > 0:
-            nchar = po.get_number_of_characters(self.df_wsegicv)
-            self.print_wsegicv += (
-                po.get_header(self.well_name, Keywords.WSEGVALV, lateral, "", nchar)
-                + po.dataframe_tostring(self.df_wsegicv, True)
-                + "\n"
-            )
 
-    def make_wsegdar(self) -> None:
-        """Print WSEGDAR to file."""
-        if self.df_wsegdar.shape[0] > 0:
-            self.print_wsegdar += po.print_wsegdar(self.df_wsegdar, self.iwell + 1) + "\n"
-
-    def make_wsegaicv(self) -> None:
-        """Print WSEGAICV to file."""
-        if self.df_wsegaicv.shape[0] > 0:
-            self.print_wsegaicv += po.print_wsegaicv(self.df_wsegaicv, self.iwell + 1) + "\n"
-
-    def fix_printing(self) -> None:
-        """Avoid printing non-existing keywords."""
-        # if no compdat then dont print it
-        if self.print_compdat == self.print_compdatinit:
-            self.print_compdat = ""
-        else:
-            self.print_compdat += self.newline3
-        # if no welsegs then dont print it
-        if self.print_welsegs == self.print_welsegsinit:
-            self.print_welsegs = ""
-        else:
-            self.print_welsegs += self.newline3
-        # if no compsegs then dont print it
-        if self.print_compsegs == self.print_compsegsinit:
-            self.print_compsegs = ""
-        else:
-            self.print_compsegs += self.newline3
-        # if no weseglink then dont print it
-        if self.print_wseglink == Keywords.WSEGLINK + "\n":
-            self.print_wseglink = ""
-        else:
-            self.print_wseglink += self.newline3
-        # if no VALVE then dont print
-        if self.print_wsegvalv == Keywords.WSEGVALV + "\n":
-            self.print_wsegvalv = ""
-        else:
-            self.print_wsegvalv += self.newline3
-        # if no ICD then dont print
-        if self.print_wsegsicd == Keywords.WSEGSICD + "\n":
-            self.print_wsegsicd = ""
-        else:
-            self.print_wsegsicd += self.newline3
-        # if no AICD then dont print
-        if self.print_wsegaicd == Keywords.WSEGAICD + "\n":
-            self.print_wsegaicd = ""
-        else:
-            self.print_wsegaicd += self.newline3
-        # if no DAR then dont print
-        if self.print_wsegdar == self.print_wsegdarinit:
-            self.print_wsegdar = ""
-        else:
-            self.print_wsegdar += self.newline1
-        # if no DAR then dont print
-        if self.print_wsegaicv == self.print_wsegaicvinit:
-            self.print_wsegaicv = ""
-        else:
-            self.print_wsegaicv += self.newline1
-        # if no ICV then dont print
-        if self.print_wsegicv == Keywords.WSEGVALV + "\n":
-            self.print_wsegicv = ""
-        else:
-            self.print_wsegicv += self.newline3
-
-    def print_per_well(self) -> None:
-        """Collect final printing for all wells."""
-        # here starts active wells
-        finalprint = self.finalprint + self.print_compdat
-        if self.write_welsegs:
-            finalprint += self.print_welsegs
-        finalprint += self.print_wseglink
-        finalprint += self.print_compsegs
-        # print udq parameter if relevant
-        if self.well_name in self.udq_parameter and self.print_udq:
-            finalprint += self.udq_parameter[self.well_name]
-
-        finalprint += (
-            self.print_wsegvalv
-            + self.print_wsegsicd
-            + self.print_wsegaicd
-            + self.print_wsegdar
-            + self.print_wsegaicv
-            + self.print_wsegicv
+def _update_segmentbranch(df_device: pd.DataFrame, df_annulus: pd.DataFrame) -> tuple[int, int]:
+    """Update the numbering of the tubing segment and branch.
+
+    Args:
+        df_device: Device data.
+        df_annulus: Annulus data.
+
+    Returns:
+        The numbers for starting segment and branch.
+
+    Raises:
+        ValueError: If there is neither device nor annulus data.
+    """
+    if df_annulus.empty and df_device.empty:
+        raise ValueError("Cannot determine starting segment and branch without device and annulus data.")
+    if df_annulus.empty and not df_device.empty:
+        start_segment = max(df_device[Headers.START_SEGMENT_NUMBER].to_numpy()) + 1
+        start_branch = max(df_device[Headers.BRANCH].to_numpy()) + 1
+    else:
+        start_segment = max(df_annulus[Headers.START_SEGMENT_NUMBER].to_numpy()) + 1
+        start_branch = max(df_annulus[Headers.BRANCH].to_numpy()) + 1
+    return start_segment, start_branch
+
+
+def _format_completion_data(well_name: str, lateral_number: int, df_compdat: pd.DataFrame, first: bool) -> str:
+    """Print completion data to file.
+
+    Args:
+        well_name: Name of well.
+        lateral_number: Current laterals number.
+        df_compdat: Completion data.
+
+    Returns:
+        Formatted string.
+    """
+    if df_compdat.empty:
+        return ""
+    nchar = prepare_outputs.get_number_of_characters(df_compdat)
+    result = prepare_outputs.get_header(well_name, Keywords.COMPLETION_DATA, lateral_number, "", nchar)
+    result += prepare_outputs.dataframe_tostring(df_compdat, True, keep_header=first)
+    return result
+
+
+def _format_well_segments(
+    well_name: str,
+    lateral_number: int,
+    df_tubing: pd.DataFrame,
+    df_device: pd.DataFrame,
+    df_annulus: pd.DataFrame,
+    header: bool,
+) -> str:
+    """Print well segments to file.
+
+    Args:
+        well_name: Name of well.
+        lateral_number: Current lateral number.
+        df_tubing: Tubing data.
+        df_device: Device data.
+        df_annulus: Annulus data.
+
+    Returns:
+        Formatted string.
+    """
+    print_welsegs = ""
+    nchar = prepare_outputs.get_number_of_characters(df_tubing)
+    if not df_device.empty:
+        # Tubing layer.
+        print_welsegs += (
+            "\n"
+            + prepare_outputs.get_header(well_name, Keywords.WELL_SEGMENTS, lateral_number, "Tubing", nchar)
+            + prepare_outputs.dataframe_tostring(df_tubing, True, keep_header=header)
+        )
+        # Device layer.
+        print_welsegs += (
+            "\n"
+            + prepare_outputs.get_header(well_name, Keywords.WELL_SEGMENTS, lateral_number, "Device", nchar)
+            + prepare_outputs.dataframe_tostring(df_device, True, keep_header=False)
         )
-        self.finalprint = finalprint
-
-    def branch_revision(self, lateral: int) -> None:
-        """Revises the order of branch numbers to be in agreement with common practice.
-
-        This means that tubing layers will get branch numbers from 1 to the number of laterals.
-        Device and lateral branch numbers are changed accordingly if they exist.
-
-        Args:
-            lateral: The lateral number being worked on.
-        """
-        correction = max(self.laterals) - lateral
-        self.df_tubing[Headers.BRANCH] = lateral
-        if self.df_device.shape[0] > 0:
-            self.df_device[Headers.BRANCH] += correction
-        if self.df_annulus.shape[0] > 0:
-            self.df_annulus[Headers.BRANCH] += correction
+    if not df_annulus.empty:
+        # Annulus layer.
+        print_welsegs += (
+            "\n"
+            + prepare_outputs.get_header(well_name, Keywords.WELL_SEGMENTS, lateral_number, "Annulus", nchar)
+            + prepare_outputs.dataframe_tostring(df_annulus, True, keep_header=False)
+        )
+    return print_welsegs
+
+
+def _format_well_segments_link(
+    well_name: str, lateral_number: int, df_well_segments_link: pd.DataFrame, header: bool
+) -> str:
+    """Formats well-segments for links.
+
+    Args:
+        well_name: Name of well.
+        lateral_number: Current lateral number.
+        df_well_segments_link: Well-segmentation data with links.
+
+    Returns:
+        Formatted string.
+    """
+    if df_well_segments_link.empty:
+        return ""
+    nchar = prepare_outputs.get_number_of_characters(df_well_segments_link)
+    return (
+        "\n"
+        + prepare_outputs.get_header(well_name, Keywords.WELL_SEGMENTS_LINK, lateral_number, "", nchar)
+        + prepare_outputs.dataframe_tostring(df_well_segments_link, True, keep_header=header)
+    )
+
+
+def _format_completion_segments(well_name: str, lateral_number: int, df_compsegs: pd.DataFrame, header: bool) -> str:
+    """Formats completion segments.
+
+    Args:
+        well_name: Name of well.
+        lateral_number: Current lateral number.
+        df_compsegs: Completion data.
+
+    Returns:
+        Formatted string.
+    """
+    if df_compsegs.empty:
+        return ""
+    nchar = prepare_outputs.get_number_of_characters(df_compsegs)
+    return (
+        "\n"
+        + prepare_outputs.get_header(well_name, Keywords.COMPLETION_SEGMENTS, lateral_number, "", nchar)
+        + prepare_outputs.dataframe_tostring(df_compsegs, True, keep_header=header)
+    )
+
+
+def _format_autonomous_inflow_control_device(
+    well_name: str, lateral_number: int, df_wsegaicd: pd.DataFrame, header: bool
+) -> str:
+    """Formats well-segments for autonomous inflow control devices.
+
+    Args:
+        well_name: Name of well.
+        lateral_number: Current lateral number.
+        df_wsegaicd: Well-segments data for autonomous inflow control devices.
+
+    Returns:
+        Formatted string.
+    """
+    if df_wsegaicd.empty:
+        return ""
+    nchar = prepare_outputs.get_number_of_characters(df_wsegaicd)
+    return (
+        "\n"
+        + prepare_outputs.get_header(well_name, Keywords.INFLOW_CONTROL_DEVICE, lateral_number, "", nchar)
+        + prepare_outputs.dataframe_tostring(df_wsegaicd, True, keep_header=header)
+    )
+
+
+def _format_inflow_control_device(well_name: str, lateral_number: int, df_wsegsicd: pd.DataFrame, header: bool) -> str:
+    """Formats well-segments for inflow control devices.
+
+    Args:
+        well_name: Name of well.
+        lateral_number: Current lateral number.
+        df_wsegsicd: Well-segment data for inflow control devices.
+
+    Returns:
+        Formatted string.
+    """
+    if df_wsegsicd.empty:
+        return ""
+    nchar = prepare_outputs.get_number_of_characters(df_wsegsicd)
+    return (
+        "\n"
+        + prepare_outputs.get_header(well_name, Keywords.INFLOW_CONTROL_DEVICE, lateral_number, "", nchar)
+        + prepare_outputs.dataframe_tostring(df_wsegsicd, True, keep_header=header)
+    )
+
+
+def _format_valve(well_name: str, lateral_number: int, df_wsegvalv, header: bool) -> str:
+    """Formats well-segments for valves.
+
+    Args:
+        well_name: Name of well.
+        lateral_number: Current lateral number.
+        df_wsegvalv: Well-segment data for valves.
+
+    Returns:
+        Formatted string.
+    """
+    if df_wsegvalv.empty:
+        return ""
+    nchar = prepare_outputs.get_number_of_characters(df_wsegvalv)
+    return (
+        "\n"
+        + prepare_outputs.get_header(well_name, Keywords.WELL_SEGMENTS_VALVE, lateral_number, "", nchar)
+        + prepare_outputs.dataframe_tostring(df_wsegvalv, True, keep_header=header)
+    )
+
+
+def _format_inflow_control_valve(well_name: str, lateral_number: int, df_wsegicv: pd.DataFrame, header: bool) -> str:
+    """Formats well-segments for inflow control valve.
+
+    Args:
+        well_name: Name of well.
+        lateral_number: Current lateral number.
+        df_wsegicv: Well-segment data for inflow control valves.
+
+    Returns:
+        Formatted string.
+    """
+    if df_wsegicv.empty:
+        return ""
+    nchar = prepare_outputs.get_number_of_characters(df_wsegicv)
+    return (
+        "\n"
+        + prepare_outputs.get_header(well_name, Keywords.WELL_SEGMENTS_VALVE, lateral_number, "", nchar)
+        + prepare_outputs.dataframe_tostring(df_wsegicv, True, keep_header=header)
+    )
+
+
+def _format_density_activated_recovery(well_number: int, df_wsegdar: pd.DataFrame) -> str:
+    """Formats well-segments for density activated recovery valve.
+
+    Args:
+        well_number: The well's number
+        df_wsegdar: Data to print.
+
+    Returns:
+        Formatted string.
+    """
+    if df_wsegdar.empty:
+        return ""
+    return prepare_outputs.print_wsegdar(df_wsegdar, well_number + 1)
+
+
+def _format_autonomous_inflow_control_valve(well_number: int, df_wsegaicv: pd.DataFrame) -> str:
+    """Formats the AICV section.
+
+    Args:
+        well_number: The well's number
+        df_wsegaicv: Data to print.
+
+    Returns:
+        Formatted string.
+    """
+    if df_wsegaicv.empty:
+        return ""
+    return prepare_outputs.print_wsegaicv(df_wsegaicv, well_number + 1)
+
+
+def _branch_revision(
+    lateral_number: int,
+    active_laterals: list[int] | npt.NDArray[np.int64],
+    df_device: pd.DataFrame,
+    df_annulus: pd.DataFrame,
+) -> tuple[pd.DataFrame, pd.DataFrame]:
+    """Revises the order of branch numbers to be in agreement with common practice.
+
+    This means that tubing layers will get branch numbers from 1 to the number of laterals.
+    Device and lateral branch numbers are changed accordingly if they exist.
+
+    Args:
+        lateral_number: The lateral number being worked on.
+        active_laterals: List of active lateral numbers.
+        df_device: Dataframe containing device data.
+        df_annulus: Dataframe containing annular data.
+
+    Returns:
+        Corrected device.
+    """
+    correction = max(active_laterals) - lateral_number
+    if df_device.get(Headers.BRANCH) is not None:
+        df_device[Headers.BRANCH] += correction
+    if df_annulus.get(Headers.BRANCH) is not None:
+        df_annulus[Headers.BRANCH] += correction
+    return df_device, df_annulus
+
+
+def _connect_lateral(
+    well_name: str, lateral: Lateral, top: pd.DataFrame, well: Well, case: ReadCasefile
+) -> pd.DataFrame:
+    """Connect lateral to main wellbore/branch.
+
+    The main branch can either have a tubing- or device-layer connected.
+    By default, the lateral will be connected to tubing-layer, but if connect_to_tubing is False,
+    it will be connected to device-layer.
+    Abort if it cannot find device layer at junction depth.
+
+    Args:
+        well_name: Well name.
+        lateral: Current lateral to connect.
+        top: DataFrame of first connection.
+        well: Well object containing data from whole well.
+
+    Returns:
+        Tubing data with modified outsegment.
+
+    Raises:
+        CompletorError: If there is no device layer at junction of lateral.
+    """
+    if top.empty:
+        lateral.df_tubing.at[0, Headers.OUT] = 1  # Default out segment.
+        return lateral.df_tubing
+
+    first_lateral_in_top = top[Headers.TUBING_BRANCH].to_numpy()[0]
+    top_lateral = [lateral for lateral in well.active_laterals if lateral.lateral_number == first_lateral_in_top][0]
+    junction_measured_depth = float(top[Headers.TUBING_MEASURED_DEPTH].to_numpy()[0])
+    if junction_measured_depth > lateral.df_tubing[Headers.MEASURED_DEPTH][0]:
+        logger.warning(
+            "Found a junction above the start of the tubing layer, well %s, branch %s. "
+            "Check the depth of segments pointing at the main stem in schedulefile.",
+            well_name,
+            lateral.lateral_number,
+        )
+    if case.connect_to_tubing(well_name, lateral.lateral_number):
+        layer_to_connect = top_lateral.df_tubing
+        measured_depths = top_lateral.df_tubing[Headers.MEASURED_DEPTH]
+    else:
+        layer_to_connect = top_lateral.df_device
+        measured_depths = top_lateral.df_device[Headers.MEASURED_DEPTH]
+    try:
+        if case.connect_to_tubing(well_name, lateral.lateral_number):
+            # Since the junction_measured_depth has segment tops and layer_to_connect has grid block midpoints,
+            # a junction at the top of the well may not be found. Therefore, we try the following:
+            if (np.array(~(measured_depths <= junction_measured_depth))).all():
+                junction_measured_depth = measured_depths.iloc[0]
+                idx = np.where(measured_depths <= junction_measured_depth)[0][-1]
+
+            else:
+                idx = np.where(measured_depths <= junction_measured_depth)[0][-1]
+        else:
+            # Add 0.1 to junction measured depth since it refers to the tubing layer junction measured depth,
+            # and the device layer measured depth is shifted 0.1 m to the tubing layer.
+            idx = np.where(measured_depths <= junction_measured_depth + 0.1)[0][-1]
+    except IndexError as err:
+        raise CompletorError(
+            f"Cannot find a device layer at junction of lateral {lateral.lateral_number} in {well_name}"
+        ) from err
+    out_segment = layer_to_connect.at[idx, Headers.START_SEGMENT_NUMBER]
+    lateral.df_tubing.at[0, Headers.OUT] = out_segment
+    return lateral.df_tubing
+
+
+def metadata_banner(paths: tuple[str, str] | None) -> str:
+    """Formats the header banner, with metadata.
+
+    Args:
+        paths: The paths to case and schedule files.
+
+    Returns:
+        Formatted header.
+    """
+    header = f"{'-' * 100}\n-- Output from Completor {get_version()}\n"
+
+    if paths is not None:
+        header += f"-- Case file: {paths[0]}\n-- Schedule file: {paths[1]}\n"
+    else:
+        logger.warning("Could not resolve case-file path to output file.")
+        header += "-- Case file: No path found\n-- Schedule file: No path found\n"
+
+    header += (
+        f"-- Created by : {(getpass.getuser()).upper()}\n"
+        f"-- Created at : {datetime.now().strftime('%Y %B %d %H:%M')}\n"
+        f"{'-' * 100}\n\n"
+    )
+    return header