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

#header{
#include "TestQuadrature.hh"
#}header

import spatialdata.utils.simplearray

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

cdef void* ptrFromHandle(obj):
  return PyCObject_AsVoidPtr(obj.handle)

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


# ----------------------------------------------------------------------
# create shim for TestQuadrature::cellDim
#embed{ int TestQuadrature_cellDim(void* obj)
const pylith::feassemble::Quadrature* q =
  (pylith::feassemble::Quadrature*) obj;
return pylith::feassemble::TestQuadrature::cellDim(*q);
#}embed

# create shim for TestQuadrature::numBasis
#embed{ int TestQuadrature_numBasis(void* obj)
const pylith::feassemble::Quadrature* q =
  (pylith::feassemble::Quadrature*) obj;
return pylith::feassemble::TestQuadrature::numBasis(*q);
#}embed

# create shim for TestQuadrature::numQuadPts
#embed{ int TestQuadrature_numQuadPts(void* obj)
const pylith::feassemble::Quadrature* q =
  (pylith::feassemble::Quadrature*) obj;
return pylith::feassemble::TestQuadrature::numQuadPts(*q);
#}embed

# create shim for TestQuadrature::spaceDim
#embed{ int TestQuadrature_spaceDim(void* obj)
const pylith::feassemble::Quadrature* q =
  (pylith::feassemble::Quadrature*) obj;
return pylith::feassemble::TestQuadrature::spaceDim(*q);
#}embed

# create shim for TestQuadrature::basis
#embed{ double* TestQuadrature_basis(void* obj)
const pylith::feassemble::Quadrature* q =
  (pylith::feassemble::Quadrature*) obj;
const int size = TestQuadrature_numQuadPts(obj) *
                 TestQuadrature_numBasis(obj);
double* vals = (size > 0) ? new double[size] : 0;
const double* basis = pylith::feassemble::TestQuadrature::basis(*q);
memcpy(vals, basis, size*sizeof(double));
return vals;
#}embed

# create shim for TestQuadrature::vertices
#embed{ double* TestQuadrature_vertices(void* obj)
const pylith::feassemble::Quadrature* q =
  (pylith::feassemble::Quadrature*) obj;
const int size = TestQuadrature_numBasis(obj) *
                 TestQuadrature_cellDim(obj);
double* vals = (size > 0) ? new double[size] : 0;
const double* vertices = pylith::feassemble::TestQuadrature::vertices(*q);
memcpy(vals, vertices, size*sizeof(double));
return vals;
#}embed

# create shim for TestQuadrature::basisDeriv
#embed{ double* TestQuadrature_basisDeriv(void* obj)
const pylith::feassemble::Quadrature* q =
  (pylith::feassemble::Quadrature*) obj;
const int size = TestQuadrature_numQuadPts(obj) *
                 TestQuadrature_numBasis(obj) *
                 TestQuadrature_cellDim(obj);
double* vals = (size > 0) ? new double[size] : 0;
const double* basisDeriv = pylith::feassemble::TestQuadrature::basisDeriv(*q);
memcpy(vals, basisDeriv, size*sizeof(double));
return vals;
#}embed

# create shim for TestQuadrature::quadPtsRef
#embed{ double* TestQuadrature_quadPtsRef(void* obj)
const pylith::feassemble::Quadrature* q =
  (pylith::feassemble::Quadrature*) obj;
const int size = TestQuadrature_numQuadPts(obj) *
                 TestQuadrature_cellDim(obj);
double* vals = (size > 0) ? new double[size] : 0;
const double* quadPtsRef = pylith::feassemble::TestQuadrature::quadPtsRef(*q);
memcpy(vals, quadPtsRef, size*sizeof(double));
return vals;
#}embed

# create shim for TestQuadrature::quadWts
#embed{ double* TestQuadrature_quadWts(void* obj)
const pylith::feassemble::Quadrature* q =
  (pylith::feassemble::Quadrature*) obj;
const int size = TestQuadrature_numQuadPts(obj);
double* vals = (size > 0) ? new double[size] : 0;
const double* quadWts = pylith::feassemble::TestQuadrature::quadWts(*q);
memcpy(vals, quadWts, size*sizeof(double));
return vals;
#}embed

# ----------------------------------------------------------------------
def vertices(qhandle):
  """
  Call TestQuadrature::vertices().
  """
  if not qhandle.name == "pylith_feassemble_Quadrature":
    raise TypeError, \
          "Argument 'quadrature' must be extension type 'Quadrature'."

  cdef void* qptr
  qptr = ptrFromHandle(qhandle)

  cdef int numBasis
  cdef int cellDim
  numBasis = TestQuadrature_numBasis(qptr)
  cellDim = TestQuadrature_cellDim(qptr)

  cdef double* values
  values = TestQuadrature_vertices(qptr)
  dims = [numBasis, cellDim]
  valuesObj = PyCObject_FromVoidPtr(values, NULL)
  return spatialdata.utils.simplearray.SimpleCppArray(valuesObj, dims, "double")
  

# ----------------------------------------------------------------------
def basis(qhandle):
  """
  Call TestQuadrature::basis().
  """
  if not qhandle.name == "pylith_feassemble_Quadrature":
    raise TypeError, \
          "Argument 'quadrature' must be extension type 'Quadrature'."

  cdef void* qptr
  qptr = ptrFromHandle(qhandle)

  cdef int numQuadPts
  cdef int numBasis
  numQuadPts = TestQuadrature_numQuadPts(qptr)
  numBasis = TestQuadrature_numBasis(qptr)

  cdef double* values
  values = TestQuadrature_basis(qptr)
  dims = [numQuadPts, numBasis]
  valuesObj = PyCObject_FromVoidPtr(values, NULL)
  return spatialdata.utils.simplearray.SimpleCppArray(valuesObj, dims, "double")
  

# ----------------------------------------------------------------------
def basisDeriv(qhandle):
  """
  Call TestQuadrature::basisDeriv().
  """
  if not qhandle.name == "pylith_feassemble_Quadrature":
    raise TypeError, \
          "Argument 'quadrature' must be extension type 'Quadrature'."

  cdef void* qptr
  qptr = ptrFromHandle(qhandle)

  cdef int numQuadPts
  cdef int numBasis
  cdef int cellDim
  numQuadPts = TestQuadrature_numQuadPts(qptr)
  numBasis = TestQuadrature_numBasis(qptr)
  cellDim = TestQuadrature_cellDim(qptr)

  cdef double* values
  values = TestQuadrature_basisDeriv(qptr)
  dims = [numQuadPts, numBasis, cellDim]
  valuesObj = PyCObject_FromVoidPtr(values, NULL)
  return spatialdata.utils.simplearray.SimpleCppArray(valuesObj, dims,
                                                      "double")
  

# ----------------------------------------------------------------------
def quadPtsRef(qhandle):
  """
  Call TestQuadrature::quadPtsRef().
  """
  if not qhandle.name == "pylith_feassemble_Quadrature":
    raise TypeError, \
          "Argument 'quadrature' must be extension type 'Quadrature'."

  cdef void* qptr
  qptr = ptrFromHandle(qhandle)

  cdef int numQuadPts
  cdef int cellDim
  numQuadPts = TestQuadrature_numQuadPts(qptr)
  cellDim = TestQuadrature_cellDim(qptr)

  cdef double* values
  values = TestQuadrature_quadPtsRef(qptr)
  dims = [numQuadPts, cellDim]
  valuesObj = PyCObject_FromVoidPtr(values, NULL)
  return spatialdata.utils.simplearray.SimpleCppArray(valuesObj, dims,
                                                      "double")
  

# ----------------------------------------------------------------------
def quadWts(qhandle):
  """
  Call TestQuadrature::quadWts().
  """
  if not qhandle.name == "pylith_feassemble_Quadrature":
    raise TypeError, \
          "Argument 'quadrature' must be extension type 'Quadrature'."

  cdef void* qptr
  qptr = ptrFromHandle(qhandle)

  cdef int numQuadPts
  numQuadPts = TestQuadrature_numQuadPts(qptr)

  cdef double* values
  values = TestQuadrature_quadWts(qptr)
  dims = [numQuadPts]
  valuesObj = PyCObject_FromVoidPtr(values, NULL)
  return spatialdata.utils.simplearray.SimpleCppArray(valuesObj, dims,
                                                      "double")


# End of file