zonevu 1.0.0__py3-none-any.whl

zonevu/DataModels/Company.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json, LetterCase
+
+
+@dataclass_json(letter_case=LetterCase.PASCAL)
+@dataclass
+class Company:
+    Version: str = ''  # API Version
+    RuntimeVersion: str = '?'  # ZoneVu server runtime version
+    CompanyName: str = ''
+    Notice: str = ''
+
+    def printNotice(self):
+        print("Zonevu Web API Version %s. Zonevu Server Version %s." % (self.Version, self.RuntimeVersion))
+        print(self.Notice)
+        print("ZoneVu account '%s'" % self.CompanyName)
+        print()
+

zonevu/DataModels/Curve.py

@@ -0,0 +1,59 @@
+import json
+from typing import Optional
+from dataclasses import dataclass, field
+from dataclasses_json import dataclass_json, LetterCase
+from .DataModel import DataModel
+import numpy as np
+from strenum import StrEnum
+
+
+class AppMnemonicCodeEnum(StrEnum):
+    NotSet = "NotSet"
+    DEPT = "DEPT"  # "Hole depth (MD)"
+    GR = "GR"  # "Gamma ray"
+    ROP = "ROP"  # "Rate of penetration"
+    WOB = "WOB"  # "Weight on bit"
+    INCL = "INCL"  # "Inclination"
+    AZIM = "AZIM"  # "Azimuth"
+    GAS = "GAS"  # "Total Gas"
+    BIT = "BIT"  # "Bit depth"
+    GRDEPT = "GRDEPT"  # "Gamma ray depth"
+    DENS = "DENS"  # "Density"
+    RESS = "RESS"  # "Shallow Resistivity"
+    RESM = "RESM"  # "Medium Resistivity"
+    RESD = "RESD"  # "Deep Resistivity"
+    DTC = "DTC"  # "Compressional Sonic Travel Time"
+    DTS = "DTS"  # "Shear Sonic Travel Time"
+    SP = "SP"  # "Spontaneous Potential"
+    PHIN = "PHIN"  # "Neutron Porosity"
+    PHID = "PHID"  # "Density Porosity"
+    NMR = "NMR"  # "Nuclear Magnetic Resonance"
+    PE = "PE"  # "Photoelectric cross section"
+    AGR = "AGR"  # "Azimuthal Gamma Ray"
+    PHIE = "PHIE"  # "Porosity"
+    SW = "SW"  # "Water Saturation"
+    VSHL = "VSHL"  # "Shale Content"
+    HCP = "HCP"  # "HydocarbonPorosity"
+    TIME = "TIME"  # "Time (UTC)"
+
+    @classmethod
+    def _missing_(cls, value):
+        return AppMnemonicCodeEnum.NotSet
+
+
+@dataclass_json(letter_case=LetterCase.PASCAL)
+@dataclass
+class Curve(DataModel):
+    description: Optional[str] = None
+    mnemonic: str = ''
+    system_mnemonic: AppMnemonicCodeEnum = field(default_factory=lambda: AppMnemonicCodeEnum.NotSet)
+    unit: Optional[str] = None
+    samples: Optional[np.ndarray] = None    # numpy float array
+    registered: bool = True
+
+    @classmethod
+    def from_dict(cls, dict_obj):
+        instance = cls(**dict_obj)
+        return instance
+
+

zonevu/DataModels/DataModel.py

@@ -0,0 +1,40 @@
+from typing import Optional, Type
+from dataclasses import dataclass, field, fields
+from dataclasses_json import dataclass_json, LetterCase
+from strenum import StrEnum
+
+
+class ChangeAgentEnum(StrEnum):
+    Unknown = 'Unknown'
+    GuiCreate = 'GuiCreate'
+    GuiImport = 'GuiImport'
+    GuiBulkImport = 'GuiBulkImport'
+    WebApi = 'WebApi'
+
+
+class WellElevationUnitsEnum(StrEnum):
+    Undefined = 'Undefined'
+    Meters = 'Meters'
+    Feet = 'Feet'
+    FeetUS = 'FeetUS'
+
+
+@dataclass_json(letter_case=LetterCase.PASCAL)
+@dataclass
+class DataModel:
+    id: int = -1            # Mandatory
+    name: Optional[str] = None
+    row_version: Optional[str] = None
+
+    def merge_from(self, source: 'DataModel'):
+        self.__dict__.update(source.__dict__)
+
+    def copy_ids_from(self, source: 'DataModel'):
+        self.id = source.id
+
+    @staticmethod
+    def merge_lists(dst_list: list['DataModel'], src_list: list['DataModel']):
+        for (dst, src) in zip(dst_list, src_list):
+            if dst is not None and src is not None:
+                dst.copy_ids_from(src)
+

zonevu/DataModels/Formation.py

@@ -0,0 +1,55 @@
+from typing import Optional
+from dataclasses import dataclass, field
+from dataclasses_json import dataclass_json, LetterCase, config
+from .DataModel import DataModel
+from strenum import StrEnum, PascalCaseStrEnum
+
+
+class GeoPeriodEnum(StrEnum):
+    Quaternary = 'Quaternary',
+    Neogene = 'Neogene',
+    Paleogene = 'Paleogene',
+    Cretaceous = 'Cretaceous',
+    Jurassic = 'Jurassic',
+    Triassic = 'Triassic',
+    Permian = 'Permian',
+    Carboniferous = 'Carboniferous',
+    Devonian = 'Devonian',
+    Silurian = 'Silurian',
+    Ordovician = 'Ordovician',
+    Cambrian = 'Cambrian',
+    Precambrian = 'Precambrian'
+
+
+class LithologyTypeEnum(PascalCaseStrEnum):
+    Unset = 'Unset',
+    Sandstone = 'Sandstone',
+    Shale = 'Shale',
+    Limestone = 'Limestone',
+    Dolomite = 'Dolomite',
+    Chalk = 'Chalk',
+    Marl = 'Marl',
+    MudstoneRich = 'MudstoneRich',
+    MudstoneLean = 'MudstoneLean',
+    Bentonite = 'Bentonite',
+    Coal = 'Coal',
+    Chert = 'Chert',
+    Anhydrite = 'Anhydrite',
+    Siltstone = 'Siltstone',
+    ShalySand = 'ShalySand'
+
+
+@dataclass_json(letter_case=LetterCase.PASCAL)
+@dataclass
+class Formation(DataModel):
+    formation_name: Optional[str] = None
+    member_name: Optional[str] = None
+    strat_col_order: int = -1
+    symbol: str = ''
+    color: Optional[str] = None
+    description: Optional[str] = None
+    period: Optional[GeoPeriodEnum] = None
+    lithology_type: Optional[LithologyTypeEnum] = None
+
+    def __post_init__(self):
+        self.name = self.formation_name

zonevu/DataModels/Geomodels/DataGrid.py

@@ -0,0 +1,27 @@
+from typing import Optional
+from enum import StrEnum
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json, LetterCase
+from zonevu.zonevu.DataModels.DataModel import DataModel
+from zonevu.zonevu.DataModels.Geospatial.GridGeometry import GridGeometry
+import numpy as np
+
+
+class GridUsageEnum(StrEnum):
+    Undefined = 'Undefined'
+    Structural = 'Structural'
+    Isopach = 'Isopach'
+    Attribute = 'Attribute'
+
+
+@dataclass_json(letter_case=LetterCase.PASCAL)
+@dataclass
+class DataGrid(DataModel):
+    geometry: GridGeometry = None
+    description: Optional[str] = None
+    usage: GridUsageEnum = GridUsageEnum.Undefined
+    average_value: Optional[float] = None
+    min_value: Optional[float] = None
+    max_value: Optional[float] = None
+    z_values: Optional[np.ndarray] = None  # numpy 32-bit (single precision float array). Must be 32-bit floats!
+

zonevu/DataModels/Geomodels/Geomodel.py

@@ -0,0 +1,27 @@
+from typing import Optional
+from dataclasses import dataclass, field
+from dataclasses_json import dataclass_json, LetterCase
+from zonevu.zonevu.DataModels.DataModel import DataModel, ChangeAgentEnum
+from zonevu.zonevu.DataModels.Geomodels.DataGrid import DataGrid
+from zonevu.zonevu.DataModels.Geomodels.Structure import Structure
+from datetime import datetime
+from zonevu.zonevu.DataModels.Helpers import MakeIsodataOptionalField
+
+
+@dataclass_json(letter_case=LetterCase.PASCAL)
+@dataclass
+class Geomodel(DataModel):
+    external_id: Optional[str] = None
+    external_source: Optional[str] = None
+    creator: Optional[str] = None
+    change_agent: ChangeAgentEnum = ChangeAgentEnum.Unknown
+    creation_date: Optional[datetime] = MakeIsodataOptionalField()
+    last_modified_date: Optional[datetime] = MakeIsodataOptionalField()
+    division_id: int = 0
+    division: str = ''
+    strat_column_id: int = 0
+    strat_column_name: str = ''
+    description: Optional[str] = None
+    data_grids: list[DataGrid] = field(default_factory=list[DataGrid])
+    structures: list[Structure] = field(default_factory=list[Structure])
+

zonevu/DataModels/Geomodels/SimpleGrid.py

@@ -0,0 +1,26 @@
+import numpy as np
+from typing import List
+from dataclasses import dataclass
+from ..Geospatial.Coordinate import Coordinate
+from ..Geospatial.Crs import CrsSpec
+
+
+@dataclass
+class SimpleGrid:
+    """
+    Represents a simple grid.
+    Use float('-inf') to represent empty grid values
+    """
+    name: str
+    origin: Coordinate      # x,y coordinate of grid origin
+    inclination: float      # rotation of grid clockwise
+    dx: float               # grid spacing in x-direction, when not rotated by inclination
+    dy: float               # grid spacing in y-direction
+    num_rows: int           # number of rows in grid. Rows are laid out along the x-direction  (non-rotated)
+    num_cols: int           # number of columns in grid. Columns are laid out along the y-direction (non-rotated)
+    crs: CrsSpec            # The projected coordinate system of the x,y origin.
+    z_values: List[float]   # Z values of grid, as a 1-D array of 32-bit floats in row major order
+
+
+
+

zonevu/DataModels/Geomodels/Structure.py

@@ -0,0 +1,16 @@
+from typing import Optional
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json, LetterCase
+from zonevu.zonevu.DataModels.DataModel import DataModel
+from zonevu.zonevu.DataModels.Geospatial.GridGeometry import GridGeometry
+import numpy as np
+
+
+@dataclass_json(letter_case=LetterCase.PASCAL)
+@dataclass
+class Structure(DataModel):
+    formation_id: int = 0
+    formation_name: str = ''
+    geometry: GridGeometry = None
+    description: Optional[str] = None
+    z_values: Optional[np.ndarray] = None  # numpy float array

zonevu/DataModels/Geospatial/Coordinate.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json, LetterCase
+
+
+@dataclass_json(letter_case=LetterCase.PASCAL)
+@dataclass
+class Coordinate:
+    x: float = 0
+    y: float = 0
+
+    # def rotate(self, angle: float) -> 'Coordinate':
+    #     """
+    #     Rotates this point around the origin by an angle
+    #     @param angle: angle from x-axis in radians
+    #     @return: the rotated point
+    #     """
+    #     x = self.x * math.cos(angle) - self.y * math.sin(angle)
+    #     y = self.x * math.sin(angle) + self.y * math.cos(angle)
+    #     return Coordinate(x, y)
+    #
+    # def __add__(self, other: 'Coordinate') -> 'Coordinate':
+    #     return Coordinate(self.x + other.x, self.y + other.y)

zonevu/DataModels/Geospatial/Crs.py

@@ -0,0 +1,44 @@
+from typing import Optional
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json, LetterCase
+from zonevu.zonevu.DataModels.Geospatial.Enums import DistanceUnitsEnum
+
+
+# Projected coordinate system specification
+@dataclass_json(letter_case=LetterCase.PASCAL)
+@dataclass
+class CrsSpec:
+    """
+    Used to specify a projected coordinate system
+    The EPSG code takes preference if both are specified.
+    The Units data member if provided overrides the default units of the specified coordinate system
+    """
+    epsg_code: Optional[int] = None
+    projection: Optional[str] = None       # DotSpatial string for projection
+    zone: Optional[str] = None              # DotSpatial string for zone
+    units: Optional[DistanceUnitsEnum] = None         # Distance units override.
+
+    @classmethod
+    def from_epsg_code(cls, code: int, units: DistanceUnitsEnum = None) -> 'CrsSpec':
+        return cls(code, None, None, units)
+
+    @classmethod
+    def from_names(cls, projection: str, zone: str, units: DistanceUnitsEnum = None) -> 'CrsSpec':
+        return cls(None, projection, zone, units)
+
+    def to_string(self) -> str:
+        has_epsg = self.epsg_code is not None
+        if has_epsg:
+            return 'CRS (EPSG=%s, UNITS=%s)' % (self.epsg_code, self.units)
+        else:
+            return 'CRS (PROJ=%s, ZONE=%s, UNITS=%s)' % (self.projection, self.zone, self.units)
+
+
+@dataclass_json(letter_case=LetterCase.PASCAL)
+@dataclass
+class CrsEntry:
+    id: str        # DotSpatial string for projection
+    name: str              # DotSpatial string for zone
+
+
+

zonevu/DataModels/Geospatial/Enums.py

@@ -0,0 +1,8 @@
+from strenum import StrEnum
+
+
+class DistanceUnitsEnum(StrEnum):
+    Undefined = 'Undefined'
+    Meters = 'Meters'
+    Feet = 'Feet'
+    FeetUS = 'FeetUS'

zonevu/DataModels/Geospatial/GeoBox.py

@@ -0,0 +1,44 @@
+from typing import List, Tuple
+from functools import reduce
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json, LetterCase
+from .GeoLocation import GeoLocation
+from zonevu.zonevu.Services.Error import ZonevuError
+
+
+@dataclass_json(letter_case=LetterCase.PASCAL)
+@dataclass
+class GeoBox:
+    """
+    Represents the bounds of a map in geolocations
+    """
+    lower_left: GeoLocation
+    upper_right: GeoLocation
+
+    @classmethod
+    def from_locations(cls, locations: List[GeoLocation]):
+        if len(locations) == 0:
+            raise ZonevuError.local('cannot create a GeoBox from a zero length list of geolocations')
+
+        lower_left = reduce(lambda l1, l2: GeoLocation.lower_left_of(l1, l2), locations)
+        upper_right = reduce(lambda l1, l2: GeoLocation.upper_right_of(l1, l2), locations)
+        g = cls(upper_right, lower_left)
+        return g
+
+    @classmethod
+    def from_boxes(cls, b1: 'GeoBox', b2: 'GeoBox') -> 'GeoBox':
+        lower_left = GeoLocation.lower_left_of(b1.lower_left, b2.lower_left)
+        upper_right = GeoLocation.upper_right_of(b1.upper_right, b2.upper_right)
+        return cls(lower_left, upper_right)
+
+    @classmethod
+    def from_box_list(cls, boxes: List['GeoBox']) -> 'GeoBox':
+        largest_box = reduce(lambda b1, b2: GeoBox.from_boxes(b1, b2), boxes)
+        return largest_box
+
+    @property
+    def tuple(self) -> Tuple[float, float, float, float]:
+        geobox_tuple = self.lower_left.tuple + self.upper_right.tuple
+        return geobox_tuple
+
+

zonevu/DataModels/Geospatial/GeoLocation.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json, LetterCase
+import math
+from typing import Tuple
+
+
+@dataclass_json(letter_case=LetterCase.PASCAL)
+@dataclass
+class GeoLocation:
+    latitude: float
+    longitude: float
+
+    @property
+    def tuple(self) -> Tuple[float, float]:
+        return self.longitude, self.latitude
+
+    @staticmethod
+    def error(l1: 'GeoLocation', l2: 'GeoLocation') -> float:
+        loc_err_lat = l1.latitude - l2.latitude
+        loc_err_lon = l1.longitude - l2.longitude
+        e = math.sqrt(math.pow(loc_err_lat, 2) + math.pow(loc_err_lon, 2))
+        return e
+
+    def arc_latitude(self) -> float:
+        return self.latitude * math.pi / 180
+
+    def arc_longitude(self) -> float:
+        return self.longitude * math.pi / 180
+
+    @staticmethod
+    def bearing(s: 'GeoLocation', f: 'GeoLocation') -> float:
+        latitude1 = s.arc_latitude()
+        latitude2 = f.arc_latitude()
+        longitudeDifference = f.arc_longitude() - s.arc_longitude()
+        y = math.sin(longitudeDifference) * math.cos(latitude2)
+        x = math.cos(latitude1) * math.sin(latitude2) - \
+            math.sin(latitude1) * math.cos(latitude2) * math.cos(longitudeDifference)
+        bearing = (math.atan2(y, x) * 180 / math.pi + 360) % 360
+        return bearing
+
+    @classmethod
+    def lower_left_of(cls, l1: 'GeoLocation', l2: 'GeoLocation') -> 'GeoLocation':
+        min_latitude = min(l1.latitude, l2.latitude)
+        min_longitude = min(l1.longitude, l2.longitude)
+        return cls(min_latitude, min_longitude)
+
+    @classmethod
+    def upper_right_of(cls, l1: 'GeoLocation', l2: 'GeoLocation') -> 'GeoLocation':
+        max_latitude = max(l1.latitude, l2.latitude)
+        max_longitude = max(l1.longitude, l2.longitude)
+        return cls(max_latitude, max_longitude)
+

zonevu/DataModels/Geospatial/GridCorner.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json, LetterCase
+from .Coordinate import Coordinate
+from .GeoLocation import GeoLocation
+from typing import Optional
+
+
+@dataclass_json(letter_case=LetterCase.PASCAL)
+@dataclass
+class GridCorner:
+    inline: int
+    crossline: int
+    p: Coordinate
+    lat_long: Optional[GeoLocation] = None

zonevu/DataModels/Geospatial/GridGeometry.py

@@ -0,0 +1,91 @@
+from typing import Optional
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json, LetterCase
+from .GridCorner import GridCorner
+from .Crs import CrsSpec
+from ..Geomodels.SimpleGrid import SimpleGrid
+from .Coordinate import Coordinate
+import math
+
+
+@dataclass
+class GridAxisInfo:
+    start: int
+    stop: int
+    count: int
+
+
+@dataclass
+class GridInfo:
+    inline_range: GridAxisInfo
+    crossline_range: GridAxisInfo
+
+    @property
+    def num_samples(self) -> int:
+        return self.inline_range.count * self.crossline_range.count
+
+
+@dataclass_json(letter_case=LetterCase.PASCAL)
+@dataclass
+class GridGeometry:
+    corner1: GridCorner
+    corner2: GridCorner
+    corner3: GridCorner
+    corner4: GridCorner
+    coordinate_system: CrsSpec
+    inclination: Optional[float] = None
+    geo_inclination: Optional[float] = None
+    inline_bin_interval: Optional[float] = None
+    crossline_bin_interval: Optional[float] = None
+    area: Optional[float] = None
+
+    @property
+    def grid_info(self) -> GridInfo:
+        c1 = self.corner1
+        c3 = self.corner3
+        inline_info = GridAxisInfo(c1.inline, c3.inline, c3.inline - c1.inline + 1)
+        crossline_info = GridAxisInfo(c1.crossline, c3.crossline, c3.crossline - c1.crossline + 1)
+        return GridInfo(inline_info, crossline_info)
+
+    @classmethod
+    def from_simple_grid(cls, grid: SimpleGrid) -> 'GridGeometry':
+        """
+        Method to set up a simple grid geometry.
+        For inclination = 0, rows are west to east, and columns south to north
+        Must provide origin, dx, and dy in distance units of provided CRS
+        @param grid: a simple grid definition
+        @return: a partially filled GridGeometry, where geolocations and geo-inclination not populated.
+
+        NOTES:
+        We set up here a CW grid geometry, where rows (inlines) run from East to West, and columns (crosslines)
+        run South to North.
+        """
+
+        radians = math.radians(grid.inclination)
+        x_length = grid.dx * grid.num_cols
+        y_length = grid.dy * grid.num_rows
+        area = x_length * y_length
+        if grid.crs.units.lower() == 'meters':
+            area = area / 1000000
+        else:
+            area = area / 27878400
+
+        c1 = GridCorner(1, 1, grid.origin, None)                    # LL Un-rotated case
+
+        c2_offset = Coordinate(x_length, 0)
+        c2_point = c2_offset.rotate(radians) + grid.origin
+        c2 = GridCorner(grid.num_cols, 1, c2_point, None)            # LR Un-rotated case
+
+        c3_offset = Coordinate(x_length, y_length)
+        c3_point = c3_offset.rotate(radians) + grid.origin
+        c3 = GridCorner(grid.num_cols, grid.num_rows, c3_point, None)   # UR Un-rotated case
+
+        c4_offset = Coordinate(0, y_length)
+        c4_point = c4_offset.rotate(radians) + grid.origin
+        c4 = GridCorner(1, grid.num_rows, c4_point, None)           # UL Un-rotated case
+
+        g = cls(c1, c2, c3, c4, grid.crs, grid.inclination, None, grid.dy, grid.dx, area)
+        return g
+
+
+

zonevu/DataModels/Geosteering/Conditioning.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass, field
+from typing import Optional
+from dataclasses_json import dataclass_json, LetterCase, config
+
+
+@dataclass_json(letter_case=LetterCase.PASCAL)
+@dataclass
+class Conditioning:
+    """
+    Represents a ZoneVu geosteering curve conditioning parameter set
+    """
+    # Amplitude Range filter
+    AmplClip: bool = False
+    AmplClipRangeMin: Optional[float] = None
+    AmplClipRangeMax: Optional[float] = None
+    AmplClipInclusiveNotExclusive: Optional[bool] = None
+
+    # MD Range filter
+    MDClip: bool = False
+    MDClipRangeMin: Optional[float] = None
+    MDClipRangeMax: Optional[float] = None
+    MDClipInclusiveNotExclusive: Optional[bool] = None
+
+    # Despiking filter.
+    Despike: bool = False
+    VarianceThreshold: Optional[
+        float] = None  # Absolute variance that is acceptable as a number in the units of the curve data.
+    DespikeLen: Optional[int] = None  # Should be an odd number. Number of pts in despiking filter.
+
+    # Interpolation filter.
+    Interpolate: bool = False
+    MaxGap: Optional[int] = None
+
+    # SmoothingFilter filter.
+    Smooth: bool = False
+    SmoothingLen: Optional[int] = None  # Number of points in smoothing filter.
+
+    # Amplitude normalization filter.
+    Normalize: bool = False
+    Bias: Optional[float] = None  # Amplitude shift
+    Scalar: Optional[float] = None  # Amplitude multiplier
+

zonevu/DataModels/Geosteering/CurveDef.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass, field
+from typing import Optional
+from dataclasses_json import dataclass_json, LetterCase, config
+from ..DataModel import DataModel
+from .Conditioning import Conditioning
+from strenum import StrEnum
+
+
+class CurveGroupRoleEnum(StrEnum):
+    Image = 'Image'
+    Litho = 'Litho'
+    Splice = 'Splice'
+
+
+@dataclass_json(letter_case=LetterCase.PASCAL)
+@dataclass
+class CurveDef(DataModel):
+    """
+    Represents a ZoneVu geosteering curve definition
+    """
+    curve_id: Optional[int] = None
+    curve_group_id: Optional[int] = None
+    role: Optional[CurveGroupRoleEnum] = None
+    active: bool = False
+    conditioning: Optional[Conditioning] = None
+