orchid-python-api 5.25.2__py3-none-any.whl → 5.25.4__py3-none-any.whl

orchid/native_subsurface_point.py

@@ -1,70 +0,0 @@
-#
-# This file is part of Orchid and related technologies.
-#
-# Copyright (c) 2017-2025 KAPPA.  All Rights Reserved.
-#
-# LEGAL NOTICE:
-# Orchid contains trade secrets and otherwise confidential information
-# owned by KAPPA. Access to and use of this information is
-# strictly limited and controlled by the Company. This file may not be copied,
-# distributed, or otherwise disclosed outside of the Company's facilities 
-# except under appropriate precautions to maintain the confidentiality hereof, 
-# and may not be used in any way not expressly authorized by the Company.
-#
-
-
-import abc
-from typing import Union
-
-import toolz.curried as toolz
-import option
-
-from orchid import (
-    dot_net_dom_access as dna,
-    net_quantity as onq,
-    unit_system as units,
-)
-
-# noinspection PyUnresolvedReferences,PyPackageRequirements
-from Orchid.FractureDiagnostics import ISubsurfacePoint
-
-
-class SubsurfacePoint(dna.IdentifiedDotNetAdapter):
-    """An abstract base class for subsurface points."""
-
-    def __init__(self, adaptee: ISubsurfacePoint, target_length_unit: Union[units.UsOilfield, units.Metric]):
-        """
-        Construct an instance adapting `adaptee` so that all lengths are expressed in `target_length_unit`.
-
-        Args:
-            adaptee: The .NET `ISubsurfacePoint` being adapted.
-            target_length_unit: The target unit for all lengths.
-        """
-        super().__init__(adaptee)
-        self._as_length_measurement_func = onq.as_measurement(target_length_unit)
-
-    depth_origin = dna.dom_property('depth_datum',
-                                    'The datum or origin for the z-coordinate of this point.')
-    xy_origin = dna.dom_property('well_reference_frame_xy',
-                                 'The reference frame or origin for the x-y coordinates of this point.')
-
-    @property
-    def x(self):
-        """The x-coordinate of this point."""
-        return self._as_length_measurement_func(option.maybe(self.dom_object.X))
-
-    @property
-    def y(self):
-        """The y-coordinate of this point."""
-        return self._as_length_measurement_func(option.maybe(self.dom_object.Y))
-
-    @property
-    def depth(self):
-        """The depth of this point."""
-        return self._as_length_measurement_func(option.maybe(self.dom_object.Depth))
-
-
-@toolz.curry
-def make_subsurface_point(target_unit: Union[units.UsOilfield, units.Metric],
-                          net_subsurface_point: ISubsurfacePoint) -> SubsurfacePoint:
-    return SubsurfacePoint(net_subsurface_point, target_unit)

orchid/native_time_series_adapter.py

@@ -1,54 +0,0 @@
-#  Copyright (c) 2017-2025 KAPPA
-#
-#  Licensed under the Apache License, Version 2.0 (the "License"); 
-#  you may not use this file except in compliance with the License. 
-#  You may obtain a copy of the License at 
-#
-#      http://www.apache.org/licenses/LICENSE-2.0 
-#
-#  Unless required by applicable law or agreed to in writing, software 
-#  distributed under the License is distributed on an "AS IS" BASIS, 
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#  See the License for the specific language governing permissions and 
-#  limitations under the License. 
-#
-# This file is part of Orchid and related technologies.
-#
-
-import enum
-
-import orchid.base
-from orchid import (
-    base_time_series_adapter as bca,
-)
-
-# noinspection PyUnresolvedReferences
-from Orchid.FractureDiagnostics.TimeSeries import IQuantityTimeSeries
-
-
-# TODO: Replace with dataclass and constant class variables.
-class TimeSeriesCurveTypes(enum.Enum):
-    MONITOR_PRESSURE = 'Pressure'
-    MONITOR_TEMPERATURE = 'Temperature'
-
-
-class NativeTimeSeriesAdapter(bca.BaseTimeSeriesAdapter):
-    def __init__(self, net_time_series: IQuantityTimeSeries):
-        super().__init__(net_time_series, orchid.base.constantly(net_time_series.Well.Project))
-
-    def quantity_name_unit_map(self, project_units):
-        """
-        Return a map (dictionary) between quantity names and units (from `unit_system`) of the data_points.
-
-        This method plays the role of "Primitive Operation" in the *Template Method* design pattern. In this
-        role, the "Template Method" defines an algorithm and delegates some steps of the algorithm to derived
-        classes through invocation of "Primitive Operations".
-
-        Args:
-            project_units: The unit system of the project.
-        """
-        result = {
-            TimeSeriesCurveTypes.MONITOR_PRESSURE.value: project_units.PRESSURE,
-            TimeSeriesCurveTypes.MONITOR_TEMPERATURE.value: project_units.TEMPERATURE,
-        }
-        return result

orchid/native_trajectory_adapter.py

@@ -1,246 +0,0 @@
-#  Copyright (c) 2017-2025 KAPPA
-#
-#  Licensed under the Apache License, Version 2.0 (the "License"); 
-#  you may not use this file except in compliance with the License. 
-#  You may obtain a copy of the License at 
-#
-#      http://www.apache.org/licenses/LICENSE-2.0 
-#
-#  Unless required by applicable law or agreed to in writing, software 
-#  distributed under the License is distributed on an "AS IS" BASIS, 
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#  See the License for the specific language governing permissions and 
-#  limitations under the License. 
-#
-# This file is part of Orchid and related technologies.
-#
-
-import deal
-
-import numpy as np
-import option
-import toolz.curried as toolz
-
-import orchid.base
-from orchid import (
-    dot_net_dom_access as dna,
-    net_quantity as onq,
-    reference_origins as origins,
-    unit_system as units,
-    validation,
-)
-
-# noinspection PyUnresolvedReferences
-from Orchid.FractureDiagnostics import IWellTrajectory
-
-# noinspection PyUnresolvedReferences
-import UnitsNet
-
-
-def _trajectory_array_in_unit(tgt_unit, raw_array):
-    result = toolz.pipe(raw_array,
-                        toolz.map(option.maybe),
-                        toolz.map(onq.as_measurement(tgt_unit)),
-                        toolz.map(lambda m: m.magnitude),
-                        lambda magnitudes: np.fromiter(magnitudes, dtype='float'))
-    return result
-
-
-class NativeTrajectoryAdapterIdentified(dna.IdentifiedDotNetAdapter):
-    def __init__(self, net_trajectory: IWellTrajectory):
-        """
-        Construct an instance adapting a .NET `IWellTrajectory`.
-
-        One need not construct an instance directly; instead, one constructs an instance by accessing the
-        Orchid domain object model (DOM) of a project. For example,
-
-        >>> project_path = orchid.training_data_path().joinpath('frankNstein_Bakken_UTM13_FEET.ifrac')
-        >>> project = orchid.load_project(str(project_path))
-        >>> well = list(project.wells().find_by_name('Demo_1H'))[0]
-        >>> # noinspection PyUnresolvedReferences
-        >>> trajectory = well.trajectory
-
-        Args:
-            net_trajectory: The .NET trajectory to be adapted.
-        """
-        super().__init__(net_trajectory, orchid.base.constantly(net_trajectory.Well.Project))
-
-    # TODO: Consider alternative interface, get_eastings()
-    # See [pint Numpy support](https://pint.readthedocs.io/en/stable/numpy.html) or the
-    # [pint pandas extension](https://github.com/hgrecco/pint-pandas)
-    @deal.pre(validation.arg_not_none)
-    def get_easting_array(self, reference_frame: origins.WellReferenceFrameXy) -> np.array:
-        """
-        Calculate the magnitudes of eastings of this trajectory relative to the specified `reference_frame`
-        in project length units.
-
-        Once one has a trajectory (from a well of a project), one can access the (Numpy) array of easting
-        values relative to a reference. For example,
-
-        >>> project_path = orchid.training_data_path().joinpath('frankNstein_Bakken_UTM13_FEET.ifrac')
-        >>> project = orchid.load_project(str(project_path))
-        >>> well = list(project.wells().find_by_name('Demo_3H'))[0]
-        >>> # noinspection PyUnresolvedReferences
-        >>> trajectory = well.trajectory
-        >>> eastings = trajectory.get_easting_array(origins.WellReferenceFrameXy.PROJECT)
-        >>> eastings[213]
-        -21007.733000000007
-
-        Args
-            reference_frame: The reference frame for the easting coordinates.
-
-        Returns:
-            The array of eastings of this trajectory.
-        """
-        return self._trajectory_length_array(self.dom_object.GetEastingArray(reference_frame.value))
-
-    # TODO: Consider alternative interface, get_northings()
-    # See [pint Numpy support](https://pint.readthedocs.io/en/stable/numpy.html) or the
-    # [pint pandas extension](https://github.com/hgrecco/pint-pandas)
-    @deal.pre(validation.arg_not_none)
-    def get_northing_array(self, reference_frame: origins.WellReferenceFrameXy) -> np.array:
-        """
-        Calculate the magnitudes of northings of this trajectory relative to the specified `reference_frame`
-        in project length units.
-
-        Once one has a trajectory (from a well of a project), one can access the (Numpy) array of northing
-        values relative to a reference. For example,
-
-        >>> project_path = orchid.training_data_path().joinpath('frankNstein_Bakken_UTM13_FEET.ifrac')
-        >>> project = orchid.load_project(str(project_path))
-        >>> well = list(project.wells().find_by_name('Demo_2H'))[0]
-        >>> # noinspection PyUnresolvedReferences
-        >>> trajectory = well.trajectory
-        >>> northings = trajectory.get_northing_array(origins.WellReferenceFrameXy.PROJECT)
-        >>> northings[203]
-        36105.4299999997
-
-        Args:
-            reference_frame: The reference frame for the northing coordinates.
-
-        Returns:
-            The array of northings of this trajectory.
-
-        """
-        return self._trajectory_length_array(self.dom_object.GetNorthingArray(reference_frame.value))
-
-    # TODO: Consider alternative interface, get_tvd_sss()
-    # See [pint Numpy support](https://pint.readthedocs.io/en/stable/numpy.html) or the
-    # [pint pandas extension](https://github.com/hgrecco/pint-pandas)
-    def get_tvd_ss_array(self) -> np.array:
-        """
-        Calculate the array of total vertical sub-sea depth values in project length units.
-
-        Once one has a trajectory (from a well of a project), one can access the (Numpy) array of TVDSS
-        values. For example,
-
-        >>> project_path = orchid.training_data_path().joinpath('frankNstein_Bakken_UTM13_FEET.ifrac')
-        >>> project = orchid.load_project(str(project_path))
-        >>> well = list(project.wells().find_by_name('Demo_4H'))[0]
-        >>> # noinspection PyUnresolvedReferences
-        >>> trajectory = well.trajectory
-        >>> tvd_sss = trajectory.get_tvd_ss_array()
-        >>> tvd_sss[144]
-        10763.48512
-
-        Returns:
-            The array of total vertical depths of this trajectory.
-        """
-        return self._get_tvd_array(origins.DepthDatum.SEA_LEVEL)
-
-    # TODO: Consider alternative interface, get_inclinations()
-    # See [pint Numpy support](https://pint.readthedocs.io/en/stable/numpy.html) or the
-    # [pint pandas extension](https://github.com/hgrecco/pint-pandas)
-    def get_inclination_array(self) -> np.array:
-        """
-        Calculate the array of inclination values.
-
-        Once one has a trajectory (from a well of a project), one can access the (Numpy) array of inclination
-        values. For example,
-
-        >>> project_path = orchid.training_data_path().joinpath('Project-frankNstein_Montney_UTM13_METERS.ifrac')
-        >>> project = orchid.load_project(str(project_path))
-        >>> well = list(project.wells().find_by_name('Hori_03'))[0]
-        >>> # noinspection PyUnresolvedReferences
-        >>> trajectory = well.trajectory
-        >>> inclinations = trajectory.get_inclination_array()
-        >>> inclinations[10]
-        4.2
-
-        Returns:
-            The array of inclinations of this trajectory.
-        """
-        return self._trajectory_angle_array(self.dom_object.GetInclinationArray())
-
-    # TODO: Consider alternative interface, get_azimuths_east_of_north()
-    # See [pint Numpy support](https://pint.readthedocs.io/en/stable/numpy.html) or the
-    # [pint pandas extension](https://github.com/hgrecco/pint-pandas)
-    def get_azimuth_east_of_north_array(self) -> np.array:
-        """
-        Calculate the array of azimuth values.
-
-        Once one has a trajectory (from a well of a project), one can access the (Numpy) array of azimuth east
-        of north values. For example,
-
-        >>> project_path = orchid.training_data_path().joinpath('Project-frankNstein_Montney_UTM13_METERS.ifrac')
-        >>> project = orchid.load_project(str(project_path))
-        >>> well = list(project.wells().find_by_name('Hori_03'))[0]
-        >>> # noinspection PyUnresolvedReferences
-        >>> trajectory = well.trajectory
-        >>> azimuths_east_of_north = trajectory.get_azimuth_east_of_north_array()
-        >>> azimuths_east_of_north[173]
-        128.6
-
-        Returns:
-            The array of azimuths of this trajectory.
-        """
-        return self._trajectory_angle_array(self.dom_object.GetAzimuthEastOfNorthArray())
-
-    # TODO: Consider alternative interface, get_md_kbs()
-    # See [pint Numpy support](https://pint.readthedocs.io/en/stable/numpy.html) or the
-    # [pint pandas extension](https://github.com/hgrecco/pint-pandas)
-    def get_md_kb_array(self) -> np.array:
-        """
-        Calculate the array of MD KB values.
-
-        Once one has a trajectory (from a well of a project), one can access the (Numpy) array of MDKB
-        values. For example,
-
-        >>> project_path = orchid.training_data_path().joinpath('Project-frankNstein_Montney_UTM13_METERS.ifrac')
-        >>> project = orchid.load_project(str(project_path))
-        >>> well = list(project.wells().find_by_name('Hori_01'))[0]
-        >>> # noinspection PyUnresolvedReferences
-        >>> trajectory = well.trajectory
-        >>> md_kbs = trajectory.get_md_kb_array()
-        >>> md_kbs[84]
-        2246.04
-
-        Returns:
-            The array of MD KB values of this trajectory.
-        """
-        return self._trajectory_length_array(self.dom_object.GetMdKbArray())
-
-    @deal.pre(validation.arg_not_none)
-    def _get_tvd_array(self, depth_datum: origins.DepthDatum) -> np.array:
-        """
-        Calculate the array of total vertical depth values relative to `depth_datum` in project length units.
-
-        Args:
-            depth_datum: The depth datum for the vertical depth values.
-
-        Returns:
-            The array of total vertical depths of this trajectory.
-        """
-        return self._trajectory_length_array(self.dom_object.GetTvdArray(depth_datum.value))
-
-    @staticmethod
-    def _trajectory_angle_array(raw_array):
-        return _trajectory_array_in_unit(units.Common.ANGLE, raw_array)
-
-    def _trajectory_length_array(self, raw_array):
-        return _trajectory_array_in_unit(self.expect_project_units.LENGTH, raw_array)
-
-
-if __name__ == '__main__':
-    import doctest
-    doctest.testmod()

orchid/native_treatment_calculations.py

@@ -1,158 +0,0 @@
-#
-# This file is part of Orchid and related technologies.
-#
-# Copyright (c) 2017-2025 KAPPA.  All Rights Reserved.
-#
-# LEGAL NOTICE:
-# Orchid contains trade secrets and otherwise confidential information
-# owned by KAPPA. Access to and use of this information is
-# strictly limited and controlled by the Company. This file may not be copied,
-# distributed, or otherwise disclosed outside of the Company's facilities 
-# except under appropriate precautions to maintain the confidentiality hereof, 
-# and may not be used in any way not expressly authorized by the Company.
-#
-
-
-from collections import namedtuple
-import datetime as dt
-from typing import Callable, Union
-
-import deal
-import option
-import pendulum
-
-from orchid import (
-    project_store as loader,
-    native_stage_adapter as nsa,
-    net_date_time as net_dt,
-    net_quantity as net_qty,
-    unit_system as units,
-)
-
-#
-# noinspection PyUnresolvedReferences,PyPackageRequirements
-from Orchid.FractureDiagnostics import IStage
-# noinspection PyUnresolvedReferences,PyPackageRequirements
-from Orchid.FractureDiagnostics.Calculations import (ICalculationResult,
-                                                     ITreatmentCalculations)
-# noinspection PyUnresolvedReferences,PyPackageRequirements
-from System import DateTime
-
-
-CalculationResult = namedtuple('CalculationResult', ['measurement', 'warnings'])
-
-
-def perform_calculation(native_calculation_func: Callable[[ITreatmentCalculations, IStage, DateTime, DateTime],
-                                                          ICalculationResult],
-                        stage: IStage,
-                        start: DateTime,
-                        stop: DateTime,
-                        target_unit: Union[units.UsOilfield, units.Metric]):
-    """
-    Perform the specific native calculation function for stage from start through (and including) stop.
-
-    Args:
-        native_calculation_func: The specific native treatment calculation function.
-        stage: The stage on which the calculation is being made.
-        start: The (inclusive) start time of the calculation.
-        stop: The (inclusive) stop time of the calculation.
-        target_unit: The target unit of the measurement to be returned as the result.
-
-    Returns:
-        The calculation result (measurement and warnings) for the calculation.
-    """
-    native_treatment_calculations = loader.native_treatment_calculations()
-    native_calculation_result = native_calculation_func(native_treatment_calculations, stage, start, stop)
-    calculation_measurement = net_qty.as_measurement(target_unit,
-                                                     option.maybe(native_calculation_result.Result))
-    warnings = native_calculation_result.Warnings
-    return CalculationResult(calculation_measurement, warnings)
-
-
-@deal.pre(lambda _stage, start, _stop: net_dt.is_utc(start), message='Expected UTC for start time zone.')
-@deal.pre(lambda _stage, _start, stop: net_dt.is_utc(stop), message='Expected UTC for stop time zone.')
-def median_treating_pressure(stage: nsa.NativeStageAdapter,
-                             start: Union[pendulum.DateTime, dt.datetime],
-                             stop: Union[pendulum.DateTime, dt.datetime]):
-    """
-    Return the median treating pressure for stage from start to (and including) stop.
-
-    Args:
-        stage: The stage on which the calculation is being made.
-        start: The (inclusive) start time of the calculation.
-        stop: The (inclusive) stop time of the calculation.
-
-    Returns:
-        The median treating pressure result (measurement and warnings).
-    """
-    def median_treatment_pressure_calculation(calculations, for_stage, start_time, stop_time):
-        calculation_result = calculations.GetMedianTreatmentPressure(for_stage.dom_object,
-                                                                     net_dt.as_net_date_time(start_time),
-                                                                     net_dt.as_net_date_time(stop_time))
-        return calculation_result
-
-    result = perform_calculation(median_treatment_pressure_calculation, stage,
-                                 _datetime_to_pendulum(start), _datetime_to_pendulum(stop),
-                                 stage.expect_project_units.PRESSURE)
-    return result
-
-
-@deal.pre(lambda _stage, start, _stop: net_dt.is_utc(start), message='Expected UTC for start time zone.')
-@deal.pre(lambda _stage, _start, stop: net_dt.is_utc(stop), message='Expected UTC for stop time zone.')
-def pumped_fluid_volume(stage: IStage,
-                        start: Union[pendulum.DateTime, dt.datetime],
-                        stop: Union[pendulum.DateTime, dt.datetime]):
-    """
-    Return the pumped (fluid) volume for stage from start to (and including) stop.
-
-    Args:
-        stage: The stage on which the calculation is being made.
-        start: The (inclusive) start time of the calculation.
-        stop: The (inclusive) stop time of the calculation.
-
-    Returns:
-        The pumped (fluid) volume result (measurement and warnings).
-    """
-
-    def pumped_fluid_volume_calculation(calculations, for_stage, start_time, stop_time):
-        calculation_result = calculations.GetPumpedVolume(for_stage.dom_object,
-                                                          net_dt.as_net_date_time(start_time),
-                                                          net_dt.as_net_date_time(stop_time))
-        return calculation_result
-
-    result = perform_calculation(pumped_fluid_volume_calculation, stage,
-                                 _datetime_to_pendulum(start), _datetime_to_pendulum(stop),
-                                 stage.expect_project_units.VOLUME)
-    return result
-
-
-@deal.pre(lambda _stage, start, _stop: net_dt.is_utc(start), message='Expected UTC for start time zone.')
-@deal.pre(lambda _stage, _start, stop: net_dt.is_utc(stop), message='Expected UTC for stop time zone.')
-def total_proppant_mass(stage: IStage,
-                        start: Union[pendulum.DateTime, dt.datetime],
-                        stop: Union[pendulum.DateTime, dt.datetime]):
-    """
-    Return the pumped (fluid) volume for stage from start to (and including) stop.
-
-    Args:
-        stage: The stage on which the calculation is being made.
-        start: The (inclusive) start time of the calculation.
-        stop: The (inclusive) stop time of the calculation.
-
-    Returns:
-        The pumped (fluid) volume result (measurement and warnings).
-    """
-    def total_proppant_mass_calculation(calculations, for_stage, start_time, stop_time):
-        calculation_result = calculations.GetTotalProppantMass(for_stage.dom_object,
-                                                               net_dt.as_net_date_time(start_time),
-                                                               net_dt.as_net_date_time(stop_time))
-        return calculation_result
-
-    result = perform_calculation(total_proppant_mass_calculation, stage,
-                                 _datetime_to_pendulum(start), _datetime_to_pendulum(stop),
-                                 stage.expect_project_units.MASS)
-    return result
-
-
-def _datetime_to_pendulum(source: dt.datetime) -> pendulum.DateTime:
-    return pendulum.instance(source).set(tz=pendulum.UTC)

orchid/native_treatment_curve_adapter.py

@@ -1,60 +0,0 @@
-#  Copyright (c) 2017-2025 KAPPA
-#
-#  Licensed under the Apache License, Version 2.0 (the "License"); 
-#  you may not use this file except in compliance with the License. 
-#  You may obtain a copy of the License at 
-#
-#      http://www.apache.org/licenses/LICENSE-2.0 
-#
-#  Unless required by applicable law or agreed to in writing, software 
-#  distributed under the License is distributed on an "AS IS" BASIS, 
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#  See the License for the specific language governing permissions and 
-#  limitations under the License. 
-#
-# This file is part of Orchid and related technologies.
-#
-
-import enum
-
-import orchid.base
-from orchid import (
-    base_time_series_adapter as bca,
-    dot_net_dom_access as dna,
-)
-
-# noinspection PyUnresolvedReferences
-from Orchid.FractureDiagnostics.TimeSeries import IQuantityTimeSeries
-
-
-class TreatmentCurveTypes(enum.Enum):
-    DOWNHOLE_PROPPANT_CONCENTRATION = 'Downhole Proppant Concentration'
-    SURFACE_PROPPANT_CONCENTRATION = 'Surface Proppant Concentration'
-    SLURRY_RATE = 'Slurry Rate'
-    TREATING_PRESSURE = 'Pressure'
-
-
-class NativeTreatmentCurveAdapter(bca.BaseTimeSeriesAdapter):
-    suffix = dna.dom_property('suffix', 'Return the suffix for this treatment curve.')
-
-    def __init__(self, net_treatment_curve: IQuantityTimeSeries):
-        super().__init__(net_treatment_curve, orchid.base.constantly(net_treatment_curve.Stage.Well.Project))
-
-    def quantity_name_unit_map(self, project_units):
-        """
-        Return a map (dictionary) between quantity names and units (from `unit_system`) of the data_points.
-
-        This method plays the role of "Primitive Operation" in the *Template Method* design pattern. In this
-        role, the "Template Method" defines an algorithm and delegates some steps of the algorithm to derived
-        classes through invocation of "Primitive Operations".
-
-        Args:
-            project_units: The unit system of the project.
-        """
-        result = {
-            TreatmentCurveTypes.TREATING_PRESSURE.value: project_units.PRESSURE,
-            TreatmentCurveTypes.DOWNHOLE_PROPPANT_CONCENTRATION.value: project_units.PROPPANT_CONCENTRATION,
-            TreatmentCurveTypes.SURFACE_PROPPANT_CONCENTRATION.value: project_units.PROPPANT_CONCENTRATION,
-            TreatmentCurveTypes.SLURRY_RATE.value: project_units.SLURRY_RATE,
-        }
-        return result