# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

"""Codes for various seismological computations"""

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _seismology
else:
    import _seismology

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


import weakref

class SwigPyIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _seismology.delete_SwigPyIterator

    def value(self):
        return _seismology.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _seismology.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _seismology.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _seismology.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _seismology.SwigPyIterator_equal(self, x)

    def copy(self):
        return _seismology.SwigPyIterator_copy(self)

    def next(self):
        return _seismology.SwigPyIterator_next(self)

    def __next__(self):
        return _seismology.SwigPyIterator___next__(self)

    def previous(self):
        return _seismology.SwigPyIterator_previous(self)

    def advance(self, n):
        return _seismology.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _seismology.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _seismology.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _seismology.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _seismology.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _seismology.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _seismology.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _seismology:
_seismology.SwigPyIterator_swigregister(SwigPyIterator)

import seiscomp.io
import seiscomp.math
import seiscomp.core
import seiscomp.datamodel
import seiscomp.geo
import seiscomp.config
class TravelTimeList_internal(object):
    r"""Proxy of C++ std::list< Seiscomp::TravelTime > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        r"""iterator(TravelTimeList_internal self) -> SwigPyIterator"""
        return _seismology.TravelTimeList_internal_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(TravelTimeList_internal self) -> bool"""
        return _seismology.TravelTimeList_internal___nonzero__(self)

    def __bool__(self):
        r"""__bool__(TravelTimeList_internal self) -> bool"""
        return _seismology.TravelTimeList_internal___bool__(self)

    def __len__(self):
        r"""__len__(TravelTimeList_internal self) -> std::list< Seiscomp::TravelTime >::size_type"""
        return _seismology.TravelTimeList_internal___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(TravelTimeList_internal self, std::list< Seiscomp::TravelTime >::difference_type i, std::list< Seiscomp::TravelTime >::difference_type j) -> TravelTimeList_internal"""
        return _seismology.TravelTimeList_internal___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(TravelTimeList_internal self, std::list< Seiscomp::TravelTime >::difference_type i, std::list< Seiscomp::TravelTime >::difference_type j)
        __setslice__(TravelTimeList_internal self, std::list< Seiscomp::TravelTime >::difference_type i, std::list< Seiscomp::TravelTime >::difference_type j, TravelTimeList_internal v)
        """
        return _seismology.TravelTimeList_internal___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(TravelTimeList_internal self, std::list< Seiscomp::TravelTime >::difference_type i, std::list< Seiscomp::TravelTime >::difference_type j)"""
        return _seismology.TravelTimeList_internal___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(TravelTimeList_internal self, std::list< Seiscomp::TravelTime >::difference_type i)
        __delitem__(TravelTimeList_internal self, PySliceObject * slice)
        """
        return _seismology.TravelTimeList_internal___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(TravelTimeList_internal self, PySliceObject * slice) -> TravelTimeList_internal
        __getitem__(TravelTimeList_internal self, std::list< Seiscomp::TravelTime >::difference_type i) -> TravelTime
        """
        return _seismology.TravelTimeList_internal___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(TravelTimeList_internal self, PySliceObject * slice, TravelTimeList_internal v)
        __setitem__(TravelTimeList_internal self, PySliceObject * slice)
        __setitem__(TravelTimeList_internal self, std::list< Seiscomp::TravelTime >::difference_type i, TravelTime x)
        """
        return _seismology.TravelTimeList_internal___setitem__(self, *args)

    def pop(self):
        r"""pop(TravelTimeList_internal self) -> TravelTime"""
        return _seismology.TravelTimeList_internal_pop(self)

    def append(self, x):
        r"""append(TravelTimeList_internal self, TravelTime x)"""
        return _seismology.TravelTimeList_internal_append(self, x)

    def empty(self):
        r"""empty(TravelTimeList_internal self) -> bool"""
        return _seismology.TravelTimeList_internal_empty(self)

    def size(self):
        r"""size(TravelTimeList_internal self) -> std::list< Seiscomp::TravelTime >::size_type"""
        return _seismology.TravelTimeList_internal_size(self)

    def swap(self, v):
        r"""swap(TravelTimeList_internal self, TravelTimeList_internal v)"""
        return _seismology.TravelTimeList_internal_swap(self, v)

    def begin(self):
        r"""begin(TravelTimeList_internal self) -> std::list< Seiscomp::TravelTime >::iterator"""
        return _seismology.TravelTimeList_internal_begin(self)

    def end(self):
        r"""end(TravelTimeList_internal self) -> std::list< Seiscomp::TravelTime >::iterator"""
        return _seismology.TravelTimeList_internal_end(self)

    def rbegin(self):
        r"""rbegin(TravelTimeList_internal self) -> std::list< Seiscomp::TravelTime >::reverse_iterator"""
        return _seismology.TravelTimeList_internal_rbegin(self)

    def rend(self):
        r"""rend(TravelTimeList_internal self) -> std::list< Seiscomp::TravelTime >::reverse_iterator"""
        return _seismology.TravelTimeList_internal_rend(self)

    def clear(self):
        r"""clear(TravelTimeList_internal self)"""
        return _seismology.TravelTimeList_internal_clear(self)

    def get_allocator(self):
        r"""get_allocator(TravelTimeList_internal self) -> std::list< Seiscomp::TravelTime >::allocator_type"""
        return _seismology.TravelTimeList_internal_get_allocator(self)

    def pop_back(self):
        r"""pop_back(TravelTimeList_internal self)"""
        return _seismology.TravelTimeList_internal_pop_back(self)

    def erase(self, *args):
        r"""
        erase(TravelTimeList_internal self, std::list< Seiscomp::TravelTime >::iterator pos) -> std::list< Seiscomp::TravelTime >::iterator
        erase(TravelTimeList_internal self, std::list< Seiscomp::TravelTime >::iterator first, std::list< Seiscomp::TravelTime >::iterator last) -> std::list< Seiscomp::TravelTime >::iterator
        """
        return _seismology.TravelTimeList_internal_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(TravelTimeList_internal self) -> TravelTimeList_internal
        __init__(TravelTimeList_internal self, TravelTimeList_internal other) -> TravelTimeList_internal
        __init__(TravelTimeList_internal self, std::list< Seiscomp::TravelTime >::size_type size) -> TravelTimeList_internal
        __init__(TravelTimeList_internal self, std::list< Seiscomp::TravelTime >::size_type size, TravelTime value) -> TravelTimeList_internal
        """
        _seismology.TravelTimeList_internal_swiginit(self, _seismology.new_TravelTimeList_internal(*args))

    def push_back(self, x):
        r"""push_back(TravelTimeList_internal self, TravelTime x)"""
        return _seismology.TravelTimeList_internal_push_back(self, x)

    def front(self):
        r"""front(TravelTimeList_internal self) -> TravelTime"""
        return _seismology.TravelTimeList_internal_front(self)

    def back(self):
        r"""back(TravelTimeList_internal self) -> TravelTime"""
        return _seismology.TravelTimeList_internal_back(self)

    def assign(self, n, x):
        r"""assign(TravelTimeList_internal self, std::list< Seiscomp::TravelTime >::size_type n, TravelTime x)"""
        return _seismology.TravelTimeList_internal_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(TravelTimeList_internal self, std::list< Seiscomp::TravelTime >::size_type new_size)
        resize(TravelTimeList_internal self, std::list< Seiscomp::TravelTime >::size_type new_size, TravelTime x)
        """
        return _seismology.TravelTimeList_internal_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(TravelTimeList_internal self, std::list< Seiscomp::TravelTime >::iterator pos, TravelTime x) -> std::list< Seiscomp::TravelTime >::iterator
        insert(TravelTimeList_internal self, std::list< Seiscomp::TravelTime >::iterator pos, std::list< Seiscomp::TravelTime >::size_type n, TravelTime x)
        """
        return _seismology.TravelTimeList_internal_insert(self, *args)

    def pop_front(self):
        r"""pop_front(TravelTimeList_internal self)"""
        return _seismology.TravelTimeList_internal_pop_front(self)

    def push_front(self, x):
        r"""push_front(TravelTimeList_internal self, TravelTime x)"""
        return _seismology.TravelTimeList_internal_push_front(self, x)

    def reverse(self):
        r"""reverse(TravelTimeList_internal self)"""
        return _seismology.TravelTimeList_internal_reverse(self)
    __swig_destroy__ = _seismology.delete_TravelTimeList_internal

# Register TravelTimeList_internal in _seismology:
_seismology.TravelTimeList_internal_swigregister(TravelTimeList_internal)

class Regions(object):
    r"""Proxy of C++ Seiscomp::Regions class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def getFlinnEngdahlRegion(lat, lon):
        r"""getFlinnEngdahlRegion(double lat, double lon) -> std::string"""
        return _seismology.Regions_getFlinnEngdahlRegion(lat, lon)

    @staticmethod
    def getFlinnEngdahlRegionsCount():
        r"""getFlinnEngdahlRegionsCount() -> int"""
        return _seismology.Regions_getFlinnEngdahlRegionsCount()

    @staticmethod
    def getFlinnEngdahlRegionById(id):
        r"""getFlinnEngdahlRegionById(int id) -> std::string"""
        return _seismology.Regions_getFlinnEngdahlRegionById(id)

    @staticmethod
    def load():
        r"""load()"""
        return _seismology.Regions_load()

    @staticmethod
    def getRegionName(lat, lon):
        r"""getRegionName(double lat, double lon) -> std::string"""
        return _seismology.Regions_getRegionName(lat, lon)

    @staticmethod
    def polyRegions():
        r"""polyRegions() -> Seiscomp::Geo::PolyRegions &"""
        return _seismology.Regions_polyRegions()
    __swig_destroy__ = _seismology.delete_Regions

# Register Regions in _seismology:
_seismology.Regions_swigregister(Regions)

def Regions_getFlinnEngdahlRegion(lat, lon):
    r"""Regions_getFlinnEngdahlRegion(double lat, double lon) -> std::string"""
    return _seismology.Regions_getFlinnEngdahlRegion(lat, lon)

def Regions_getFlinnEngdahlRegionsCount():
    r"""Regions_getFlinnEngdahlRegionsCount() -> int"""
    return _seismology.Regions_getFlinnEngdahlRegionsCount()

def Regions_getFlinnEngdahlRegionById(id):
    r"""Regions_getFlinnEngdahlRegionById(int id) -> std::string"""
    return _seismology.Regions_getFlinnEngdahlRegionById(id)

def Regions_load():
    r"""Regions_load()"""
    return _seismology.Regions_load()

def Regions_getRegionName(lat, lon):
    r"""Regions_getRegionName(double lat, double lon) -> std::string"""
    return _seismology.Regions_getRegionName(lat, lon)

def Regions_polyRegions():
    r"""Regions_polyRegions() -> Seiscomp::Geo::PolyRegions &"""
    return _seismology.Regions_polyRegions()

SC3_LOCATOR_INTERFACE_VERSION = _seismology.SC3_LOCATOR_INTERFACE_VERSION

class SensorLocationDelegate(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::Seismology::SensorLocationDelegate class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def getSensorLocation(self, pick):
        r"""getSensorLocation(SensorLocationDelegate self, Pick pick) -> SensorLocation"""
        return _seismology.SensorLocationDelegate_getSensorLocation(self, pick)
    __swig_destroy__ = _seismology.delete_SensorLocationDelegate

# Register SensorLocationDelegate in _seismology:
_seismology.SensorLocationDelegate_swigregister(SensorLocationDelegate)

class LocatorInterface(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::Seismology::LocatorInterface class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    F_NONE = _seismology.LocatorInterface_F_NONE
    
    F_BACKAZIMUTH = _seismology.LocatorInterface_F_BACKAZIMUTH
    
    F_SLOWNESS = _seismology.LocatorInterface_F_SLOWNESS
    
    F_TIME = _seismology.LocatorInterface_F_TIME
    
    F_ALL = _seismology.LocatorInterface_F_ALL
    
    EFlagsQuantity = _seismology.LocatorInterface_EFlagsQuantity
    
    NoCapability = _seismology.LocatorInterface_NoCapability
    
    InitialLocation = _seismology.LocatorInterface_InitialLocation
    
    FixedDepth = _seismology.LocatorInterface_FixedDepth
    
    DistanceCutOff = _seismology.LocatorInterface_DistanceCutOff
    
    IgnoreInitialLocation = _seismology.LocatorInterface_IgnoreInitialLocation
    
    CapQuantity = _seismology.LocatorInterface_CapQuantity
    
    Log = _seismology.LocatorInterface_Log
    
    Warning = _seismology.LocatorInterface_Warning
    
    __swig_destroy__ = _seismology.delete_LocatorInterface

    @staticmethod
    def Create(algo):
        r"""Create(char const * algo) -> LocatorInterface"""
        return _seismology.LocatorInterface_Create(algo)

    def name(self):
        r"""name(LocatorInterface self) -> std::string const &"""
        return _seismology.LocatorInterface_name(self)

    def setSensorLocationDelegate(self, delegate):
        r"""setSensorLocationDelegate(LocatorInterface self, SensorLocationDelegate delegate)"""
        return _seismology.LocatorInterface_setSensorLocationDelegate(self, delegate)

    def init(self, config):
        r"""init(LocatorInterface self, Config config) -> bool"""
        return _seismology.LocatorInterface_init(self, config)

    def parameters(self):
        r"""parameters(LocatorInterface self) -> VectorStr"""
        return _seismology.LocatorInterface_parameters(self)

    def parameter(self, name):
        r"""parameter(LocatorInterface self, std::string const & name) -> std::string"""
        return _seismology.LocatorInterface_parameter(self, name)

    def setParameter(self, name, value):
        r"""setParameter(LocatorInterface self, std::string const & name, std::string const & value) -> bool"""
        return _seismology.LocatorInterface_setParameter(self, name, value)

    def profiles(self):
        r"""profiles(LocatorInterface self) -> VectorStr"""
        return _seismology.LocatorInterface_profiles(self)

    def setProfile(self, name):
        r"""setProfile(LocatorInterface self, std::string const & name)"""
        return _seismology.LocatorInterface_setProfile(self, name)

    def capabilities(self):
        r"""capabilities(LocatorInterface self) -> int"""
        return _seismology.LocatorInterface_capabilities(self)

    def locate(self, *args):
        r"""
        locate(LocatorInterface self, Seiscomp::Seismology::LocatorInterface::PickList & pickList) -> Origin
        locate(LocatorInterface self, Seiscomp::Seismology::LocatorInterface::PickList & pickList, double initLat, double initLon, double initDepth, Time initTime) -> Origin
        """
        return _seismology.LocatorInterface_locate(self, *args)

    def relocate(self, origin):
        r"""relocate(LocatorInterface self, Origin origin) -> Origin"""
        return _seismology.LocatorInterface_relocate(self, origin)

    def lastMessage(self, arg2):
        r"""lastMessage(LocatorInterface self, Seiscomp::Seismology::LocatorInterface::MessageType arg2) -> std::string"""
        return _seismology.LocatorInterface_lastMessage(self, arg2)

    def supports(self, arg2):
        r"""supports(LocatorInterface self, Seiscomp::Seismology::LocatorInterface::Capability arg2) -> bool"""
        return _seismology.LocatorInterface_supports(self, arg2)

    def setFixedDepth(self, depth, use=True):
        r"""setFixedDepth(LocatorInterface self, double depth, bool use=True)"""
        return _seismology.LocatorInterface_setFixedDepth(self, depth, use)

    def useFixedDepth(self, use=True):
        r"""useFixedDepth(LocatorInterface self, bool use=True)"""
        return _seismology.LocatorInterface_useFixedDepth(self, use)

    def fixedDepth(self):
        r"""fixedDepth(LocatorInterface self) -> double"""
        return _seismology.LocatorInterface_fixedDepth(self)

    def usingFixedDepth(self):
        r"""usingFixedDepth(LocatorInterface self) -> bool"""
        return _seismology.LocatorInterface_usingFixedDepth(self)

    def releaseDepth(self):
        r"""releaseDepth(LocatorInterface self)"""
        return _seismology.LocatorInterface_releaseDepth(self)

    def setDistanceCutOff(self, distance):
        r"""setDistanceCutOff(LocatorInterface self, double distance)"""
        return _seismology.LocatorInterface_setDistanceCutOff(self, distance)

    def releaseDistanceCutOff(self):
        r"""releaseDistanceCutOff(LocatorInterface self)"""
        return _seismology.LocatorInterface_releaseDistanceCutOff(self)

    def isInitialLocationIgnored(self):
        r"""isInitialLocationIgnored(LocatorInterface self) -> bool"""
        return _seismology.LocatorInterface_isInitialLocationIgnored(self)

    def setIgnoreInitialLocation(self, f):
        r"""setIgnoreInitialLocation(LocatorInterface self, bool f)"""
        return _seismology.LocatorInterface_setIgnoreInitialLocation(self, f)

    def getPick(self, arrival):
        r"""getPick(LocatorInterface self, Arrival arrival) -> Pick"""
        return _seismology.LocatorInterface_getPick(self, arrival)

    def getSensorLocation(self, pick):
        r"""getSensorLocation(LocatorInterface self, Pick pick) -> SensorLocation"""
        return _seismology.LocatorInterface_getSensorLocation(self, pick)

# Register LocatorInterface in _seismology:
_seismology.LocatorInterface_swigregister(LocatorInterface)

def LocatorInterface_Create(algo):
    r"""LocatorInterface_Create(char const * algo) -> LocatorInterface"""
    return _seismology.LocatorInterface_Create(algo)

class PickNotFoundException(seiscomp.core.GeneralException):
    r"""Proxy of C++ Seiscomp::Seismology::PickNotFoundException class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(PickNotFoundException self) -> PickNotFoundException
        __init__(PickNotFoundException self, std::string const & str) -> PickNotFoundException
        """
        _seismology.PickNotFoundException_swiginit(self, _seismology.new_PickNotFoundException(*args))
    __swig_destroy__ = _seismology.delete_PickNotFoundException

# Register PickNotFoundException in _seismology:
_seismology.PickNotFoundException_swigregister(PickNotFoundException)

class LocatorException(seiscomp.core.GeneralException):
    r"""Proxy of C++ Seiscomp::Seismology::LocatorException class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(LocatorException self) -> LocatorException
        __init__(LocatorException self, std::string const & str) -> LocatorException
        """
        _seismology.LocatorException_swiginit(self, _seismology.new_LocatorException(*args))
    __swig_destroy__ = _seismology.delete_LocatorException

# Register LocatorException in _seismology:
_seismology.LocatorException_swigregister(LocatorException)

class StationNotFoundException(seiscomp.core.GeneralException):
    r"""Proxy of C++ Seiscomp::Seismology::StationNotFoundException class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(StationNotFoundException self) -> StationNotFoundException
        __init__(StationNotFoundException self, std::string const & str) -> StationNotFoundException
        """
        _seismology.StationNotFoundException_swiginit(self, _seismology.new_StationNotFoundException(*args))
    __swig_destroy__ = _seismology.delete_StationNotFoundException

# Register StationNotFoundException in _seismology:
_seismology.StationNotFoundException_swigregister(StationNotFoundException)


def arrivalToFlags(arrival):
    r"""arrivalToFlags(Arrival arrival) -> int"""
    return _seismology.arrivalToFlags(arrival)

def flagsToArrival(arrival, flags):
    r"""flagsToArrival(Arrival arrival, int flags)"""
    return _seismology.flagsToArrival(arrival, flags)
class FileNotFoundError(seiscomp.core.GeneralException):
    r"""Proxy of C++ Seiscomp::FileNotFoundError class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, filename):
        r"""__init__(FileNotFoundError self, std::string const & filename) -> FileNotFoundError"""
        _seismology.FileNotFoundError_swiginit(self, _seismology.new_FileNotFoundError(filename))
    __swig_destroy__ = _seismology.delete_FileNotFoundError

# Register FileNotFoundError in _seismology:
_seismology.FileNotFoundError_swigregister(FileNotFoundError)

class MultipleModelsError(seiscomp.core.GeneralException):
    r"""Proxy of C++ Seiscomp::MultipleModelsError class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, model):
        r"""__init__(MultipleModelsError self, std::string const & model) -> MultipleModelsError"""
        _seismology.MultipleModelsError_swiginit(self, _seismology.new_MultipleModelsError(model))
    __swig_destroy__ = _seismology.delete_MultipleModelsError

# Register MultipleModelsError in _seismology:
_seismology.MultipleModelsError_swigregister(MultipleModelsError)

class NoPhaseError(seiscomp.core.GeneralException):
    r"""Proxy of C++ Seiscomp::NoPhaseError class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(NoPhaseError self) -> NoPhaseError"""
        _seismology.NoPhaseError_swiginit(self, _seismology.new_NoPhaseError())
    __swig_destroy__ = _seismology.delete_NoPhaseError

# Register NoPhaseError in _seismology:
_seismology.NoPhaseError_swigregister(NoPhaseError)

class TravelTime(object):
    r"""Proxy of C++ Seiscomp::TravelTime class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(TravelTime self) -> TravelTime
        __init__(TravelTime self, std::string const & _phase, double _time, double _dtdd, double _dtdh, double _dddp, double _takeoff) -> TravelTime
        """
        _seismology.TravelTime_swiginit(self, _seismology.new_TravelTime(*args))

    def __eq__(self, other):
        r"""__eq__(TravelTime self, TravelTime other) -> bool"""
        return _seismology.TravelTime___eq__(self, other)

    def __lt__(self, other):
        r"""__lt__(TravelTime self, TravelTime other) -> bool"""
        return _seismology.TravelTime___lt__(self, other)
    phase = property(_seismology.TravelTime_phase_get, _seismology.TravelTime_phase_set, doc=r"""phase : std::string""")
    time = property(_seismology.TravelTime_time_get, _seismology.TravelTime_time_set, doc=r"""time : double""")
    dtdd = property(_seismology.TravelTime_dtdd_get, _seismology.TravelTime_dtdd_set, doc=r"""dtdd : double""")
    dtdh = property(_seismology.TravelTime_dtdh_get, _seismology.TravelTime_dtdh_set, doc=r"""dtdh : double""")
    dddp = property(_seismology.TravelTime_dddp_get, _seismology.TravelTime_dddp_set, doc=r"""dddp : double""")
    takeoff = property(_seismology.TravelTime_takeoff_get, _seismology.TravelTime_takeoff_set, doc=r"""takeoff : double""")
    __swig_destroy__ = _seismology.delete_TravelTime

# Register TravelTime in _seismology:
_seismology.TravelTime_swigregister(TravelTime)

class TravelTimeList(TravelTimeList_internal):
    r"""Proxy of C++ Seiscomp::TravelTimeList class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def isEmpty(self):
        r"""isEmpty(TravelTimeList self) -> bool"""
        return _seismology.TravelTimeList_isEmpty(self)

    def sortByTime(self):
        r"""sortByTime(TravelTimeList self)"""
        return _seismology.TravelTimeList_sortByTime(self)
    depth = property(_seismology.TravelTimeList_depth_get, _seismology.TravelTimeList_depth_set, doc=r"""depth : double""")
    delta = property(_seismology.TravelTimeList_delta_get, _seismology.TravelTimeList_delta_set, doc=r"""delta : double""")

    def __init__(self):
        r"""__init__(TravelTimeList self) -> TravelTimeList"""
        _seismology.TravelTimeList_swiginit(self, _seismology.new_TravelTimeList())
    __swig_destroy__ = _seismology.delete_TravelTimeList

# Register TravelTimeList in _seismology:
_seismology.TravelTimeList_swigregister(TravelTimeList)

class TravelTimeTableInterface(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::TravelTimeTableInterface class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _seismology.delete_TravelTimeTableInterface

    @staticmethod
    def Create(name):
        r"""Create(char const * name) -> TravelTimeTableInterface"""
        return _seismology.TravelTimeTableInterface_Create(name)

    def setModel(self, model):
        r"""setModel(TravelTimeTableInterface self, std::string const & model) -> bool"""
        return _seismology.TravelTimeTableInterface_setModel(self, model)

    def model(self):
        r"""model(TravelTimeTableInterface self) -> std::string const &"""
        return _seismology.TravelTimeTableInterface_model(self)

    def compute(self, *args):
        r"""
        compute(TravelTimeTableInterface self, double lat1, double lon1, double dep1, double lat2, double lon2, double alt2=0., int ellc=0) -> TravelTimeList
        compute(TravelTimeTableInterface self, char const * phase, double lat1, double lon1, double dep1, double lat2, double lon2, double alt2=0., int ellc=0) -> TravelTime
        """
        return _seismology.TravelTimeTableInterface_compute(self, *args)

    def computeFirst(self, lat1, lon1, dep1, lat2, lon2, alt2=0., ellc=0):
        r"""computeFirst(TravelTimeTableInterface self, double lat1, double lon1, double dep1, double lat2, double lon2, double alt2=0., int ellc=0) -> TravelTime"""
        return _seismology.TravelTimeTableInterface_computeFirst(self, lat1, lon1, dep1, lat2, lon2, alt2, ellc)

# Register TravelTimeTableInterface in _seismology:
_seismology.TravelTimeTableInterface_swigregister(TravelTimeTableInterface)

def TravelTimeTableInterface_Create(name):
    r"""TravelTimeTableInterface_Create(char const * name) -> TravelTimeTableInterface"""
    return _seismology.TravelTimeTableInterface_Create(name)

class TravelTimeTable(TravelTimeTableInterface):
    r"""Proxy of C++ Seiscomp::TravelTimeTable class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(TravelTimeTable self) -> TravelTimeTable"""
        _seismology.TravelTimeTable_swiginit(self, _seismology.new_TravelTimeTable())

    def setModel(self, model):
        r"""setModel(TravelTimeTable self, std::string const & model) -> bool"""
        return _seismology.TravelTimeTable_setModel(self, model)

    def model(self):
        r"""model(TravelTimeTable self) -> std::string const &"""
        return _seismology.TravelTimeTable_model(self)

    def compute(self, *args):
        r"""
        compute(TravelTimeTable self, double lat1, double lon1, double dep1, double lat2, double lon2, double alt2=0., int ellc=1) -> TravelTimeList
        compute(TravelTimeTable self, char const * phase, double lat1, double lon1, double dep1, double lat2, double lon2, double alt2=0., int ellc=1) -> TravelTime
        """
        return _seismology.TravelTimeTable_compute(self, *args)

    def computeFirst(self, lat1, lon1, dep1, lat2, lon2, alt2=0., ellc=1):
        r"""computeFirst(TravelTimeTable self, double lat1, double lon1, double dep1, double lat2, double lon2, double alt2=0., int ellc=1) -> TravelTime"""
        return _seismology.TravelTimeTable_computeFirst(self, lat1, lon1, dep1, lat2, lon2, alt2, ellc)
    __swig_destroy__ = _seismology.delete_TravelTimeTable

# Register TravelTimeTable in _seismology:
_seismology.TravelTimeTable_swigregister(TravelTimeTable)


def ellipcorr(phase, lat1, lon1, lat2, lon2, depth, corr):
    r"""ellipcorr(std::string const & phase, double lat1, double lon1, double lat2, double lon2, double depth, double & corr) -> bool"""
    return _seismology.ellipcorr(phase, lat1, lon1, lat2, lon2, depth, corr)

def getPhase(arg1, phaseCode):
    r"""getPhase(TravelTimeList arg1, std::string const & phaseCode) -> TravelTime"""
    return _seismology.getPhase(arg1, phaseCode)

def firstArrivalP(arg1):
    r"""firstArrivalP(TravelTimeList arg1) -> TravelTime"""
    return _seismology.firstArrivalP(arg1)
class LocSATErrorEllipsoid(object):
    r"""Proxy of C++ Seiscomp::LocSATErrorEllipsoid class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(LocSATErrorEllipsoid self) -> LocSATErrorEllipsoid"""
        _seismology.LocSATErrorEllipsoid_swiginit(self, _seismology.new_LocSATErrorEllipsoid())
    sxx = property(_seismology.LocSATErrorEllipsoid_sxx_get, _seismology.LocSATErrorEllipsoid_sxx_set, doc=r"""sxx : float""")
    syy = property(_seismology.LocSATErrorEllipsoid_syy_get, _seismology.LocSATErrorEllipsoid_syy_set, doc=r"""syy : float""")
    szz = property(_seismology.LocSATErrorEllipsoid_szz_get, _seismology.LocSATErrorEllipsoid_szz_set, doc=r"""szz : float""")
    stt = property(_seismology.LocSATErrorEllipsoid_stt_get, _seismology.LocSATErrorEllipsoid_stt_set, doc=r"""stt : float""")
    sxy = property(_seismology.LocSATErrorEllipsoid_sxy_get, _seismology.LocSATErrorEllipsoid_sxy_set, doc=r"""sxy : float""")
    sxz = property(_seismology.LocSATErrorEllipsoid_sxz_get, _seismology.LocSATErrorEllipsoid_sxz_set, doc=r"""sxz : float""")
    syz = property(_seismology.LocSATErrorEllipsoid_syz_get, _seismology.LocSATErrorEllipsoid_syz_set, doc=r"""syz : float""")
    stx = property(_seismology.LocSATErrorEllipsoid_stx_get, _seismology.LocSATErrorEllipsoid_stx_set, doc=r"""stx : float""")
    sty = property(_seismology.LocSATErrorEllipsoid_sty_get, _seismology.LocSATErrorEllipsoid_sty_set, doc=r"""sty : float""")
    stz = property(_seismology.LocSATErrorEllipsoid_stz_get, _seismology.LocSATErrorEllipsoid_stz_set, doc=r"""stz : float""")
    sdobs = property(_seismology.LocSATErrorEllipsoid_sdobs_get, _seismology.LocSATErrorEllipsoid_sdobs_set, doc=r"""sdobs : float""")
    smajax = property(_seismology.LocSATErrorEllipsoid_smajax_get, _seismology.LocSATErrorEllipsoid_smajax_set, doc=r"""smajax : float""")
    sminax = property(_seismology.LocSATErrorEllipsoid_sminax_get, _seismology.LocSATErrorEllipsoid_sminax_set, doc=r"""sminax : float""")
    strike = property(_seismology.LocSATErrorEllipsoid_strike_get, _seismology.LocSATErrorEllipsoid_strike_set, doc=r"""strike : float""")
    sdepth = property(_seismology.LocSATErrorEllipsoid_sdepth_get, _seismology.LocSATErrorEllipsoid_sdepth_set, doc=r"""sdepth : float""")
    stime = property(_seismology.LocSATErrorEllipsoid_stime_get, _seismology.LocSATErrorEllipsoid_stime_set, doc=r"""stime : float""")
    conf = property(_seismology.LocSATErrorEllipsoid_conf_get, _seismology.LocSATErrorEllipsoid_conf_set, doc=r"""conf : float""")
    __swig_destroy__ = _seismology.delete_LocSATErrorEllipsoid

# Register LocSATErrorEllipsoid in _seismology:
_seismology.LocSATErrorEllipsoid_swigregister(LocSATErrorEllipsoid)

class LocSAT(LocatorInterface):
    r"""Proxy of C++ Seiscomp::LocSAT class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        r"""__init__(LocSAT self) -> LocSAT"""
        _seismology.LocSAT_swiginit(self, _seismology.new_LocSAT())
    __swig_destroy__ = _seismology.delete_LocSAT

    def init(self, config):
        r"""init(LocSAT self, Config config) -> bool"""
        return _seismology.LocSAT_init(self, config)

    def parameters(self):
        r"""parameters(LocSAT self) -> VectorStr"""
        return _seismology.LocSAT_parameters(self)

    def parameter(self, name):
        r"""parameter(LocSAT self, std::string const & name) -> std::string"""
        return _seismology.LocSAT_parameter(self, name)

    def setParameter(self, name, value):
        r"""setParameter(LocSAT self, std::string const & name, std::string const & value) -> bool"""
        return _seismology.LocSAT_setParameter(self, name, value)

    def profiles(self):
        r"""profiles(LocSAT self) -> VectorStr"""
        return _seismology.LocSAT_profiles(self)

    def setProfile(self, name):
        r"""setProfile(LocSAT self, std::string const & name)"""
        return _seismology.LocSAT_setProfile(self, name)

    @staticmethod
    def setDefaultProfile(name):
        r"""setDefaultProfile(std::string const & name)"""
        return _seismology.LocSAT_setDefaultProfile(name)

    @staticmethod
    def currentDefaultProfile():
        r"""currentDefaultProfile() -> std::string"""
        return _seismology.LocSAT_currentDefaultProfile()

    def setNewOriginID(self, newOriginID):
        r"""setNewOriginID(LocSAT self, std::string const & newOriginID)"""
        return _seismology.LocSAT_setNewOriginID(self, newOriginID)

    def capabilities(self):
        r"""capabilities(LocSAT self) -> int"""
        return _seismology.LocSAT_capabilities(self)

    def locate(self, *args):
        r"""
        locate(LocSAT self, Seiscomp::Seismology::LocatorInterface::PickList & pickList) -> Origin
        locate(LocSAT self, Seiscomp::Seismology::LocatorInterface::PickList & pickList, double initLat, double initLon, double initDepth, Time initTime) -> Origin
        """
        return _seismology.LocSAT_locate(self, *args)

    def relocate(self, origin):
        r"""relocate(LocSAT self, Origin origin) -> Origin"""
        return _seismology.LocSAT_relocate(self, origin)

    def errorEllipsoid(self):
        r"""errorEllipsoid(LocSAT self) -> LocSATErrorEllipsoid"""
        return _seismology.LocSAT_errorEllipsoid(self)

# Register LocSAT in _seismology:
_seismology.LocSAT_swigregister(LocSAT)

def LocSAT_setDefaultProfile(name):
    r"""LocSAT_setDefaultProfile(std::string const & name)"""
    return _seismology.LocSAT_setDefaultProfile(name)

def LocSAT_currentDefaultProfile():
    r"""LocSAT_currentDefaultProfile() -> std::string"""
    return _seismology.LocSAT_currentDefaultProfile()