# -*- Pyrex -*-
#
# ======================================================================
#
#                           Brad T. Aagaard
#                        U.S. Geological Survey
#
# {LicenseText}
#
# ======================================================================
#

#header{
#include "pylith/faults/Fault.hh"
#include "pylith/faults/FaultCohesive.hh"
#include "pylith/faults/FaultCohesiveKin.hh"
#include "pylith/faults/EqKinSrc.hh"
#include "pylith/faults/SlipTimeFn.hh"
#include "pylith/faults/BruneSlipFn.hh"

#include "pylith/utils/array.hh"

#include <assert.h>
#include <stdexcept>
#include <Python.h>
#}header

# ----------------------------------------------------------------------
cdef extern from "Python.h":
  object PyCObject_FromVoidPtr(void*, void (*destruct)(void*))
  void* PyCObject_AsVoidPtr(object)

cdef void* ptrFromHandle(obj):
  """Extract pointer from PyCObject."""
  return PyCObject_AsVoidPtr(obj.handle)

cdef extern from "stdlib.h":
  ctypedef unsigned long size_t
  void* malloc(size_t size)
  void free(void* mem)

cdef void Fault_destructor(void* obj):
  """
  Destroy Fault object.
  """
  # create shim for destructor
  #embed{ void Fault_destructor_cpp(void* objVptr)
  pylith::faults::Fault* pM = (pylith::faults::Fault*) objVptr;
  delete pM;
  #}embed
  Fault_destructor_cpp(obj)
  return

cdef void EqKinSrc_destructor(void* obj):
  """
  Destroy EqKinSrc object.
  """
  # create shim for destructor
  #embed{ void EqKinSrc_destructor_cpp(void* objVptr)
  pylith::faults::EqKinSrc* src = (pylith::faults::EqKinSrc*) objVptr;
  delete src;
  #}embed
  EqKinSrc_destructor_cpp(obj)
  return


cdef void SlipTimeFn_destructor(void* obj):
  """
  Destroy SlipTimeFn object.
  """
  # create shim for destructor
  #embed{ void SlipTimeFn_destructor_cpp(void* objVptr)
  pylith::faults::SlipTimeFn* f = (pylith::faults::SlipTimeFn*) objVptr;
  delete f;
  #}embed
  SlipTimeFn_destructor_cpp(obj)
  return


# ----------------------------------------------------------------------
cdef class Fault:

  cdef void* thisptr # Pointer to C++ object
  cdef readonly object handle # PyCObject holding pointer to C++ object
  cdef readonly object name # Identifier for object base type

  def __init__(self):
    """
    Constructor.
    """
    self.handle = None
    self.thisptr = NULL
    self.name = "pylith_faults_Fault"
    return


  def adjustTopology(self, mesh):
    """
    Adjust mesh topology for fault implementation.
    """
    # create shim for method 'adjustTopology'
    #embed{ void Fault_adjustTopology(void* objVptr, void* meshVptr)
    try {
      assert(0 != objVptr);
      ALE::Obj<ALE::Mesh>* mesh = (ALE::Obj<ALE::Mesh>*) meshVptr;
      ((pylith::faults::Fault*) objVptr)->adjustTopology(*mesh);
    } catch (const std::exception& err) {
    PyErr_SetString(PyExc_RuntimeError,
                    const_cast<char*>(err.what()));
    } catch (const ALE::Exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.msg().c_str()));
    } catch (...) {
    PyErr_SetString(PyExc_RuntimeError,
                    "Caught unknown C++ exception.");
    } // try/catch
    #}embed
    Fault_adjustTopology(self.thisptr, ptrFromHandle(mesh))
    return


  def initialize(self, mesh, cs, upDir, normalDir, matDB):
    """
    Initialize fault.
    """
    # create shim for method 'initialize'
    #embed{ void Fault_initialize(void* objVptr, void* meshVptr, void* csVptr, double* upDirPtr, double* normalDirPtr, void* dbVptr)
    try {
      assert(0 != objVptr);
      assert(0 != meshVptr);
      assert(0 != csVptr);
      assert(0 != dbVptr);
      ALE::Obj<ALE::Mesh>* mesh = (ALE::Obj<ALE::Mesh>*) meshVptr;
      spatialdata::geocoords::CoordSys* cs =
        (spatialdata::geocoords::CoordSys*) csVptr;
      spatialdata::spatialdb::SpatialDB* matDB =
        (spatialdata::spatialdb::SpatialDB*) dbVptr;
      pylith::double_array upDir(3);
      upDir[0] = upDirPtr[0];
      upDir[1] = upDirPtr[1];
      upDir[2] = upDirPtr[2];
      pylith::double_array normalDir(3);
      normalDir[0] = normalDirPtr[0];
      normalDir[1] = normalDirPtr[1];
      normalDir[2] = normalDirPtr[2];
      ((pylith::faults::Fault*) objVptr)->initialize(*mesh, cs, upDir, normalDir, matDB);
      } catch (const std::exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.what()));
    } catch (const ALE::Exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.msg().c_str()));
    } catch (...) {
      PyErr_SetString(PyExc_RuntimeError,
                      "Caught unknown C++ exception.");
    } // try/catch      
    #}embed

    if not mesh.name == "pylith_topology_Mesh":
      raise TypeError, \
            "Argument 'mesh' must be extension module type " \
            "'pylith::topology::Mesh'."
    if not cs.name == "spatialdata_geocoords_CoordSys":
      raise TypeError, \
            "Argument 'cs' must be extension module type " \
            "'spatialdata::geocoords::CoordSys'."
    if 3 != len(upDir):
      raise TypeError, \
            "Argument 'upDir' must be a 3 vector (list)."
    if 3 != len(normalDir):
      raise TypeError, \
            "Argument 'normalDir' must be a 3 vector (list)."
    if not matDB.name == "spatialdata_spatialdb_SpatialDB":
      raise TypeError, \
            "Argument 'matDB' must be extension module type " \
            "'spatialdata::spatialdb::SpatialDB'."
    cdef double upDirCpp[3]
    upDirCpp[0] = upDir[0]
    upDirCpp[1] = upDir[1]
    upDirCpp[2] = upDir[2]    
    cdef double normalDirCpp[3]
    normalDirCpp[0] = normalDir[0]
    normalDirCpp[1] = normalDir[1]
    normalDirCpp[2] = normalDir[2]    
    Fault_initialize(self.thisptr, ptrFromHandle(mesh), ptrFromHandle(cs),
                     upDirCpp, normalDirCpp, ptrFromHandle(matDB))
    return


  def _createHandle(self):
    """
    Wrap pointer to C++ object in PyCObject.
    """
    return PyCObject_FromVoidPtr(self.thisptr, Fault_destructor)


  property id:
    def __set__(self, value):
      """
      Set identifier of material.
      """
      # create shim for method 'id'
      #embed{ void Fault_id_set(void* objVptr, int value)
      try {
        assert(0 != objVptr);
        ((pylith::faults::Fault*) objVptr)->id(value);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
        } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      #}embed
      Fault_id_set(self.thisptr, value)

    def __get__(self):
      """
      Get identifier of material.
      """
      # create shim for method 'id'
      #embed{ int Fault_id_get(void* objVptr)
      int result = 0;
      try {
        assert(0 != objVptr);
        result = ((pylith::faults::Fault*) objVptr)->id();
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
        } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      return result;
      #}embed
      return Fault_id_get(self.thisptr)


  property label:
    def __set__(self, value):
      """
      Set label of material.
      """
      # create shim for method 'label'
      #embed{ void Fault_label_set(void* objVptr, char* value)
      try {
        assert(0 != objVptr);
        ((pylith::faults::Fault*) objVptr)->label(value);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      #}embed
      Fault_label_set(self.thisptr, value)


# ----------------------------------------------------------------------
cdef class FaultCohesive(Fault):

  def __init__(self):
    """
    Constructor.
    """
    Fault.__init__(self)
    return


# ----------------------------------------------------------------------
cdef class FaultCohesiveKin(FaultCohesive):

  def __init__(self):
    """
    Constructor.
    """
    # create shim for constructor
    #embed{ void* FaultCohesiveKin_constructor()
    void* result = 0;
    try {
      result = (void*)(new pylith::faults::FaultCohesiveKin);
      assert(0 != result);
    } catch (const std::exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.what()));
    } catch (const ALE::Exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.msg().c_str()));
    } catch (...) {
      PyErr_SetString(PyExc_RuntimeError,
                      "Caught unknown C++ exception.");
    } // try/catch
    return result;
    #}embed

    FaultCohesive.__init__(self)
    self.thisptr = FaultCohesiveKin_constructor()
    self.handle = self._createHandle()
    return


  def integrateResidual(self, residual, t, fields, mesh):
    """
    Integrate contributions to residual term (r) for operator.
    """
    # create shim for method 'integrateResidual'
    #embed{ void FaultCohesiveKin_integrateResidual(void* objVptr, void* residualVptr, double t, void* fieldsVptr, void* meshVptr)
    try {
      assert(0 != objVptr);
      assert(0 != residualVptr);
      assert(0 != fieldsVptr);
      assert(0 != meshVptr);
      ALE::Obj<ALE::Mesh>* mesh =
        (ALE::Obj<ALE::Mesh>*) meshVptr;
      ALE::Obj<pylith::real_section_type>* residual =
        (ALE::Obj<pylith::real_section_type>*) residualVptr;
      pylith::topology::FieldsManager* fields =
        (pylith::topology::FieldsManager*) fieldsVptr;
      ((pylith::faults::FaultCohesiveKin*) objVptr)->integrateResidual(*residual,
                                                              t, fields, *mesh);
    } catch (const std::exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.what()));
    } catch (const ALE::Exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.msg().c_str()));
    } catch (...) {
      PyErr_SetString(PyExc_RuntimeError,
                      "Caught unknown C++ exception.");
    } // try/catch
    #}embed
    if mesh.name != "pylith_topology_Mesh":
      raise TypeError, \
            "Argument must be extension module type 'Mesh'."
    FaultCohesiveKin_integrateResidual(self.thisptr, 
                                       PyCObject_AsVoidPtr(residual),
                                       t,
                                       ptrFromHandle(fields),
                                       ptrFromHandle(mesh))
    return


  def integrateJacobian(self, mat, t, fields, mesh):
    """
    Compute contributions to Jacobian matrix (A) associated with operator.
    """
    # create shim for method 'integrateJacobian'
    #embed{ void FaultCohesiveKin_integrateJacobian(void* objVptr, void* matVptr, double t, void* fieldsVptr, void* meshVptr)
    try {
      assert(0 != objVptr);
      assert(0 != matVptr);
      assert(0 != fieldsVptr);
      assert(0 != meshVptr);
      ALE::Obj<ALE::Mesh>* mesh =
        (ALE::Obj<ALE::Mesh>*) meshVptr;
      PetscMat* mat = (PetscMat*) matVptr;
      pylith::topology::FieldsManager* fields =
        (pylith::topology::FieldsManager*) fieldsVptr;
      ((pylith::faults::FaultCohesiveKin*) objVptr)->integrateJacobian(
                                                        mat, t, fields, *mesh);
    } catch (const std::exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.what()));
    } catch (const ALE::Exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.msg().c_str()));
    } catch (...) {
      PyErr_SetString(PyExc_RuntimeError,
                      "Caught unknown C++ exception.");
    } // try/catch
    #}embed
    if mesh.name != "pylith_topology_Mesh":
      raise TypeError, \
            "Argument 'mesh' must be extension module type 'Mesh'."
    FaultCohesiveKin_integrateJacobian(self.thisptr,
                                       PyCObject_AsVoidPtr(mat),
                                       t, 
                                       ptrFromHandle(fields),
                                       ptrFromHandle(mesh))
    return


  def updateState(self, t, field, mesh):
    """
    Update state variables as needed.
    """
    # create shim for method 'updateState'
    #embed{ void FaultCohesiveKin_updateState(void* objVptr, double t, void* fieldVptr, void* meshVptr)
    try {
      assert(0 != objVptr);
      assert(0 != fieldVptr);
      assert(0 != meshVptr);
      ALE::Obj<pylith::real_section_type>* field =
        (ALE::Obj<pylith::real_section_type>*) fieldVptr;
      ALE::Obj<ALE::Mesh>* mesh =
        (ALE::Obj<ALE::Mesh>*) meshVptr;
      ((pylith::faults::FaultCohesiveKin*) objVptr)->updateState(t, *field, *mesh);
    } catch (const std::exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.what()));
    } catch (const ALE::Exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.msg().c_str()));
    } catch (...) {
      PyErr_SetString(PyExc_RuntimeError,
                      "Caught unknown C++ exception.");
    } // try/catch
    #}embed
    if mesh.name != "pylith_topology_Mesh":
      raise TypeError, \
            "Argument 'mesh' must be extension module type 'Mesh'."
    FaultCohesiveKin_updateState(self.thisptr,
                                 t,
                                 PyCObject_AsVoidPtr(field),
                                 ptrFromHandle(mesh))
    return


  property quadrature:
    def __set__(self, q):
      """
      Set quadrature.
      """
      # create shim for method 'quadrature'
      #embed{ void FaultCohesiveKin_quadrature_set(void* objVptr, void* qVptr)
      try {
        assert(0 != objVptr);
        pylith::feassemble::Quadrature* quadrature =
          (pylith::feassemble::Quadrature*) qVptr;
        ((pylith::faults::FaultCohesiveKin*) objVptr)->quadrature(quadrature);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      #}embed
      if not q.name == "pylith_feassemble_Quadrature":
        raise TypeError, \
              "Argument must be extension module type 'Quadrature'."
      FaultCohesiveKin_quadrature_set(self.thisptr, ptrFromHandle(q))


  property eqsrc:
    def __set__(self, src):
      """
      Set quadrature.
      """
      # create shim for method 'eqsrc'
      #embed{ void FaultCohesiveKin_eqsrc_set(void* objVptr, void* srcVptr)
      try {
        assert(0 != objVptr);
        pylith::faults::EqKinSrc* eqsrc =
          (pylith::faults::EqKinSrc*) srcVptr;
        ((pylith::faults::FaultCohesiveKin*) objVptr)->eqsrc(eqsrc);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      #}embed
      if not src.name == "pylith_faults_EqKinSrc":
        raise TypeError, \
              "Argument must be extension module type 'EqKinSrc'."
      FaultCohesiveKin_eqsrc_set(self.thisptr, ptrFromHandle(src))


  property timeStep:
    def __set__(self, dt):
      """
      Set timeStep.
      """
      # create shim for method 'timeStep'
      #embed{ void FaultCohesiveKin_timeStep_set(void* objVptr, double dt)
      try {
        assert(0 != objVptr);
        ((pylith::faults::FaultCohesiveKin*) objVptr)->timeStep(dt);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      #}embed
      FaultCohesiveKin_timeStep_set(self.thisptr, dt)


  property stableTimeStep:
    def __get__(self):
      """
      Get stable time step.
      """
      # create shim for method 'stableTimeStep'
      #embed{ double FaultCohesiveKin_stableTimeStep_get(void* objVptr)
      double result = 0.0;
      try {
        assert(0 != objVptr);
        result =
          ((pylith::faults::FaultCohesiveKin*) objVptr)->stableTimeStep();
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      return result;
      #}embed
      return FaultCohesiveKin_stableTimeStep_get(self.thisptr)


  property needNewJacobian:
    def __get__(self):
      """
      Set timeStep.
      """
      # create shim for method 'needNewJacobian'
      #embed{ int FaultCohesiveKin_needNewJacobian_get(void* objVptr)
      int result = 0;
      try {
        assert(0 != objVptr);
        result =
          ((pylith::faults::FaultCohesiveKin*) objVptr)->needNewJacobian();
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      return result;
      #}embed
      return FaultCohesiveKin_needNewJacobian_get(self.thisptr)


  property useSolnIncr:
    def __set__(self, flag):
      """
      Set timeStep.
      """
      # create shim for method 'useSolnIncr'
      #embed{ void FaultCohesiveKin_useSolnIncr_set(void* objVptr, int flag)
      try {
        assert(0 != objVptr);
        ((pylith::faults::FaultCohesiveKin*) objVptr)->useSolnIncr(flag);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      #}embed
      FaultCohesiveKin_useSolnIncr_set(self.thisptr, flag)


# ----------------------------------------------------------------------
cdef class EqKinSrc:

  cdef void* thisptr # Pointer to C++ object
  cdef readonly object handle # PyCObject holding pointer to C++ object
  cdef readonly object name # Identifier for object base type

  def __init__(self):
    """
    Constructor.
    """
    # create shim for constructor
    #embed{ void* EqKinSrc_constructor()
    void* result = 0;
    try {
      result = (void*)(new pylith::faults::EqKinSrc);
      assert(0 != result);
    } catch (const std::exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.what()));
    } catch (const ALE::Exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.msg().c_str()));
    } catch (...) {
      PyErr_SetString(PyExc_RuntimeError,
                      "Caught unknown C++ exception.");
    } // try/catch
    return result;
    #}embed

    self.name = "pylith_faults_EqKinSrc"
    self.thisptr = EqKinSrc_constructor()
    self.handle = self._createHandle()
    return


  def _createHandle(self):
    """
    Wrap pointer to C++ object in PyCObject.
    """
    return PyCObject_FromVoidPtr(self.thisptr, EqKinSrc_destructor)


  property slipfn:
    def __set__(self, value):
      """
      Set slip time function.
      """
      # create shim for method 'slipfn'
      #embed{ void EqKinSrc_slipfn_set(void* objVptr, void* fnVptr)
      try {
        assert(0 != objVptr);
        assert(0 != fnVptr);
        pylith::faults::SlipTimeFn* fn =
          (pylith::faults::SlipTimeFn*) fnVptr;
        ((pylith::faults::EqKinSrc*) objVptr)->slipfn(fn);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      #}embed
      if not value.name == "pylith_faults_SlipTimeFn":
        raise TypeError, \
              "Argument must be extension module type " \
              "'pylith_faults_SlipTimeFn'."
      EqKinSrc_slipfn_set(self.thisptr, ptrFromHandle(value))


# ----------------------------------------------------------------------
cdef class SlipTimeFn:

  cdef void* thisptr # Pointer to C++ object
  cdef readonly object handle # PyCObject holding pointer to C++ object
  cdef readonly object name # Identifier for object base type

  def __init__(self):
    """
    Constructor.
    """
    self.handle = None
    self.thisptr = NULL
    self.name = "pylith_faults_SlipTimeFn"
    return


  def _createHandle(self):
    """
    Wrap pointer to C++ object in PyCObject.
    """
    return PyCObject_FromVoidPtr(self.thisptr, SlipTimeFn_destructor)


# ----------------------------------------------------------------------
cdef class BruneSlipFn(SlipTimeFn):

  def __init__(self):
    """
    Constructor.
    """
    # create shim for constructor
    #embed{ void* BruneSlipFn_constructor()
    void* result = 0;
    try {
      result = (void*)(new pylith::faults::BruneSlipFn);
      assert(0 != result);
    } catch (const std::exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.what()));
    } catch (const ALE::Exception& err) {
      PyErr_SetString(PyExc_RuntimeError,
                      const_cast<char*>(err.msg().c_str()));
    } catch (...) {
      PyErr_SetString(PyExc_RuntimeError,
                      "Caught unknown C++ exception.");
    } // try/catch
    return result;
    #}embed

    SlipTimeFn.__init__(self)
    self.thisptr = BruneSlipFn_constructor()
    self.handle = self._createHandle()
    return


  property dbFinalSlip:
    def __set__(self, value):
      """
      Set database for final slip.
      """
      # create shim for method 'dbFinalSlip'
      #embed{ void BruneSlipFn_dbFinalSlip_set(void* objVptr, void* dbVptr)
      try {
        assert(0 != objVptr);
        assert(0 != dbVptr);
        spatialdata::spatialdb::SpatialDB* db =
          (spatialdata::spatialdb::SpatialDB*) dbVptr;
        ((pylith::faults::BruneSlipFn*) objVptr)->dbFinalSlip(db);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      #}embed
      if not value.name == "spatialdata_spatialdb_SpatialDB":
        raise TypeError, \
              "Argument must be extension module type " \
              "'spatialdata::spatialdb::SpatialDB'."
      BruneSlipFn_dbFinalSlip_set(self.thisptr, ptrFromHandle(value))


  property dbSlipTime:
    def __set__(self, value):
      """
      Set database for slip initiation time.
      """
      # create shim for method 'dbSlipTime'
      #embed{ void BruneSlipFn_dbSlipTime_set(void* objVptr, void* dbVptr)
      try {
        assert(0 != objVptr);
        assert(0 != dbVptr);
        spatialdata::spatialdb::SpatialDB* db =
          (spatialdata::spatialdb::SpatialDB*) dbVptr;
        ((pylith::faults::BruneSlipFn*) objVptr)->dbSlipTime(db);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      #}embed
      if not value.name == "spatialdata_spatialdb_SpatialDB":
        raise TypeError, \
              "Argument must be extension module type " \
              "'spatialdata::spatialdb::SpatialDB'."
      BruneSlipFn_dbSlipTime_set(self.thisptr, ptrFromHandle(value))


  property dbPeakRate:
    def __set__(self, value):
      """
      Set database for peak slip rate.
      """
      # create shim for method 'dbPeakRate'
      #embed{ void BruneSlipFn_dbPeakRate_set(void* objVptr, void* dbVptr)
      try {
        assert(0 != objVptr);
        assert(0 != dbVptr);
        spatialdata::spatialdb::SpatialDB* db =
          (spatialdata::spatialdb::SpatialDB*) dbVptr;
        ((pylith::faults::BruneSlipFn*) objVptr)->dbPeakRate(db);
      } catch (const std::exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.what()));
      } catch (const ALE::Exception& err) {
        PyErr_SetString(PyExc_RuntimeError,
                        const_cast<char*>(err.msg().c_str()));
      } catch (...) {
        PyErr_SetString(PyExc_RuntimeError,
                        "Caught unknown C++ exception.");
      } // try/catch
      #}embed
      if not value.name == "spatialdata_spatialdb_SpatialDB":
        raise TypeError, \
              "Argument must be extension module type " \
              "'spatialdata::spatialdb::SpatialDB'."
      BruneSlipFn_dbPeakRate_set(self.thisptr, ptrFromHandle(value))


# End of file