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