corva-worker-python 2.0.0__py3-none-any.whl

worker/wellbore/model/annulus.py

@@ -0,0 +1,113 @@
+from typing import List
+
+from worker.data.serialization import serialization
+from worker.wellbore.measured_depth_finder import get_unique_measured_depths
+from worker.wellbore.model.ann import Ann
+from worker.wellbore.model.drillstring import Drillstring
+from worker.wellbore.model.enums import PipeType
+from worker.wellbore.model.hole import Hole
+from worker.wellbore.sections_mixin import SectionsMixin
+
+
+@serialization
+class Annulus(SectionsMixin):
+    SERIALIZED_VARIABLES = {"sections": list}
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.sections: List[Ann] = kwargs.get("sections") or []
+
+        drillstring: Drillstring = kwargs.get("drillstring")
+        hole: Hole = kwargs.get("hole")
+        if drillstring and hole:
+            self.create_annulus(drillstring, hole)
+
+    def add_section(self, section: Ann):
+        """
+        Add a new ann section to the end of the sections.
+        :param section:
+        :return:
+        """
+        if self:
+            section.top_depth = self[-1].bottom_depth
+
+        section.set_bottom_depth()
+
+        self.sections.append(section)
+
+    def insert_section(self, section: Ann, index: int):
+        """
+        Insert a new pipe element in the given index.
+        :param section:
+        :param index:
+        :return:
+        """
+        if index is not None:
+            if self:
+                section.top_depth = self[index - 1].bottom_depth
+            section.set_bottom_depth()
+
+            self.sections.insert(index, section)
+
+            for i in range(index + 1, len(self)):
+                self[i].top_depth = self[i - 1].bottom_depth
+                self[i].set_bottom_depth()
+
+    def check_for_concatenation(self):
+        """
+        Concatenate the adjacent section with the same ID and OD and hole type
+        """
+        for i in range(len(self) - 2, -1, -1):
+            if self[i].eq_without_length(self[i + 1]):
+                self[i].set_bottom_depth(self[i + 1].bottom_depth)
+                self[i].set_length()
+                del self[i + 1]
+
+    def create_annulus(self, drillstring: Drillstring, hole: Hole):
+        """
+        Create annulus for a given drillstring and hole configuration
+        :return:
+        """
+        self.sections = []
+
+        md_list = get_unique_measured_depths(drillstring, hole)
+        md_list = [md for md in md_list if md <= drillstring[-1].bottom_depth]
+        epsilon = 0.0001
+        for i in range(len(md_list) - 1):
+            hole_section = hole.find_section_at_measured_depth(md_list[i] + epsilon, True)
+            if not hole_section:
+                continue
+
+            drillstring_section = drillstring.find_section_at_measured_depth(md_list[i] + epsilon, False)
+            annulus_section = Ann(**{"top_depth": md_list[i], "bottom_depth": md_list[i + 1]})
+
+            # If there is no drillstring_section when the bit is at surface (0ft) or once we reach the bit in the loop
+            # stop looping
+            if not drillstring_section or drillstring_section.pipe_type == PipeType.BIT:
+                break
+
+            annulus_section.set_properties_from_pipe_section(drillstring_section)
+            annulus_section.set_properties_from_hole(hole_section)
+
+            self.add_section(annulus_section)
+
+        if not self:
+            return
+
+        # extend the last segment to be equal to the bit depth since the bit has been removed
+        bit_depth = drillstring.bit_depth
+        self[-1].set_bottom_depth(bit_depth)
+        self[-1].set_length()
+
+        self.check_for_concatenation()
+
+    @property
+    def volume(self):
+        return sum(sec.volume for sec in self)
+
+    @property
+    def bottom_depth(self):
+        if not self:
+            return 0
+        return self[-1].bottom_depth

worker/wellbore/model/drillstring.py

@@ -0,0 +1,196 @@
+from copy import deepcopy
+from typing import List, Union
+
+from worker.data.operations import get_data_by_path
+from worker.data.serialization import serialization
+from worker.wellbore.model.drillstring_components import MWD, PDM, RSS, Agitator, Bit, Pipe, UnderReamer
+from worker.wellbore.model.enums import PipeType
+from worker.wellbore.model.hole import Hole
+from worker.wellbore.sections_mixin import SectionsMixin
+
+
+@serialization
+class Drillstring(SectionsMixin):
+    SERIALIZED_VARIABLES = {"sections": list, "mongo_id": str}
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.mongo_id = kwargs.get("mongo_id")
+        self.sections: List[Union[Pipe, Bit]] = kwargs.get("sections") or []
+        if args:
+            self.set_drillstring(args[0])
+
+    def add_section(self, section: Union[Pipe, Bit]):
+        """
+        Add a new pipe element to the end of the drillstring.
+        :param section:
+        :return:
+        """
+        section.top_depth = 0 if not self else self[-1].bottom_depth
+        # length is the source of truth, so we are updating the bottom depth
+        section.set_bottom_depth()
+
+        self.sections.append(section)
+
+    def insert_section(self, section: Union[Pipe, Bit], index: int):
+        """
+        Insert a new pipe element in the given index.
+        :param section:
+        :param index:
+        :return:
+        """
+        if index is not None:
+            if self:
+                section.top_depth = self[index - 1].bottom_depth
+            section.set_bottom_depth()
+
+            self.sections.insert(index, section)
+
+            for i in range(index + 1, len(self)):
+                self[i].top_depth = self[i - 1].bottom_depth
+                self[i].set_bottom_depth()
+
+    def update(self, bit_depth: Union[dict, float]):
+        """
+        This method gets the bit depth and chops the current drill string to fit the criteria in the wellbore.
+        If the drill string length is more than the bit measured depth it chops the extra length from
+        surface. And if it is short in length then it extends the top section to the surface.
+        In addition, the indices of the special tools are updated accordingly, when the drillstring is chopped.
+        :param bit_depth: a wits dict or actual bit depth
+        :return:
+        """
+
+        if isinstance(bit_depth, dict):
+            bit_depth = get_data_by_path(bit_depth, "data.bit_depth", float)
+
+        self[-1].set_bottom_depth(bit_depth)
+        self[-1].set_top_depth()
+
+        for i in range(len(self) - 2, -1, -1):
+            self[i].set_bottom_depth(self[i + 1].top_depth)
+            self[i].set_top_depth()
+
+            if self[i].bottom_depth < 0:
+                del self.sections[i]
+
+        self[0].top_depth = 0
+        self[0].set_length()
+
+    @property
+    def bit_depth(self):
+        if not self:
+            return None
+        return self[-1].bottom_depth
+
+    def set_drillstring(self, drillstring: dict):
+        """
+        This gets the whole drillstring json and sets it
+        :return:
+        """
+        if not drillstring:
+            return
+
+        self.mongo_id = drillstring.get("_id")
+
+        self.sections = []
+
+        # family to class mapping
+        mapping = {"bit": Bit, "agitator": Agitator, "pdm": PDM, "mwd": MWD, "rss": RSS, "ur": UnderReamer}
+
+        drillstring_components = drillstring.get("data", {}).get("components", [])
+        for component in drillstring_components:
+            family = component.get("family", None)
+            if family in mapping:
+                component = mapping[family](**component)
+            else:
+                component = Pipe(**component)
+
+            self.add_section(component)
+
+    def perform_qc(self, hole: Hole):
+        """
+        Removes the items that the pipe OD is equal to or greater than the bit/hole size or OD is equal to 0.
+        If the pipe id is zero then set it equal to 0.5 of the OD
+        :return:
+        """
+        bit_diameter = self.get_bit().size
+
+        self.sections = [sec for sec in self.sections if 0 < sec.outer_diameter < bit_diameter]
+
+        for component in self.sections:
+            if component.inner_diameter == 0:
+                component.inner_diameter = component.outer_diameter / 2
+
+    def compute_get_inside_volume(self):
+        """
+        Compute and get the inside volume of the pipes of the drill string only,
+        not the body and outside of it.
+        :return: volume in FOOT^3
+        """
+        return sum(sec.compute_get_volume() for sec in self)
+
+    def compute_get_outside_volume(self):
+        """
+        Compute and get the outside volume of the pipes of the drill string only,
+        using outer diameter
+        :return: volume in FOOT^3
+        """
+        ds = self.get_a_copy_without_bit()
+        return sum(sec.compute_outer_volume_tj_adjusted() for sec in ds)
+
+    def compute_get_body_volume(self):
+        """
+        Compute and get the body volume of the pipes of the drill string only,
+        not inside and outside of it.
+        :return: volume in FOOT^3
+        """
+        ds = self.get_a_copy_without_bit()
+        return sum(sec.compute_body_volume_tj_adjusted() for sec in ds)
+
+    def get_a_copy_without_bit(self):
+        """
+        To get a deep copy of the current drillstring without the bit
+        :return:
+        """
+        ds = deepcopy(self)
+        bit = ds.get_bit()
+        if bit:
+            ds.sections.remove(bit)
+        return ds
+
+    def get_bit(self):
+        """
+        Get the bit element from the drillstring
+        :return:
+        """
+        if not self:
+            return None
+
+        bit = self[-1]
+        if isinstance(bit, Bit):
+            return bit
+
+        return None
+
+    def get_under_reamer(self):
+        """
+        Get the under-reamer element from the drillstring
+        :return:
+        """
+        if not self:
+            return None
+
+        return next((pipe for pipe in self if pipe.pipe_type == PipeType.UNDERREAMER), None)
+
+    def get_bha_length(self) -> float:
+        """
+        To get the length of the BHA
+        :return:
+        """
+        dp_indices = [index for index, pipe in enumerate(self) if pipe.pipe_type == PipeType.DP]
+        last_dp_index = -1
+        if dp_indices:
+            last_dp_index = max(dp_indices)
+        length = sum(el.length for el in self[last_dp_index + 1 :])
+        return length