diff --git a/python/Element.hpp b/python/Element.hpp
index c22c2e6..aa09dfc 100644
--- a/python/Element.hpp
+++ b/python/Element.hpp
@@ -1,29 +1,27 @@
/* =================================================================================================
(c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM
================================================================================================= */
#include <GooseFEM/GooseFEM.h>
#include <pybind11/pybind11.h>
#include <pyxtensor/pyxtensor.hpp>
namespace py = pybind11;
void init_Element(py::module& m)
{
- m.def(
- "asElementVector",
+ m.def("asElementVector",
&GooseFEM::Element::asElementVector,
"Convert nodal vector [nnode, ndim] to nodal vector stored per element [nelem, nne, ndim]",
py::arg("conn"),
py::arg("nodevec"));
- m.def(
- "assembleElementVector",
+ m.def("assembleElementVector",
&GooseFEM::Element::assembleNodeVector,
"Assemble nodal vector stored per element [nelem, nne, ndim] to nodal vector [nnode, ndim]",
py::arg("conn"),
py::arg("elemvec"));
}
diff --git a/python/ElementHex8.hpp b/python/ElementHex8.hpp
index ef85435..a0d6f5f 100644
--- a/python/ElementHex8.hpp
+++ b/python/ElementHex8.hpp
@@ -1,148 +1,135 @@
/* =================================================================================================
(c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM
================================================================================================= */
#include <GooseFEM/GooseFEM.h>
#include <pybind11/pybind11.h>
#include <pyxtensor/pyxtensor.hpp>
namespace py = pybind11;
void init_ElementHex8(py::module& m)
{
py::class_<GooseFEM::Element::Hex8::Quadrature>(m, "Quadrature")
.def(py::init<const xt::xtensor<double, 3>&>(), "Quadrature", py::arg("x"))
- .def(
- py::init<
+ .def(py::init<
const xt::xtensor<double, 3>&,
const xt::xtensor<double, 2>&,
const xt::xtensor<double, 1>&>(),
"Quadrature",
py::arg("x"),
py::arg("xi"),
py::arg("w"))
- .def(
- "update_x",
+ .def("update_x",
&GooseFEM::Element::Hex8::Quadrature::update_x,
"Update the nodal positions")
- .def("nelem", &GooseFEM::Element::Hex8::Quadrature::nelem, "Number of elements")
-
- .def("nne", &GooseFEM::Element::Hex8::Quadrature::nne, "Number of nodes per element")
-
- .def("ndim", &GooseFEM::Element::Hex8::Quadrature::ndim, "Number of dimensions")
-
- .def("nip", &GooseFEM::Element::Hex8::Quadrature::nip, "Number of integration points")
-
.def("dV", &GooseFEM::Element::Hex8::Quadrature::dV, "Integration point volume (qscalar)")
- .def(
- "GradN_vector",
+ .def("GradN_vector",
py::overload_cast<const xt::xtensor<double, 3>&>(
&GooseFEM::Element::Hex8::Quadrature::GradN_vector, py::const_),
"Dyadic product, returns 'qtensor'",
py::arg("elemvec"))
- .def(
- "GradN_vector_T",
+ .def("GradN_vector_T",
py::overload_cast<const xt::xtensor<double, 3>&>(
&GooseFEM::Element::Hex8::Quadrature::GradN_vector_T, py::const_),
"Dyadic product, returns 'qtensor'",
py::arg("elemvec"))
- .def(
- "SymGradN_vector",
+ .def("SymGradN_vector",
py::overload_cast<const xt::xtensor<double, 3>&>(
&GooseFEM::Element::Hex8::Quadrature::SymGradN_vector, py::const_),
"Dyadic product, returns 'qtensor'",
py::arg("elemvec"))
- .def(
- "Int_N_scalar_NT_dV",
+ .def("Int_N_scalar_NT_dV",
py::overload_cast<const xt::xtensor<double, 2>&>(
&GooseFEM::Element::Hex8::Quadrature::Int_N_scalar_NT_dV, py::const_),
"Integration, returns 'elemmat'",
py::arg("qscalar"))
- .def(
- "Int_gradN_dot_tensor2_dV",
+ .def("Int_gradN_dot_tensor2_dV",
py::overload_cast<const xt::xtensor<double, 4>&>(
&GooseFEM::Element::Hex8::Quadrature::Int_gradN_dot_tensor2_dV, py::const_),
"Integration, returns 'elemvec'",
py::arg("qtensor"))
- .def(
- "Int_gradN_dot_tensor4_dot_gradNT_dV",
+ .def("Int_gradN_dot_tensor4_dot_gradNT_dV",
py::overload_cast<const xt::xtensor<double, 6>&>(
&GooseFEM::Element::Hex8::Quadrature::Int_gradN_dot_tensor4_dot_gradNT_dV,
py::const_),
"Integration, returns 'elemvec'",
py::arg("qtensor"))
- .def(
- "AsTensor",
+ // Derived from QuadratureBase
+
+ .def("nelem", &GooseFEM::Element::Hex8::Quadrature::nelem, "Number of elements")
+
+ .def("nne", &GooseFEM::Element::Hex8::Quadrature::nne, "Number of nodes per element")
+
+ .def("ndim", &GooseFEM::Element::Hex8::Quadrature::ndim, "Number of dimensions")
+
+ .def("nip", &GooseFEM::Element::Hex8::Quadrature::nip, "Number of integration points")
+
+ .def("AsTensor",
(xt::xarray<double>(GooseFEM::Element::Hex8::Quadrature::*)(
size_t, const xt::xtensor<double, 2>&) const)
&GooseFEM::Element::Hex8::Quadrature::AsTensor<double>,
"Convert 'qscalar' to 'qtensor' of certain rank")
- .def(
- "AllocateQtensor",
- (xt::xarray<double>(GooseFEM::Element::Hex8::Quadrature::*)(
- size_t) const)
+ .def("AllocateQtensor",
+ (xt::xarray<double>(GooseFEM::Element::Hex8::Quadrature::*)(size_t) const)
&GooseFEM::Element::Hex8::Quadrature::AllocateQtensor<double>,
"Allocate 'qtensor'",
py::arg("rank"))
- .def(
- "AllocateQtensor",
- (xt::xarray<double>(GooseFEM::Element::Hex8::Quadrature::*)(
- size_t, double) const)
+ .def("AllocateQtensor",
+ (xt::xarray<double>(GooseFEM::Element::Hex8::Quadrature::*)(size_t, double) const)
&GooseFEM::Element::Hex8::Quadrature::AllocateQtensor<double>,
"Allocate 'qtensor'",
py::arg("rank"),
py::arg("val"))
- .def(
- "AllocateQscalar",
+ .def("AllocateQscalar",
py::overload_cast<>(
&GooseFEM::Element::Hex8::Quadrature::AllocateQscalar<double>, py::const_),
"Allocate 'qscalar'")
- .def(
- "AllocateQscalar",
+ .def("AllocateQscalar",
py::overload_cast<double>(
&GooseFEM::Element::Hex8::Quadrature::AllocateQscalar<double>, py::const_),
"Allocate 'qscalar'",
py::arg("val"))
.def("__repr__", [](const GooseFEM::Element::Hex8::Quadrature&) {
return "<GooseFEM.Element.Hex8.Quadrature>";
});
}
void init_ElementHex8Gauss(py::module& m)
{
m.def("nip", &GooseFEM::Element::Hex8::Gauss::nip, "Return number of integration point");
m.def("xi", &GooseFEM::Element::Hex8::Gauss::xi, "Return integration point coordinates");
m.def("w", &GooseFEM::Element::Hex8::Gauss::w, "Return integration point weights");
}
void init_ElementHex8Nodal(py::module& m)
{
m.def("nip", &GooseFEM::Element::Hex8::Nodal::nip, "Return number of integration point");
m.def("xi", &GooseFEM::Element::Hex8::Nodal::xi, "Return integration point coordinates");
m.def("w", &GooseFEM::Element::Hex8::Nodal::w, "Return integration point weights");
}
diff --git a/python/ElementQuad4.hpp b/python/ElementQuad4.hpp
index 44190a4..76f39c5 100644
--- a/python/ElementQuad4.hpp
+++ b/python/ElementQuad4.hpp
@@ -1,166 +1,150 @@
/* =================================================================================================
(c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM
================================================================================================= */
#include <GooseFEM/GooseFEM.h>
#include <pybind11/pybind11.h>
#include <pyxtensor/pyxtensor.hpp>
namespace py = pybind11;
void init_ElementQuad4(py::module& m)
{
py::class_<GooseFEM::Element::Quad4::Quadrature>(m, "Quadrature")
.def(py::init<const xt::xtensor<double, 3>&>(), "Quadrature", py::arg("x"))
- .def(
- py::init<
+ .def(py::init<
const xt::xtensor<double, 3>&,
const xt::xtensor<double, 2>&,
const xt::xtensor<double, 1>&>(),
"Quadrature",
py::arg("x"),
py::arg("xi"),
py::arg("w"))
- .def(
- "update_x",
+ .def("update_x",
&GooseFEM::Element::Quad4::Quadrature::update_x,
"Update the nodal positions")
.def("dV", &GooseFEM::Element::Quad4::Quadrature::dV, "Integration point volume (qscalar)")
- .def(
- "Interp_N_vector",
+ .def("Interp_N_vector",
&GooseFEM::Element::Quad4::Quadrature::Interp_N_vector<double>,
"See :cpp:class:`GooseFEM::Quad4::Quadrature::Interp_N_vector`.",
py::arg("elemvec"))
- .def(
- "GradN_vector",
+ .def("GradN_vector",
py::overload_cast<const xt::xtensor<double, 3>&>(
&GooseFEM::Element::Quad4::Quadrature::GradN_vector, py::const_),
"Dyadic product, returns 'qtensor'",
py::arg("elemvec"))
- .def(
- "GradN_vector_T",
+ .def("GradN_vector_T",
py::overload_cast<const xt::xtensor<double, 3>&>(
&GooseFEM::Element::Quad4::Quadrature::GradN_vector_T, py::const_),
"Dyadic product, returns 'qtensor'",
py::arg("elemvec"))
- .def(
- "SymGradN_vector",
+ .def("SymGradN_vector",
py::overload_cast<const xt::xtensor<double, 3>&>(
&GooseFEM::Element::Quad4::Quadrature::SymGradN_vector, py::const_),
"Dyadic product, returns 'qtensor'",
py::arg("elemvec"))
- .def(
- "Int_N_scalar_NT_dV",
+ .def("Int_N_scalar_NT_dV",
py::overload_cast<const xt::xtensor<double, 2>&>(
&GooseFEM::Element::Quad4::Quadrature::Int_N_scalar_NT_dV, py::const_),
"Integration, returns 'elemmat'",
py::arg("qscalar"))
- .def(
- "Int_gradN_dot_tensor2_dV",
+ .def("Int_gradN_dot_tensor2_dV",
py::overload_cast<const xt::xtensor<double, 4>&>(
&GooseFEM::Element::Quad4::Quadrature::Int_gradN_dot_tensor2_dV, py::const_),
"Integration, returns 'elemvec'",
py::arg("qtensor"))
- .def(
- "Int_gradN_dot_tensor4_dot_gradNT_dV",
+ .def("Int_gradN_dot_tensor4_dot_gradNT_dV",
py::overload_cast<const xt::xtensor<double, 6>&>(
&GooseFEM::Element::Quad4::Quadrature::Int_gradN_dot_tensor4_dot_gradNT_dV,
py::const_),
"Integration, returns 'elemvec'",
py::arg("qtensor"))
// Derived from QuadratureBase
.def("nelem", &GooseFEM::Element::Quad4::Quadrature::nelem, "Number of elements")
.def("nne", &GooseFEM::Element::Quad4::Quadrature::nne, "Number of nodes per element")
.def("ndim", &GooseFEM::Element::Quad4::Quadrature::ndim, "Number of dimensions")
.def("nip", &GooseFEM::Element::Quad4::Quadrature::nip, "Number of integration points")
- .def(
- "AsTensor",
+ .def("AsTensor",
(xt::xarray<double>(GooseFEM::Element::Quad4::Quadrature::*)(
size_t, const xt::xtensor<double, 2>&) const)
&GooseFEM::Element::Quad4::Quadrature::AsTensor<double>,
"Convert 'qscalar' to 'qtensor' of certain rank")
- .def(
- "ShapeQtensor",
+ .def("ShapeQtensor",
(std::vector<size_t>(GooseFEM::Element::Quad4::Quadrature::*)(size_t) const)
&GooseFEM::Element::Quad4::Quadrature::ShapeQtensor,
"Shape of 'qtensor'",
py::arg("rank"))
- .def(
- "ShapeQscalar",
+ .def("ShapeQscalar",
&GooseFEM::Element::Quad4::Quadrature::ShapeQscalar,
"Shape of 'qscalar'")
- .def(
- "AllocateQtensor",
+ .def("AllocateQtensor",
(xt::xarray<double>(GooseFEM::Element::Quad4::Quadrature::*)(size_t) const)
&GooseFEM::Element::Quad4::Quadrature::AllocateQtensor<double>,
"Allocate 'qtensor'",
py::arg("rank"))
- .def(
- "AllocateQtensor",
+ .def("AllocateQtensor",
(xt::xarray<double>(GooseFEM::Element::Quad4::Quadrature::*)(size_t, double) const)
&GooseFEM::Element::Quad4::Quadrature::AllocateQtensor<double>,
"Allocate 'qtensor'",
py::arg("rank"),
py::arg("val"))
- .def(
- "AllocateQscalar",
+ .def("AllocateQscalar",
py::overload_cast<>(
&GooseFEM::Element::Quad4::Quadrature::AllocateQscalar<double>, py::const_),
"Allocate 'qscalar'")
- .def(
- "AllocateQscalar",
+ .def("AllocateQscalar",
py::overload_cast<double>(
&GooseFEM::Element::Quad4::Quadrature::AllocateQscalar<double>, py::const_),
"Allocate 'qscalar'",
py::arg("val"))
.def("__repr__", [](const GooseFEM::Element::Quad4::Quadrature&) {
return "<GooseFEM.Element.Quad4.Quadrature>";
});
}
void init_ElementQuad4Gauss(py::module& m)
{
m.def("nip", &GooseFEM::Element::Quad4::Gauss::nip, "Return number of integration point");
m.def("xi", &GooseFEM::Element::Quad4::Gauss::xi, "Return integration point coordinates");
m.def("w", &GooseFEM::Element::Quad4::Gauss::w, "Return integration point weights");
}
void init_ElementQuad4Nodal(py::module& m)
{
m.def("nip", &GooseFEM::Element::Quad4::Nodal::nip, "Return number of integration point");
m.def("xi", &GooseFEM::Element::Quad4::Nodal::xi, "Return integration point coordinates");
m.def("w", &GooseFEM::Element::Quad4::Nodal::w, "Return integration point weights");
}
diff --git a/python/ElementQuad4Axisymmetric.hpp b/python/ElementQuad4Axisymmetric.hpp
index 61776cf..bed138c 100644
--- a/python/ElementQuad4Axisymmetric.hpp
+++ b/python/ElementQuad4Axisymmetric.hpp
@@ -1,141 +1,118 @@
/* =================================================================================================
(c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM
================================================================================================= */
#include <GooseFEM/GooseFEM.h>
#include <pybind11/pybind11.h>
#include <pyxtensor/pyxtensor.hpp>
namespace py = pybind11;
void init_ElementQuad4Axisymmetric(py::module& m)
{
py::class_<GooseFEM::Element::Quad4::QuadratureAxisymmetric>(m, "QuadratureAxisymmetric")
.def(py::init<const xt::xtensor<double, 3>&>(), "QuadratureAxisymmetric", py::arg("x"))
- .def(
- py::init<
+ .def(py::init<
const xt::xtensor<double, 3>&,
const xt::xtensor<double, 2>&,
const xt::xtensor<double, 1>&>(),
"QuadratureAxisymmetric",
py::arg("x"),
py::arg("xi"),
py::arg("w"))
- .def(
- "update_x",
+ .def("update_x",
&GooseFEM::Element::Quad4::QuadratureAxisymmetric::update_x,
"Update the nodal positions")
- .def(
- "nelem", &GooseFEM::Element::Quad4::QuadratureAxisymmetric::nelem, "Number of elements")
-
- .def(
- "nne",
- &GooseFEM::Element::Quad4::QuadratureAxisymmetric::nne,
- "Number of nodes per element")
-
- .def(
- "ndim", &GooseFEM::Element::Quad4::QuadratureAxisymmetric::ndim, "Number of dimensions")
-
- .def(
- "nip",
- &GooseFEM::Element::Quad4::QuadratureAxisymmetric::nip,
- "Number of integration points")
-
- .def(
- "dV",
+ .def("dV",
&GooseFEM::Element::Quad4::QuadratureAxisymmetric::dV,
"Integration point volume (qscalar)")
- .def(
- "GradN_vector",
+ .def("GradN_vector",
py::overload_cast<const xt::xtensor<double, 3>&>(
&GooseFEM::Element::Quad4::QuadratureAxisymmetric::GradN_vector, py::const_),
"Dyadic product, returns 'qtensor'",
py::arg("elemvec"))
- .def(
- "GradN_vector_T",
+ .def("GradN_vector_T",
py::overload_cast<const xt::xtensor<double, 3>&>(
&GooseFEM::Element::Quad4::QuadratureAxisymmetric::GradN_vector_T, py::const_),
"Dyadic product, returns 'qtensor'",
py::arg("elemvec"))
- .def(
- "SymGradN_vector",
+ .def("SymGradN_vector",
py::overload_cast<const xt::xtensor<double, 3>&>(
&GooseFEM::Element::Quad4::QuadratureAxisymmetric::SymGradN_vector, py::const_),
"Dyadic product, returns 'qtensor'",
py::arg("elemvec"))
- .def(
- "Int_N_scalar_NT_dV",
+ .def("Int_N_scalar_NT_dV",
py::overload_cast<const xt::xtensor<double, 2>&>(
&GooseFEM::Element::Quad4::QuadratureAxisymmetric::Int_N_scalar_NT_dV, py::const_),
"Integration, returns 'elemmat'",
py::arg("qscalar"))
- .def(
- "Int_gradN_dot_tensor2_dV",
+ .def("Int_gradN_dot_tensor2_dV",
py::overload_cast<const xt::xtensor<double, 4>&>(
&GooseFEM::Element::Quad4::QuadratureAxisymmetric::Int_gradN_dot_tensor2_dV,
py::const_),
"Integration, returns 'elemvec'",
py::arg("qtensor"))
- .def(
- "Int_gradN_dot_tensor4_dot_gradNT_dV",
+ .def("Int_gradN_dot_tensor4_dot_gradNT_dV",
py::overload_cast<const xt::xtensor<double, 6>&>(
- &GooseFEM::Element::Quad4::QuadratureAxisymmetric::
- Int_gradN_dot_tensor4_dot_gradNT_dV,
+ &GooseFEM::Element::Quad4::QuadratureAxisymmetric::Int_gradN_dot_tensor4_dot_gradNT_dV,
py::const_),
"Integration, returns 'elemvec'",
py::arg("qtensor"))
- .def(
- "AsTensor",
+ // Derived from QuadratureBase
+
+ .def("nelem", &GooseFEM::Element::Quad4::QuadratureAxisymmetric::nelem, "Number of elements")
+
+ .def("nne", &GooseFEM::Element::Quad4::QuadratureAxisymmetric::nne, "Number of nodes per element")
+
+ .def("ndim", &GooseFEM::Element::Quad4::QuadratureAxisymmetric::ndim, "Number of dimensions")
+
+ .def("nip", &GooseFEM::Element::Quad4::QuadratureAxisymmetric::nip, "Number of integration points")
+
+ .def("AsTensor",
(xt::xarray<double>(GooseFEM::Element::Quad4::QuadratureAxisymmetric::*)(
size_t, const xt::xtensor<double, 2>&) const)
&GooseFEM::Element::Quad4::QuadratureAxisymmetric::AsTensor<double>,
"Convert 'qscalar' to 'qtensor' of certain rank")
- .def(
- "AllocateQtensor",
- (xt::xarray<double>(GooseFEM::Element::Quad4::QuadratureAxisymmetric::*)(
- size_t) const)
+ .def("AllocateQtensor",
+ (xt::xarray<double>(GooseFEM::Element::Quad4::QuadratureAxisymmetric::*)(size_t) const)
&GooseFEM::Element::Quad4::QuadratureAxisymmetric::AllocateQtensor<double>,
"Allocate 'qtensor'",
py::arg("rank"))
- .def(
- "AllocateQtensor",
- (xt::xarray<double>(GooseFEM::Element::Quad4::QuadratureAxisymmetric::*)(
- size_t, double) const)
+ .def("AllocateQtensor",
+ (xt::xarray<double>(GooseFEM::Element::Quad4::QuadratureAxisymmetric::*)(size_t, double) const)
&GooseFEM::Element::Quad4::QuadratureAxisymmetric::AllocateQtensor<double>,
"Allocate 'qtensor'",
py::arg("rank"),
py::arg("val"))
- .def(
- "AllocateQscalar",
+ .def("AllocateQscalar",
py::overload_cast<>(
&GooseFEM::Element::Quad4::QuadratureAxisymmetric::AllocateQscalar<double>, py::const_),
"Allocate 'qscalar'")
- .def(
- "AllocateQscalar",
+ .def("AllocateQscalar",
py::overload_cast<double>(
&GooseFEM::Element::Quad4::QuadratureAxisymmetric::AllocateQscalar<double>, py::const_),
"Allocate 'qscalar'",
py::arg("val"))
.def("__repr__", [](const GooseFEM::Element::Quad4::QuadratureAxisymmetric&) {
return "<GooseFEM.Element.Quad4.QuadratureAxisymmetric>";
});
}
diff --git a/python/ElementQuad4Planar.hpp b/python/ElementQuad4Planar.hpp
index 268cb1e..3f79802 100644
--- a/python/ElementQuad4Planar.hpp
+++ b/python/ElementQuad4Planar.hpp
@@ -1,132 +1,117 @@
/* =================================================================================================
(c - GPLv3) T.W.J. de Geus (Tom) | tom@geus.me | www.geus.me | github.com/tdegeus/GooseFEM
================================================================================================= */
#include <GooseFEM/GooseFEM.h>
#include <pybind11/pybind11.h>
#include <pyxtensor/pyxtensor.hpp>
namespace py = pybind11;
void init_ElementQuad4Planar(py::module& m)
{
py::class_<GooseFEM::Element::Quad4::QuadraturePlanar>(m, "QuadraturePlanar")
.def(py::init<const xt::xtensor<double, 3>&>(), "QuadraturePlanar", py::arg("x"))
- .def(
- py::init<
+ .def(py::init<
const xt::xtensor<double, 3>&,
const xt::xtensor<double, 2>&,
const xt::xtensor<double, 1>&>(),
"QuadraturePlanar",
py::arg("x"),
py::arg("xi"),
py::arg("w"))
- .def(
- "update_x",
+ .def("update_x",
&GooseFEM::Element::Quad4::QuadraturePlanar::update_x,
"Update the nodal positions")
- .def("nelem", &GooseFEM::Element::Quad4::QuadraturePlanar::nelem, "Number of elements")
-
- .def("nne", &GooseFEM::Element::Quad4::QuadraturePlanar::nne, "Number of nodes per element")
-
- .def("ndim", &GooseFEM::Element::Quad4::QuadraturePlanar::ndim, "Number of dimensions")
-
- .def(
- "nip", &GooseFEM::Element::Quad4::QuadraturePlanar::nip, "Number of integration points")
-
- .def(
- "dV",
+ .def("dV",
&GooseFEM::Element::Quad4::QuadraturePlanar::dV,
"Integration point volume (qscalar)")
- .def(
- "GradN_vector",
+ .def("GradN_vector",
py::overload_cast<const xt::xtensor<double, 3>&>(
&GooseFEM::Element::Quad4::QuadraturePlanar::GradN_vector, py::const_),
"Dyadic product, returns 'qtensor'",
py::arg("elemvec"))
- .def(
- "GradN_vector_T",
+ .def("GradN_vector_T",
py::overload_cast<const xt::xtensor<double, 3>&>(
&GooseFEM::Element::Quad4::QuadraturePlanar::GradN_vector_T, py::const_),
"Dyadic product, returns 'qtensor'",
py::arg("elemvec"))
- .def(
- "SymGradN_vector",
+ .def("SymGradN_vector",
py::overload_cast<const xt::xtensor<double, 3>&>(
&GooseFEM::Element::Quad4::QuadraturePlanar::SymGradN_vector, py::const_),
"Dyadic product, returns 'qtensor'",
py::arg("elemvec"))
- .def(
- "Int_N_scalar_NT_dV",
+ .def("Int_N_scalar_NT_dV",
py::overload_cast<const xt::xtensor<double, 2>&>(
&GooseFEM::Element::Quad4::QuadraturePlanar::Int_N_scalar_NT_dV, py::const_),
"Integration, returns 'elemmat'",
py::arg("qscalar"))
- .def(
- "Int_gradN_dot_tensor2_dV",
+ .def("Int_gradN_dot_tensor2_dV",
py::overload_cast<const xt::xtensor<double, 4>&>(
&GooseFEM::Element::Quad4::QuadraturePlanar::Int_gradN_dot_tensor2_dV, py::const_),
"Integration, returns 'elemvec'",
py::arg("qtensor"))
- .def(
- "Int_gradN_dot_tensor4_dot_gradNT_dV",
+ .def("Int_gradN_dot_tensor4_dot_gradNT_dV",
py::overload_cast<const xt::xtensor<double, 6>&>(
&GooseFEM::Element::Quad4::QuadraturePlanar::Int_gradN_dot_tensor4_dot_gradNT_dV,
py::const_),
"Integration, returns 'elemvec'",
py::arg("qtensor"))
- .def(
- "AsTensor",
+ // Derived from QuadratureBase
+
+ .def("nelem", &GooseFEM::Element::Quad4::QuadraturePlanar::nelem, "Number of elements")
+
+ .def("nne", &GooseFEM::Element::Quad4::QuadraturePlanar::nne, "Number of nodes per element")
+
+ .def("ndim", &GooseFEM::Element::Quad4::QuadraturePlanar::ndim, "Number of dimensions")
+
+ .def("nip", &GooseFEM::Element::Quad4::QuadraturePlanar::nip, "Number of integration points")
+
+ .def("AsTensor",
(xt::xarray<double>(GooseFEM::Element::Quad4::QuadraturePlanar::*)(
size_t, const xt::xtensor<double, 2>&) const)
&GooseFEM::Element::Quad4::QuadraturePlanar::AsTensor<double>,
"Convert 'qscalar' to 'qtensor' of certain rank")
- .def(
- "AllocateQtensor",
- (xt::xarray<double>(GooseFEM::Element::Quad4::QuadraturePlanar::*)(
- size_t) const)
+ .def("AllocateQtensor",
+ (xt::xarray<double>(GooseFEM::Element::Quad4::QuadraturePlanar::*)(size_t) const)
&GooseFEM::Element::Quad4::QuadraturePlanar::AllocateQtensor<double>,
"Allocate 'qtensor'",
py::arg("rank"))
- .def(
- "AllocateQtensor",
- (xt::xarray<double>(GooseFEM::Element::Quad4::QuadraturePlanar::*)(
- size_t, double) const)
+ .def("AllocateQtensor",
+ (xt::xarray<double>(GooseFEM::Element::Quad4::QuadraturePlanar::*)(size_t, double) const)
&GooseFEM::Element::Quad4::QuadraturePlanar::AllocateQtensor<double>,
"Allocate 'qtensor'",
py::arg("rank"),
py::arg("val"))
- .def(
- "AllocateQscalar",
+ .def("AllocateQscalar",
py::overload_cast<>(
&GooseFEM::Element::Quad4::QuadraturePlanar::AllocateQscalar<double>, py::const_),
"Allocate 'qscalar'")
- .def(
- "AllocateQscalar",
+ .def("AllocateQscalar",
py::overload_cast<double>(
&GooseFEM::Element::Quad4::QuadraturePlanar::AllocateQscalar<double>, py::const_),
"Allocate 'qscalar'",
py::arg("val"))
.def("__repr__", [](const GooseFEM::Element::Quad4::QuadraturePlanar&) {
return "<GooseFEM.Element.Quad4.QuadraturePlanar>";
});
}