1. The GeologicalToolbox API reference — Geological Toolbox 0.1.0b documentation

# 1. The GeologicalToolbox API reference

## 1.1. Members of the ‘GeologicalToolbox’ package

Geological Toolbox Module

This Module is the base for processing and storing of geological data.

## 1.2. Members of the ‘GeologicalToolbox.AbstractLog’ module

This module provides an abstract base class for storing logging or property information.

Todo

- reformat docstrings, espacially of setter and getter functions
- check exception types

class `GeologicalToolbox.AbstractLog.` `AbstractLogClass`(property_name, property_unit, *args, **kwargs)

  This class is the base for storing logging information or properties. This class should be treated as abstract, no object should be created directly!

  `property_name`

    Returns the name of the property

    Returns: | Returns the name of the property

  `property_unit`

    Returns the unit of the property

    Returns: | Returns the unit of the property

## 1.3. Constants defined in the ‘GeologicalToolbox’ package

This module defines constants which are used in the API.

`GeologicalToolbox.Constants.` `float_precision` = 0.001

  precision for float comparison

## 1.4. Members of the ‘GeologicalToolbox.DBHandler’ module

This module provides a class for database access through an SQLAlchemy session and the base class for all database related classes.

class `GeologicalToolbox.DBHandler.` `AbstractDBObject`(session, name='', comment='')

  This class represents the base class for all database objects. It should be treated as abstract, no object should be created directly!

  `comment`

    The additional comments for the AbstractDBObject

    Type: | str

  classmethod `delete_from_db`(obj, session)

    Deletes an object from the database :param obj: object to delete :type obj; object :param session: SQLAlchemy Session handling the connection to the database :type session: Session :return: Nothing

  classmethod `load_all_from_db`(session)

    Returns all well marker in the database connected to the SQLAlchemy Session session

    Parameters: | session (Session) – represents the database connection as SQLAlchemy Session
    Returns: | a list of well marker representing the result of the database query
    Return type: | List[WellMarker]
    Raises: | TypeError – if session is not of type SQLAlchemy Session

  classmethod `load_by_id_from_db`(id, session)

    Returns the line with the given id in the database connected to the SQLAlchemy Session session

    Parameters: | id (int) – Only the object with this id will be returned (has to be 1, unique value) session (Session) – represents the database connection as SQLAlchemy Session
    Returns: | a single line representing the result of the database query
    Return type: | Line
    Raises: | NoResultFound – Raises NoResultFound if no line was found with this id IntegrityError – Raises IntegrityError if more than one line is found (more than one unique value) TypeError – if session is not of type SQLAlchemy Session

  classmethod `load_by_name_from_db`(name, session)

    Returns all DBObjects with the given name in the database connected to the SQLAlchemy Session session

    Parameters: | name (str) – Only DBObjects or derived types with this name will be returned session (Session) – represents the database connection as SQLAlchemy Session
    Returns: | a list of DBObjects representing the result of the database query
    Return type: | List[cls]
    Raises: | TypeError – if session is not of type SQLAlchemy Session

  `name`

    The name of the AbstractDBObject

    Type: | str

  `save_to_db`()

    Saves all changes of the well marker to the database

    Returns: | Nothing
    Raises: | IntegrityError – raises IntegrityError if the commit to the database fails and rolls all changes back

  `session`

    The current Session object

    Type: | Session
    Raises: | TypeError – if session is not of an instance of Session

class `GeologicalToolbox.DBHandler.` `DBHandler`(connection='sqlite:///:memory:', *args, **kwargs)

  A class for database access through an SQLAlchemy session.

  `get_session`()

    Returns the session object for the current database connection

    Returns: | Returns the session object for the current database connection

## 1.5. Exceptions defined for the API

exception `GeologicalToolbox.Exceptions.` `ArgumentError`(msg)

  This exception should be raised, if a wrong number of arguments are submitted or an other failure inside the arguments are recognised.

exception `GeologicalToolbox.Exceptions.` `DatabaseException`(msg)

  This exception should be raised, if an unresolved database issue occurred (e.g. more than one value in a unique column

exception `GeologicalToolbox.Exceptions.` `DatabaseRequestException`(msg)

  This exception should be raised, if an error occurs during a database request (e.g. not the expected result)

exception `GeologicalToolbox.Exceptions.` `FaultException`(msg)

  Will be raised, if a fault marker causes an interruption

exception `GeologicalToolbox.Exceptions.` `ListOrderException`(msg)

  Will be raised, if the ordering of a list is wrong (e.g. min values in an extent list after max…)

exception `GeologicalToolbox.Exceptions.` `WellMarkerDepthException`(msg)

  Will be raised, if a new well marker should be located deeper than the depth of the well

## 1.6. Members of the ‘GeologicalToolbox.Geometries’ module

This module provides basic geometries (points and lines) for storing geological data in database.

class `GeologicalToolbox.Geometries.` `GeoPoint`(horizon, has_z, *args, **kwargs)

  Class GeoPoint

  Represents a geological point feature, e.g. for storing line nodes or geological outcrops in a database.

  `add_property`(prop)

    Adds a new property to the point

    Parameters: | prop (Property) – new point property
    Returns: | Nothing
    Raises: | TypeError – if log is not of type Property

  `del_z`()

    removes the z-value from the point

    Returns: | Nothing

  `delete_property`(prop)

    Deletes a property from the point

    Parameters: | prop (Property) – property to delete
    Returns: | Nothing
    Raises: | TypeError – if log is not of type Property ValueError – if log is not part of self.properties

  `get_property`(property_name)

    Returns requested property, if the property with the name property_name exists for the GeoPoint

    Parameters: | property_name (str) – name of the requested property
    Returns: | Returns the property
    Return type: | Property
    Raises: | ValueError – if no property with the name exists

  `has_property`(property_name)

    Returns True, if a property with the name property_name exists for the GeoPoint, else False

    Parameters: | property_name (str) – name of the requested property
    Returns: | Returns True, if a property with the name property_name exists for the GeoPoint, else False
    Return type: | bool

  `horizon`

    The stratigraphy of the point object

    Type: | StratigraphicObject or None
    Raises: | TypeError – if value is not of type Stratigraphy

  classmethod `load_all_without_lines_from_db`(session)

    Returns all points in the database connected to the SQLAlchemy Session session, which are not part of a line. This function is similar the AbstractGeoObject.load_all_from_db(…) function.

    Parameters: | session (Session) – represents the database connection as SQLAlchemy Session
    Returns: | a list of points representing the result of the database query
    Return type: | List[GeoPoint]
    Raises: | TypeError – if session is not of type SQLAlchemy Session

  classmethod `load_by_name_without_lines_from_db`(name, session)

    Returns all GeoPoints with the given name in the database connected to the SQLAlchemy Session session, which don’t belong to a line

    Parameters: | name (str) – Only GeoPoints with this name will be returned session (Session) – represents the database connection as SQLAlchemy Session
    Returns: | a list of GeoPoints representing the result of the database query
    Return type: | List[GeoPoints]
    Raises: | TypeError – if session is not of type SQLAlchemy Session

  classmethod `load_in_extent_without_lines_from_db`(session, min_easting, max_easting, min_northing, max_northing)

    Returns all points inside the given extent in the database connected to the SQLAlchemy Session session, which are not part of a line. This function is similar the AbstractGeoObject.load_in_extent_from_db(…) function.

    Parameters: | min_easting (float) – minimal easting of extent max_easting (float) – maximal easting of extent min_northing (float) – minimal northing of extent max_northing (float) – maximal northing of extent session (Session) – represents the database connection as SQLAlchemy Session
    Returns: | a list of points representing the result of the database query
    Return type: | List[GeoPoint]
    Raises: | ValueError – if one of the extension values is not compatible to type float TypeError – if session is not of type SQLAlchemy Session

  `use_z`()

    uses the altitude value as z coordinate

    Returns: | Nothing

class `GeologicalToolbox.Geometries.` `Line`(closed, horizon, points, *args, **kwargs)

  Class Line

  Represents a geological line feature, e.g. for storing faults or horizon surface expressions.

  `delete_point`(point)

    Deletes the point from the line

    Parameters: | point (GeoPoint) – GeoPoint object which should be deleted
    Returns: | Nothing
    Raises: | TypeError – Raises TypeError if point is not of type GeoPoint ValueError – Raises ValueError the point is not part of the line

  `delete_point_by_coordinates`(easting, northing, altitude=0)

    Deletes a point with the given coordinates from the line

    Parameters: | easting (float) – easting value of the point to be deleted northing (float) – northing value of the point to be deleted altitude (float) – altitude value of the point to be deleted (only necessary if point has z-values!)
    Returns: | Nothing
    Raises: | ValueError – Raises ValueError if one parameter is not compatible to type float or no point can be found

  `get_point_index`(point)

    Returns the index of the given point in the line

    Parameters: | point (GeoPoint) – point which has to be looked up
    Returns: | Index of the point in the line
    Return type: | int
    Raises: | ValueError – Raises ValueError if committed point is not part of the line

  `horizon`

    The stratigraphy of the line object

    Type: | StratigraphicObject
    Raises: | TypeError – Raises TypeError if value is not of type Stratigraphy

  `insert_point`(point, position)

    Insert a point in the line at the committed index.

    Parameters: | point (GeoPoint) – point to be inserted in the line position (int) – Index, where points should be inserted in the line
    Returns: | Nothing
    Raises: | TypeError – Raises TypeError if point is not of type GeoPoint ValueError – Raises ValueError if position is not of type int or cannot be converted to int

  `insert_points`(points, position)

    Insert a points in the line at the committed index.

    Parameters: | points (List[GeoPoint]) – List of points to be inserted in the line position (int) – Index, where points should be inserted in the line
    Returns: | Nothing
    Raises: | TypeError – Raises TypeError if one of the points is not of type GeoPoint ValueError – Raises ValueError if position is not of type int or cannot be converted to int

  `is_closed`

    True if the line is closed else False

    Type: | bool
    Raises: | ValueError – if value is not compatible to type bool

  classmethod `load_in_extent_from_db`(session, min_easting, max_easting, min_northing, max_northing)

    Returns all lines with at least on point inside the given extent in the database connected to the SQLAlchemy Session session. This function overloads the AbstractGeoObject.load_in_extent_from_db(…) function.

    Parameters: | min_easting (float) – minimal easting of extent max_easting (float) – maximal easting of extent min_northing (float) – minimal northing of extent max_northing (float) – maximal northing of extent session (Session) – represents the database connection as SQLAlchemy Session
    Returns: | a list of lines representing the result of the database query
    Return type: | List[Line]
    Raises: | ValueError – if one of the extension values is not compatible to type float TypeError – if session is not of type SQLAlchemy Session

## 1.7. Members of the ‘GeologicalToolbox.GeoObject’ module

This module hosts the basic AbstractGeoObject class. This class inherits all basic function for GeoObjects

class `GeologicalToolbox.GeoObject.` `AbstractGeoObject`(reference_system, easting, northing, altitude, *args, **kwargs)

  This is a base class which stores central GeoObject data. This class should be treated as abstract, no object should be created directly!

  `altitude`

    The height above sea level of the object

    Type: | float
    Raises: | ValueError – if value is not compatible to type float

  `easting`

    The easting value of the object

    Type: | float
    Raises: | ValueError – if value is not compatible to type float

  classmethod `load_in_extent_from_db`(session, min_easting, max_easting, min_northing, max_northing)

    Returns all points inside the given extent in the database connected to the SQLAlchemy Session session

    Parameters: | min_easting (float) – minimal easting of extent max_easting (float) – maximal easting of extent min_northing (float) – minimal northing of extent max_northing (float) – maximal northing of extent session (Session) – represents the database connection as SQLAlchemy Session
    Returns: | a list of points representing the result of the database query
    Return type: | List[cls]
    Raises: | ValueError – if one of the extension values is not compatible to type float TypeError – if session is not of type SQLAlchemy Session

  `northing`

    The northing value of the object

    Type: | float
    Raises: | ValueError – if value is not compatible to type float

  `reference_system`

    The reference system in WKT format ATTENTION: The reference system is not checked!

    Returns: | Returns the current reference system
    Type: | str

## 1.8. Members of the ‘GeologicalToolbox.Properties’ module

This module provides a class for storing properties of points (and therefore also for lines). Properties for points are the same as logs, except there is only one value, not a list of values. They are both derived from the AbstractLogClass.

Todo

- reformat docstrings, espacially of setter and getter functions
- check exception types

class `GeologicalToolbox.Properties.` `Property`(*args, **kwargs)

  This class represents logging information for wells

  `value`

    Returns the value of the property

    Returns: | Returns the value of the property

## 1.9. Members of the ‘GeologicalToolbox.Requests’ module

This module hosts the class Requests, which provides functionality for special (geo-)database requests.

class `GeologicalToolbox.Requests.` `Requests`

  The class Requests, which provides functionality for special (geo-)database requests.

  static `check_extent`(extent)

    checks, if the given extent has the right format

    Parameters: | extent – value to be checked
    Returns: | Nothing
    Raises: | TypeError – if extent is not a list ValueError – if on list element is not compatible to float or number of elements is not 4 ListOrderException – if the ordering of the extent list [min_easting, max_easting, min_northing, max_northing] is wrong.

  static `create_thickness_point`(sorted_dict, well_id, marker_1, marker_2, session, use_faulted=False, fault_name='', add_properties=())

    Generate a new GeoPoint with thickness property from 2 well marker

    Parameters: | sorted_dict (dict()) – dictionary containing well_id / WellMarker data well_id (int) – current well_id marker_1 (int) – id of marker 1 marker_2 (int) – id of marker 2 session (Session) – current SQLAlchemy session use_faulted (bool) – should faulted sequence be included? fault_name (str) – name of fault stratigraphic unit (default: “Fault”) add_properties (tuple()) – Adds the properties to the GeoPoint. Format for each property: (name, unit, value)
    Returns: | new GeoPoint Object
    Return type: | GeoPoint
    Raises: | FaultException – if a fault is inside the section and use_faulted is False ValueError – if a property in the add_property tuple has less than 3 entries

  static `interpolate_geopoints`(points, property_name, method)

    Interpolate the property values of the given GeoPoints using the interpolation method ‘method’

    Todo

    - Integrate functionality
    - define interpolation methods
    - define return statement

    Parameters: | points (List[GeoPoint]) – List of GeoPoints as interpolation base property_name (str) – Name of the property to interpolate method (str) – Interpolation method
    Returns: | Currently Nothing
    Raises: | TypeError – if on of the points is not of type GeoPoint

    possible values for interpolation method are:

    - nearest (Nearest Neighbour interpolation)
    - ide (Inverse Distance interpolation)
    - spline (Thin-Plate-Spline interpolation)
  static `well_markers_to_thickness`(session, marker_1, marker_2, *args, **kwargs)

    This static method generates a point set including a thickness property derived from the committed well marker

    Parameters: | session (Session) – The SQLAlchemy session connected to the database storing the geodata marker_1 (str) – First WellMarker unit name marker_2 (str) – Second WellMarker unit name summarise_multiple (bool) – Summarise multiple occurrences of marker_1 and marker_2 to a maximum thickness. If this parameter is False (default value) create multiple points. extent ([float, float, float, float]) – extension rectangle as list which borders the well distribution. The list has the following order: [min easting, max easting, min northing, max northing] use_faulted (bool) – if True, also sections with faults between marker_1 and marker_2 are returned fault_name (str) – unit name of fault marker (standard: ‘Fault’)
    Returns: | A list of GeoPoints each with a thickness property
    Return type: | [GeoPoint]
    Raises: | AttributeError – if marker_1 and marker_2 are equal DatabaseException – if the database query results in less than 2 marker of a well_id DatabaseRequestException – if an unexpected query result occurs TypeError – if session is not an instance of SQLAlchemy session ValueError – if a parameter is not compatible with the required type

    for further raises see `Requests.check_extent()`

    Query for selecting markers:

         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        SELECT wm1.* FROM well_marker wm1
        JOIN stratigraphy st1
        ON wm1.horizon_id = st1.id
        WHERE st1.unit_name IN ("mu", "so")
        AND EXISTS
        (
            SELECT 1 FROM well_marker wm2
            JOIN stratigraphy st2
            ON wm2.horizon_id = st2.id
            WHERE st2.unit_name IN ("mu", "so")
            AND wm1.well_id = wm2.well_id
            AND st1.unit_name <> st2.unit_name
        )
        ORDER BY wm1.well_id,wm1.drill_depth

## 1.10. Members of the ‘GeologicalToolbox.Stratigraphy’ module

This module provides a class for storing stratigraphical information in a database.

class `GeologicalToolbox.Stratigraphy.` `StratigraphicObject`(session, name, age=-1)

  A class for storing stratigraphical information in a database.

  `horizon_age`

    The age of the stratigraphic unit

    Type: | float
    Raises: | ValueError – if new value is convertible to type int

  classmethod `init_stratigraphy`(session, name, age=-1, update=False)

    Initialize a stratigraphic unit. Create a new one if unit doesn’t exists in the database, else use the existing.

    Parameters: | session (Session) – SQLAlchemy session, which includes the database connection name (str) – Name of the stratigraphic unit age (float) – age of the stratigraphic unit (-1 if none) update (bool) – update age if stratigraphic unit exists
    Raises: | ValueError – if age is not compatible to float TypeError – if session is not of type SQLAlchemy Session

  classmethod `load_all_from_db`(session)

    Returns all stratigraphic units stored in the database connected to the SQLAlchemy Session session

    Parameters: | session (Session) – represents the database connection as SQLAlchemy Session
    Returns: | a list of stratigraphic units representing the result of the database query
    Return type: | List[StratigraphicObject]
    Raises: | TypeError – if session is not of type SQLAlchemy Session

  classmethod `load_by_age_from_db`(min_age, max_age, session)

    Returns a list of stratigraphic units with an age between min_age and max_age from the database connected to the SQLAlchemy Session session. If no result was found, this function returns an empty list.

    Parameters: | min_age (float) – Minimal age of the stratigraphic units max_age (float) – Maximal age of the stratigraphic units session (Session) – represents the database connection as SQLAlchemy Session
    Returns: | Returns a list of stratigraphic units with an age between min_age and max_age.
    Return type: | List[StratigraphicObject]
    Raises: | ValueError – if min_age or max_age is not compatible to float TypeError – if session is not of type SQLAlchemy Session

  classmethod `load_by_name_from_db`(name, session)

    Returns the stratigraphic unit with the given name in the database connected to the SQLAlchemy Session session

    Parameters: | name (str) – The name of the requested stratigraphic unit session (Session) – represents the database connection as SQLAlchemy Session
    Returns: | As the name is a unique value, only one result can be returned or None
    Return type: | StratigraphicObject or None
    Raises: | DatabaseException – if more than one result was found (name is an unique value) TypeError – if session is not of type SQLAlchemy Session

  `name`

    The name of the stratigraphic unit

    Type: | str

  `save_to_db`()

    Saves all changes of the line or the line itself to the connected database

    Returns: | Nothing
    Raises: | IntegrityError – if the commit to the database fails and rolls all changes back

  `session`

    The current Session object

    Type: | Session
    Raises: | TypeError – if new value is not of an instance of Session

## 1.11. Members of the ‘GeologicalToolbox.WellLogs’ module

This module provides a class for storing logging information of wells. The logging class is derived from the AbstractLogClass.

Todo

- reformat docstrings, espacially of setter and getter functions
- check exception types

class `GeologicalToolbox.WellLogs.` `WellLog`(*args, **kwargs)

  This class represents logging information for wells

  `delete_value`(value)

    Deletes the value from the well log

    Parameters: | value (WellLogValue) – WellLogValue object which should be deleted
    Returns: | Nothing
    Raises: | TypeError – Raises TypeError if value is not of type WellLogValue ValueError – Raises ValueError the value is not part of the well log

  `get_value_by_depth`(depth)

    Returns the value at depth ‘depth’

    Parameters: | depth (float) – depth of the requested marker
    Returns: | Returns the value at depth ‘depth’
    Return type: | WellLogValue
    Raises: | ValueError – Raises ValueError if no marker was found for the committed depth or depth is not compatible to float

  `insert_log_value`(log_value)

    Insert a new log value in the log ATTENTION: If you insert a log value, the log will be automatically stored in the database!

    Parameters: | log_value (WellLogValue) – WellLogValue to be inserted
    Returns: | Nothing
    Raises: | TypeError – Raises TypeError if marker is not an instance of WellLogValue ValueError – Raises ValueError if the depth of the marker is larger than the drilled depth of the well

  `insert_multiple_log_values`(log_values)

    Insert the multiple log values in the log ATTENTION: If you insert value, the log will be automatically stored in the database!

    Parameters: | log_values (List[WellLogValue]) – List of marker to be inserted
    Returns: | Nothing
    Raises: | TypeError – Raises TypeError if one of the marker is not an instance of WellLogValue ValueError – Raises ValueError if the depth of a value is larger than the drilled depth of the well

class `GeologicalToolbox.WellLogs.` `WellLogValue`(depth, value, *args, **kwargs)

  This class connects the logging values to their related depth

  `depth`

    Returns the depth of the log value

    Returns: | Returns the depth of the log value

  `value`

    Returns the value of the log depth

    Returns: | Returns the value of the log depth

## 1.12. Members of the ‘GeologicalToolbox.Wells’ module

This module provides classes for storing drilling data in a database.

Todo

- reformat docstrings, especially of setter and getter functions
- check exception types

class `GeologicalToolbox.Wells.` `Well`(well_name, short_name, depth, *args, **kwargs)

  Class Well

  Represents a well for storage of geoscientific data.

  `add_log`(log)

    Adds a new log to the well

    Parameters: | log (WellLog) – new well log
    Returns: | Nothing
    Raises: | TypeError – Raises TypeError if log is not of type WellLog

  `delete_log`(log)

    Deletes a log from the well

    Parameters: | log (WellLog) – log to delete
    Returns: | Nothing
    Raises: | TypeError – Raises TypeError if log is not of type WellLog ValueError – Raises ValueError if log is not part of self.logs

  `delete_marker`(marker)

    Deletes the marker from the well

    Parameters: | marker (WellMarker) – WellMarker object which should be deleted
    Returns: | Nothing
    Raises: | TypeError – Raises TypeError if marker is not of type WellMarker ValueError – Raises ValueError the marker is not part of the well

  `depth`

    Returns the drilling depth of the well

    Returns: | Returns the drilling depth of the well
    Return type: | float

  `get_marker_by_depth`(depth)

    Returns the marker at depth ‘depth’

    Parameters: | depth (float) – depth of the requested marker
    Returns: | Returns the marker at depth ‘depth’
    Return type: | WellMarker
    Raises: | ValueError – Raises ValueError if no marker was found for the committed depth or depth is not compatible to float

  `insert_marker`(marker)

    Insert a new WellMarker in the well ATTENTION: If you insert a marker, the well will be automatically stored in the database!

    Parameters: | marker (WellMarker) – WellMarker to be inserted
    Returns: | Nothing
    Raises: | TypeError – Raises TypeError if marker is not of type WellMarker ValueError – Raises ValueError if the depth of the marker is larger than the drilled depth of the well

  `insert_multiple_marker`(marker)

    Insert the multiple marker in the well ATTENTION: If you insert marker, the well will be automatically stored in the database!

    Parameters: | marker (List[WellMarker]) – List of marker to be inserted
    Returns: | Nothing
    Raises: | TypeError – Raises TypeError if one of the marker is not of type WellMarker ValueError – Raises ValueError if the depth of a marker is larger than the drilled depth of the well

  classmethod `load_by_wellname_from_db`(name, session)

    Returns the well with the given name in the database connected to the SQLAlchemy Session session

    Parameters: | name (str) – Only the well with this name will be returned session (Session) – represents the database connection as SQLAlchemy Session
    Returns: | As the name is a unique value, only one result can be returned or None
    Return type: | Well or None
    Raises: | DatabaseException – Raises DatabaseException if more than one result was found (name is an unique value)

  classmethod `load_deeper_than_value_from_db`(session, min_depth)

    Returns all wells with a drilled depth below the min_depth in the database connected to the SQLAlchemy Session session

    Parameters: | min_depth (float) – minimal drilled depth session (Session) – represents the database connection as SQLAlchemy Session
    Returns: | a list of wells representing the result of the database query
    Return type: | List[Well]

  `short_name`

    Returns the short name of the well

    Returns: | Returns the short name of the well
    Return type: | str

  `well_name`

    Returns the name of the well

    Returns: | Returns the name of the well
    Return type: | str

class `GeologicalToolbox.Wells.` `WellMarker`(depth, horizon, *args, **kwargs)

  Class WellMarker

  Represents single markers in a drilled well

  `depth`

    Returns the depth of the well marker below Kelly Bushing.

    Returns: | Returns the depth of the well marker below Kelly Bushing.
    Return type: | float

  `horizon`

    Returns the stratigraphy of the point

    Returns: | Returns the current Stratigraphy
    Return type: | StratigraphicObject

  classmethod `load_all_by_stratigraphy_from_db`(horizon, session)

    Returns all WellMarker in the database which are connected to the horizon ‘horizon’

    Parameters: | horizon (StratigraphicObject) – stratigraphy for the database query session (Session) – represents the database connection as SQLAlchemy Session
    Returns: | a list of WellMarker
    Return type: | List[WellMarker]

  classmethod `load_all_by_stratigraphy_in_extent_from_db`(horizon, min_easting, max_easting, min_northing, max_northing, session)

    Returns all WellMarker in the database which are connected to the horizon ‘horizon’

    Parameters: | horizon (StratigraphicObject) – stratigraphy for the database query min_easting (float) – minimal easting of extent max_easting (float) – maximal easting of extent min_northing (float) – minimal northing of extent max_northing (float) – maximal northing of extent session (Session) – represents the database connection as SQLAlchemy Session
    Returns: | a list of WellMarker
    Return type: | List[WellMarker]

  classmethod `load_in_extent_from_db`(session, min_easting, max_easting, min_northing, max_northing)

    Returns all well marker with committed horizon inside the given extent in the database connected to the SQLAlchemy Session session

    Parameters: | min_easting (float) – minimal easting of extent max_easting (float) – maximal easting of extent min_northing (float) – minimal northing of extent max_northing (float) – maximal northing of extent session (Session) – represents the database connection as SQLAlchemy Session
    Returns: | a list of wells representing the result of the database query
    Return type: | List[WellMarker]

  `to_geopoint`()

    Returns the current well marker as GeoPoint

    Returns: | Returns the current well marker as GeoPoint
    Return type: | GeoPoint