[cig-commits] r14357 - in short/3D/PyLith/branches/pylith-swig/modulesrc: bc feassemble materials
brad at geodynamics.org
brad at geodynamics.org
Mon Mar 16 16:22:25 PDT 2009
Author: brad
Date: 2009-03-16 16:22:25 -0700 (Mon, 16 Mar 2009)
New Revision: 14357
Removed:
short/3D/PyLith/branches/pylith-swig/modulesrc/bc/bc.pyxe.src
short/3D/PyLith/branches/pylith-swig/modulesrc/feassemble/feassemble.pyxe.src
short/3D/PyLith/branches/pylith-swig/modulesrc/materials/materials.pyxe.src
Log:
Removed old module files.
Deleted: short/3D/PyLith/branches/pylith-swig/modulesrc/bc/bc.pyxe.src
===================================================================
--- short/3D/PyLith/branches/pylith-swig/modulesrc/bc/bc.pyxe.src 2009-03-16 23:17:30 UTC (rev 14356)
+++ short/3D/PyLith/branches/pylith-swig/modulesrc/bc/bc.pyxe.src 2009-03-16 23:22:25 UTC (rev 14357)
@@ -1,1763 +0,0 @@
-# -*- Pyrex -*-
-#
-# ======================================================================
-#
-# Brad T. Aagaard
-# U.S. Geological Survey
-#
-# {LicenseText}
-#
-# ======================================================================
-#
-
-#header{
-#include "pylith/bc/BoundaryCondition.hh"
-#include "pylith/bc/AbsorbingDampers.hh"
-#include "pylith/bc/DirichletPoints.hh"
-#include "pylith/bc/DirichletBoundary.hh"
-#include "pylith/bc/Neumann.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 BoundaryCondition_destructor(void* obj):
- """
- Destroy BoundaryCondition object.
- """
- # create shim for destructor
- #embed{ void BoundaryCondition_destructor_cpp(void* objVptr)
- pylith::bc::BoundaryCondition* pM = (pylith::bc::BoundaryCondition*) objVptr;
- delete pM;
- #}embed
- BoundaryCondition_destructor_cpp(obj)
- return
-
-
-cdef class BoundaryCondition:
-
- 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_bc_BoundaryCondition"
- return
-
-
- def verifyConfiguration(self, mesh):
- """
- Verify compatibility of configuration settings.
- """
- # create shim for method 'verifyConfiguration'
- #embed{ void BoundaryCondition_verifyConfiguration(void* objVptr, void* meshVptr)
- try {
- assert(0 != objVptr);
- assert(0 != meshVptr);
- ALE::Obj<pylith::Mesh>* mesh = (ALE::Obj<pylith::Mesh>*) meshVptr;
- ((pylith::bc::BoundaryCondition*) objVptr)->verifyConfiguration(*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 not mesh.name == "pylith_topology_Mesh":
- raise TypeError, \
- "Argument must be extension module type " \
- "'pylith::topology::Mesh'."
- BoundaryCondition_verifyConfiguration(self.thisptr, ptrFromHandle(mesh))
- return
-
-
- def initialize(self, mesh, cs, upDir):
- """
- Initialize boundary condition.
- """
- # create shim for method 'initialize'
- #embed{ void BoundaryCondition_initialize(void* objVptr, void* meshVptr, void* csVptr, double* upDirPtr)
- try {
- assert(0 != objVptr);
- assert(0 != meshVptr);
- assert(0 != csVptr);
- ALE::Obj<pylith::Mesh>* mesh = (ALE::Obj<pylith::Mesh>*) meshVptr;
- spatialdata::geocoords::CoordSys* cs =
- (spatialdata::geocoords::CoordSys*) csVptr;
- pylith::double_array upDir(3);
- upDir[0] = upDirPtr[0];
- upDir[1] = upDirPtr[1];
- upDir[2] = upDirPtr[2];
- ((pylith::bc::BoundaryCondition*) objVptr)->initialize(*mesh, cs, upDir);
- } 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 must be extension module type " \
- "'pylith::topology::Mesh'."
- if not cs.name == "spatialdata_geocoords_CoordSys":
- raise TypeError, \
- "Argument must be extension module type " \
- "'spatialdata::geocoords::CoordSys'."
- if 3 != len(upDir):
- raise TypeError, \
- "Argument 'upDir' must be a 3 vector (list)."
- cdef double upDirCpp[3]
- upDirCpp[0] = upDir[0]
- upDirCpp[1] = upDir[1]
- upDirCpp[2] = upDir[2]
- BoundaryCondition_initialize(self.thisptr, ptrFromHandle(mesh), ptrFromHandle(cs), upDirCpp)
- return
-
-
- def _createHandle(self):
- """
- Wrap pointer to C++ object in PyCObject.
- """
- return PyCObject_FromVoidPtr(self.thisptr, BoundaryCondition_destructor)
-
-
- property label:
- def __set__(self, value):
- """
- Set label of material.
- """
- # create shim for method 'label'
- #embed{ void BoundaryCondition_label_set(void* objVptr, char* value)
- try {
- assert(0 != objVptr);
- ((pylith::bc::BoundaryCondition*) 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
- BoundaryCondition_label_set(self.thisptr, value)
-
-
- property db:
- def __set__(self, value):
- """
- Set spatial database for parameters.
- """
- # create shim for method 'db'
- #embed{ void BoundaryCondition_db_set(void* objVptr, void* dbVptr)
- try {
- assert(0 != objVptr);
- assert(0 != dbVptr);
- spatialdata::spatialdb::SpatialDB* db =
- (spatialdata::spatialdb::SpatialDB*) dbVptr;
- ((pylith::bc::BoundaryCondition*) objVptr)->db(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'."
- BoundaryCondition_db_set(self.thisptr, ptrFromHandle(value))
-
-
-# ----------------------------------------------------------------------
-cdef class DirichletPoints(BoundaryCondition):
-
- def __init__(self):
- """
- Constructor.
- """
- # create shim for constructor
- #embed{ void* DirichletPoints_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::bc::DirichletPoints);
- 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
-
- BoundaryCondition.__init__(self)
- self.thisptr = DirichletPoints_constructor()
- self.handle = self._createHandle()
- return
-
-
- property referenceTime:
- def __set__(self, value):
- """
- Set reference time for rate of change of values.
- """
- # create shim for method 'referenceTime'
- #embed{ void DirichletPoints_referenceTime_set(void* objVptr, double value)
- try {
- assert(0 != objVptr);
- ((pylith::bc::DirichletPoints*) objVptr)->referenceTime(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
- DirichletPoints_referenceTime_set(self.thisptr, value)
-
-
- property dbRate:
- def __set__(self, value):
- """
- Set spatial database for parameters of rate of change of values.
- """
- # create shim for method 'dbRate'
- #embed{ void DirichletPoints_dbRate_set(void* objVptr, void* dbVptr)
- try {
- assert(0 != objVptr);
- assert(0 != dbVptr);
- spatialdata::spatialdb::SpatialDB* db =
- (spatialdata::spatialdb::SpatialDB*) dbVptr;
- ((pylith::bc::DirichletPoints*) objVptr)->dbRate(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'."
- DirichletPoints_dbRate_set(self.thisptr, ptrFromHandle(value))
-
-
- property fixedDOF:
- def __set__(self, value):
- """
- Set fixed DOF.
- """
- # create shim for method 'fixedDOF'
- #embed{ void DirichletPoints_fixedDOF_set(void* objVptr, int* dofVptr, int numFixedDOF)
- try {
- assert(0 != objVptr);
- assert(0 != dofVptr);
- pylith::int_array fixedDOF((int*) dofVptr, numFixedDOF);
- ((pylith::bc::DirichletPoints*) objVptr)->fixedDOF(fixedDOF);
- } 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
- cdef int* fixedDOF
- numFixedDOF = len(value)
- fixedDOF = <int*> malloc(numFixedDOF*sizeof(int))
- assert(fixedDOF != NULL)
- for i from 0 <= i < numFixedDOF:
- fixedDOF[i] = value[i]
- DirichletPoints_fixedDOF_set(self.thisptr, fixedDOF, numFixedDOF)
- free(fixedDOF)
-
-
- property normalizer:
- def __set__(self, value):
- """
- Set nondimensionalizer.
- """
- # create shim for method 'normalizer'
- #embed{ void DirichletPoints_normalizer_set(void* objVptr, void* dimVptr)
- try {
- assert(0 != objVptr);
- assert(0 != dimVptr);
- spatialdata::units::Nondimensional* dim =
- (spatialdata::units::Nondimensional*) dimVptr;
- ((pylith::bc::DirichletPoints*) objVptr)->normalizer(*dim);
- } 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_units_Nondimensional":
- raise TypeError, \
- "Argument must be extension module type " \
- "'spatialdata::units::Nondimensional'."
- DirichletPoints_normalizer_set(self.thisptr, ptrFromHandle(value))
-
-
- def setConstraintSizes(self, field, mesh):
- """
- Set number of degrees of freedom that are constrained at points in field.
- """
- # create shim for method 'setConstraintSizes'
- #embed{ void DirichletPoints_setConstraintSizes(void* objVptr, 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<pylith::Mesh>* mesh = (ALE::Obj<pylith::Mesh>*) meshVptr;
- ((pylith::bc::DirichletPoints*) objVptr)->setConstraintSizes(*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 not mesh.name == "pylith_topology_Mesh":
- raise TypeError, \
- "Argument must be extension module type " \
- "'pylith::topology::Mesh'."
- DirichletPoints_setConstraintSizes(self.thisptr, PyCObject_AsVoidPtr(field),
- ptrFromHandle(mesh))
- return
-
-
- def setConstraints(self, field, mesh):
- """
- Set which degrees of freedom that are constrained at points in field.
- """
- # create shim for method 'setConstraints'
- #embed{ void DirichletPoints_setConstraints(void* objVptr, 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<pylith::Mesh>* mesh = (ALE::Obj<pylith::Mesh>*) meshVptr;
- ((pylith::bc::DirichletPoints*) objVptr)->setConstraints(*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 not mesh.name == "pylith_topology_Mesh":
- raise TypeError, \
- "Argument must be extension module type " \
- "'pylith::topology::Mesh'."
- DirichletPoints_setConstraints(self.thisptr, PyCObject_AsVoidPtr(field), ptrFromHandle(mesh))
- return
-
-
- def setField(self, t, field, mesh):
- """
- Set values in field.
- """
- # create shim for method 'setField'
- #embed{ void DirichletPoints_setField(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<pylith::Mesh>* mesh = (ALE::Obj<pylith::Mesh>*) meshVptr;
- ((pylith::bc::DirichletPoints*) objVptr)->setField(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 not mesh.name == "pylith_topology_Mesh":
- raise TypeError, \
- "Argument must be extension module type " \
- "'pylith::topology::Mesh'."
- DirichletPoints_setField(self.thisptr, t, PyCObject_AsVoidPtr(field),
- ptrFromHandle(mesh))
- return
-
-
- property useSolnIncr:
- def __set__(self, flag):
- """
- Set solution increment flag.
- """
- # create shim for method 'useSolnIncr'
- #embed{ void DirichletPoints_useSolnIncr_set(void* objVptr, int flag)
- try {
- assert(0 != objVptr);
- ((pylith::bc::DirichletPoints*) 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
- DirichletPoints_useSolnIncr_set(self.thisptr, flag)
-
-
-# ----------------------------------------------------------------------
-cdef class DirichletBoundary(BoundaryCondition):
-
- def __init__(self):
- """
- Constructor.
- """
- # create shim for constructor
- #embed{ void* DirichletBoundary_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::bc::DirichletBoundary);
- 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
-
- BoundaryCondition.__init__(self)
- self.thisptr = DirichletBoundary_constructor()
- self.handle = self._createHandle()
- return
-
-
- property referenceTime:
- def __set__(self, value):
- """
- Set reference time for rate of change of values.
- """
- # create shim for method 'referenceTime'
- #embed{ void DirichletBoundary_referenceTime_set(void* objVptr, double value)
- try {
- assert(0 != objVptr);
- ((pylith::bc::DirichletBoundary*) objVptr)->referenceTime(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
- DirichletBoundary_referenceTime_set(self.thisptr, value)
-
-
- property dbRate:
- def __set__(self, value):
- """
- Set spatial database for parameters of rate of change of values.
- """
- # create shim for method 'dbRate'
- #embed{ void DirichletBoundary_dbRate_set(void* objVptr, void* dbVptr)
- try {
- assert(0 != objVptr);
- assert(0 != dbVptr);
- spatialdata::spatialdb::SpatialDB* db =
- (spatialdata::spatialdb::SpatialDB*) dbVptr;
- ((pylith::bc::DirichletBoundary*) objVptr)->dbRate(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'."
- DirichletBoundary_dbRate_set(self.thisptr, ptrFromHandle(value))
-
-
- property fixedDOF:
- def __set__(self, value):
- """
- Set fixed DOF.
- """
- # create shim for method 'fixedDOF'
- #embed{ void DirichletBoundary_fixedDOF_set(void* objVptr, int* dofVptr, int numFixedDOF)
- try {
- assert(0 != objVptr);
- assert(0 != dofVptr);
- pylith::int_array fixedDOF((int*) dofVptr, numFixedDOF);
- ((pylith::bc::DirichletBoundary*) objVptr)->fixedDOF(fixedDOF);
- } 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
- cdef int* fixedDOF
- numFixedDOF = len(value)
- fixedDOF = <int*> malloc(numFixedDOF*sizeof(int))
- assert(fixedDOF != NULL)
- for i from 0 <= i < numFixedDOF:
- fixedDOF[i] = value[i]
- DirichletBoundary_fixedDOF_set(self.thisptr, fixedDOF, numFixedDOF)
- free(fixedDOF)
-
-
- property normalizer:
- def __set__(self, value):
- """
- Set nondimensionalizer.
- """
- # create shim for method 'normalizer'
- #embed{ void DirichletBoundary_normalizer_set(void* objVptr, void* dimVptr)
- try {
- assert(0 != objVptr);
- assert(0 != dimVptr);
- spatialdata::units::Nondimensional* dim =
- (spatialdata::units::Nondimensional*) dimVptr;
- ((pylith::bc::DirichletBoundary*) objVptr)->normalizer(*dim);
- } 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_units_Nondimensional":
- raise TypeError, \
- "Argument must be extension module type " \
- "'spatialdata::units::Nondimensional'."
- DirichletBoundary_normalizer_set(self.thisptr, ptrFromHandle(value))
-
-
- def setConstraintSizes(self, field, mesh):
- """
- Set number of degrees of freedom that are constrained at points in field.
- """
- # create shim for method 'setConstraintSizes'
- #embed{ void DirichletBoundary_setConstraintSizes(void* objVptr, 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<pylith::Mesh>* mesh = (ALE::Obj<pylith::Mesh>*) meshVptr;
- ((pylith::bc::DirichletBoundary*) objVptr)->setConstraintSizes(*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 not mesh.name == "pylith_topology_Mesh":
- raise TypeError, \
- "Argument must be extension module type " \
- "'pylith::topology::Mesh'."
- DirichletBoundary_setConstraintSizes(self.thisptr, PyCObject_AsVoidPtr(field),
- ptrFromHandle(mesh))
- return
-
-
- def setConstraints(self, field, mesh):
- """
- Set which degrees of freedom that are constrained at points in field.
- """
- # create shim for method 'setConstraints'
- #embed{ void DirichletBoundary_setConstraints(void* objVptr, 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<pylith::Mesh>* mesh = (ALE::Obj<pylith::Mesh>*) meshVptr;
- ((pylith::bc::DirichletBoundary*) objVptr)->setConstraints(*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 not mesh.name == "pylith_topology_Mesh":
- raise TypeError, \
- "Argument must be extension module type " \
- "'pylith::topology::Mesh'."
- DirichletBoundary_setConstraints(self.thisptr, PyCObject_AsVoidPtr(field), ptrFromHandle(mesh))
- return
-
-
- def setField(self, t, field, mesh):
- """
- Set values in field.
- """
- # create shim for method 'setField'
- #embed{ void DirichletBoundary_setField(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<pylith::Mesh>* mesh = (ALE::Obj<pylith::Mesh>*) meshVptr;
- ((pylith::bc::DirichletBoundary*) objVptr)->setField(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 not mesh.name == "pylith_topology_Mesh":
- raise TypeError, \
- "Argument must be extension module type " \
- "'pylith::topology::Mesh'."
- DirichletBoundary_setField(self.thisptr, t, PyCObject_AsVoidPtr(field),
- ptrFromHandle(mesh))
- return
-
-
- def boundaryMesh(self, mesh):
- """
- Get mesh associated with fields over boundary.
- """
- # create shim for method 'boundaryMesh'
- #embed{ void DirichletBoundary_boundaryMesh(void* objVptr, void* meshVptr)
- try {
- assert(0 != objVptr);
- assert(0 != meshVptr);
- ALE::Obj<pylith::SubMesh>* mesh = (ALE::Obj<pylith::SubMesh>*) meshVptr;
- *mesh = ((pylith::bc::DirichletBoundary*) objVptr)->boundaryMesh();
- } 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'."
- DirichletBoundary_boundaryMesh(self.thisptr, ptrFromHandle(mesh))
- return
-
-
- def vertexField(self, name, mesh, fields=None):
- """
- Get cell field.
- """
- # create shim for method 'vertexField'
- #embed{ void* DirichletBoundary_vertexField(void* objVptr, int* fieldPtr, char* name, void* meshVptr, void* fieldsVptr)
- void* result = 0;
- try {
- assert(0 != objVptr);
- assert(0 != fieldPtr);
- assert(0 != name);
- assert(0 != meshVptr);
- pylith::bc::DirichletBoundary* bc = (pylith::bc::DirichletBoundary*) objVptr;
- ALE::Obj<pylith::Mesh>* mesh = (ALE::Obj<pylith::Mesh>*) meshVptr;
- pylith::topology::FieldsManager* fields =
- (pylith::topology::FieldsManager*) fieldsVptr;
- pylith::VectorFieldEnum fieldType;
- const ALE::Obj<pylith::real_section_type>& field =
- bc->vertexField(&fieldType, name, *mesh, fields);
- *fieldPtr = fieldType;
- result = (void*) &field;
- } 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
- if not mesh.name == "pylith_topology_Mesh":
- raise TypeError, \
- "Argument 'mesh' must be extension module type " \
- "'pylith::topology::Mesh'."
- if None != fields:
- if not fields.name == "pylith_topology_FieldsManager":
- raise TypeError, \
- "Argument 'fields' must be extension module type " \
- "'pylith::topology::FieldsManager'."
- cdef void* ptr
- cdef int fieldType
- if None != fields:
- ptr = DirichletBoundary_vertexField(self.thisptr, &fieldType, name,
- ptrFromHandle(mesh), ptrFromHandle(fields))
- else:
- ptr = DirichletBoundary_vertexField(self.thisptr, &fieldType, name,
- ptrFromHandle(mesh), NULL)
- return (PyCObject_FromVoidPtr(ptr, NULL), fieldType)
-
-
- property useSolnIncr:
- def __set__(self, flag):
- """
- Set solution increment flag.
- """
- # create shim for method 'useSolnIncr'
- #embed{ void DirichletBoundary_useSolnIncr_set(void* objVptr, int flag)
- try {
- assert(0 != objVptr);
- ((pylith::bc::DirichletBoundary*) 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
- DirichletBoundary_useSolnIncr_set(self.thisptr, flag)
-
-
-# ----------------------------------------------------------------------
-cdef class AbsorbingDampers(BoundaryCondition):
-
- def __init__(self):
- """
- Constructor.
- """
- # create shim for constructor
- #embed{ void* AbsorbingDampers_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::bc::AbsorbingDampers);
- 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
- BoundaryCondition.__init__(self)
- self.thisptr = AbsorbingDampers_constructor()
- self.handle = self._createHandle()
- return
-
-
- def integrateResidual(self, residual, t, fields, mesh, cs):
- """
- Integrate contributions to residual term (r) for operator.
- """
- # create shim for method 'integrateResidual'
- #embed{ void AbsorbingDampers_integrateResidual(void* objVptr, void* residualVptr, double t, void* fieldsVptr, void* meshVptr, void* csVptr)
- try {
- assert(0 != objVptr);
- assert(0 != residualVptr);
- assert(0 != fieldsVptr);
- assert(0 != meshVptr);
- assert(0 != csVptr);
- ALE::Obj<pylith::Mesh>* mesh =
- (ALE::Obj<pylith::Mesh>*) meshVptr;
- ALE::Obj<pylith::real_section_type>* residual =
- (ALE::Obj<pylith::real_section_type>*) residualVptr;
- pylith::topology::FieldsManager* fields =
- (pylith::topology::FieldsManager*) fieldsVptr;
- spatialdata::geocoords::CoordSys* cs =
- (spatialdata::geocoords::CoordSys*) csVptr;
- ((pylith::bc::AbsorbingDampers*) objVptr)->integrateResidual(*residual,
- t, fields, *mesh, cs);
- } 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'."
- AbsorbingDampers_integrateResidual(self.thisptr,
- PyCObject_AsVoidPtr(residual),
- t,
- ptrFromHandle(fields),
- ptrFromHandle(mesh),
- ptrFromHandle(cs))
- return
-
-
- def integrateJacobian(self, mat, t, fields, mesh):
- """
- Compute contributions to Jacobian matrix (A) associated with operator.
- """
- # create shim for method 'integrateJacobian'
- #embed{ void AbsorbingDampers_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<pylith::Mesh>* mesh =
- (ALE::Obj<pylith::Mesh>*) meshVptr;
- PetscMat* mat = (PetscMat*) matVptr;
- pylith::topology::FieldsManager* fields =
- (pylith::topology::FieldsManager*) fieldsVptr;
- ((pylith::bc::AbsorbingDampers*) 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'."
- AbsorbingDampers_integrateJacobian(self.thisptr,
- PyCObject_AsVoidPtr(mat),
- t,
- ptrFromHandle(fields),
- ptrFromHandle(mesh))
- return
-
-
- def integrateResidualAssembled(self, residual, t, fields, mesh, cs):
- """
- Integrate contributions to residual term (r) for operator that do
- not require assembly over cells, vertices, or processors.
- """
- # create shim for method 'integrateResidualAssembled'
- #embed{ void AbsorbingDampers_integrateResidualAssembled(void* objVptr, void* residualVptr, double t, void* fieldsVptr, void* meshVptr, void* csVptr)
- try {
- assert(0 != objVptr);
- assert(0 != residualVptr);
- assert(0 != fieldsVptr);
- assert(0 != meshVptr);
- assert(0 != csVptr);
- ALE::Obj<pylith::Mesh>* mesh =
- (ALE::Obj<pylith::Mesh>*) meshVptr;
- ALE::Obj<pylith::real_section_type>* residual =
- (ALE::Obj<pylith::real_section_type>*) residualVptr;
- pylith::topology::FieldsManager* fields =
- (pylith::topology::FieldsManager*) fieldsVptr;
- spatialdata::geocoords::CoordSys* cs =
- (spatialdata::geocoords::CoordSys*) csVptr;
- ((pylith::bc::AbsorbingDampers*) objVptr)->integrateResidualAssembled(*residual,
- t, fields, *mesh, cs);
- } 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'."
- AbsorbingDampers_integrateResidualAssembled(self.thisptr,
- PyCObject_AsVoidPtr(residual),
- t,
- ptrFromHandle(fields),
- ptrFromHandle(mesh),
- ptrFromHandle(cs))
- return
-
-
- def integrateJacobianAssembled(self, mat, t, fields, mesh):
- """
- Compute contributions to Jacobian matrix (A) associated with
- operator that do not require assembly over cells, vertices, or
- processors.
- """
- # create shim for method 'integrateJacobianAssembled'
- #embed{ void AbsorbingDampers_integrateJacobianAssembled(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<pylith::Mesh>* mesh =
- (ALE::Obj<pylith::Mesh>*) meshVptr;
- PetscMat* mat = (PetscMat*) matVptr;
- pylith::topology::FieldsManager* fields =
- (pylith::topology::FieldsManager*) fieldsVptr;
- ((pylith::bc::AbsorbingDampers*) objVptr)->integrateJacobianAssembled(
- 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'."
- AbsorbingDampers_integrateJacobianAssembled(self.thisptr,
- PyCObject_AsVoidPtr(mat),
- t,
- ptrFromHandle(fields),
- ptrFromHandle(mesh))
- return
-
-
- def updateState(self, t, fields, mesh):
- """
- Update state variables as needed.
- """
- # create shim for method 'updateState'
- #embed{ void AbsorbingDampers_updateState(void* objVptr, double t, void* fieldsVptr, void* meshVptr)
- try {
- assert(0 != objVptr);
- assert(0 != fieldsVptr);
- assert(0 != meshVptr);
- pylith::topology::FieldsManager* fields =
- (pylith::topology::FieldsManager*) fieldsVptr;
- ALE::Obj<pylith::Mesh>* mesh =
- (ALE::Obj<pylith::Mesh>*) meshVptr;
- ((pylith::bc::AbsorbingDampers*) objVptr)->updateState(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 fields.name != "pylith_topology_FieldsManager":
- raise TypeError, \
- "Argument 'fields' must be extension module type 'FieldsManager'."
- if mesh.name != "pylith_topology_Mesh":
- raise TypeError, \
- "Argument 'mesh' must be extension module type 'Mesh'."
- AbsorbingDampers_updateState(self.thisptr,
- t,
- ptrFromHandle(fields),
- ptrFromHandle(mesh))
- return
-
-
- def _createHandle(self):
- """
- Wrap pointer to C++ object in PyCObject.
- """
- return PyCObject_FromVoidPtr(self.thisptr, BoundaryCondition_destructor)
-
-
- property quadrature:
- def __set__(self, q):
- """
- Set quadrature.
- """
- # create shim for method 'quadrature'
- #embed{ void AbsorbingDampers_quadrature_set(void* objVptr, void* qVptr)
- try {
- assert(0 != objVptr);
- pylith::feassemble::Quadrature* quadrature =
- (pylith::feassemble::Quadrature*) qVptr;
- ((pylith::bc::AbsorbingDampers*) 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'."
- AbsorbingDampers_quadrature_set(self.thisptr, ptrFromHandle(q))
-
-
- property normalizer:
- def __set__(self, value):
- """
- Set nondimensionalizer.
- """
- # create shim for method 'normalizer'
- #embed{ void AbsorbingDampers_normalizer_set(void* objVptr, void* dimVptr)
- try {
- assert(0 != objVptr);
- assert(0 != dimVptr);
- spatialdata::units::Nondimensional* dim =
- (spatialdata::units::Nondimensional*) dimVptr;
- ((pylith::bc::AbsorbingDampers*) objVptr)->normalizer(*dim);
- } 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_units_Nondimensional":
- raise TypeError, \
- "Argument must be extension module type " \
- "'spatialdata::units::Nondimensional'."
- AbsorbingDampers_normalizer_set(self.thisptr, ptrFromHandle(value))
-
-
- property timeStep:
- def __set__(self, dt):
- """
- Set timeStep.
- """
- # create shim for method 'timeStep'
- #embed{ void AbsorbingDampers_timeStep_set(void* objVptr, double dt)
- try {
- assert(0 != objVptr);
- ((pylith::bc::AbsorbingDampers*) 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
- AbsorbingDampers_timeStep_set(self.thisptr, dt)
-
-
- property stableTimeStep:
- def __get__(self):
- """
- Get stable time step.
- """
- # create shim for method 'stableTimeStep'
- #embed{ double AbsorbingDampers_stableTimeStep_get(void* objVptr)
- double result = 0.0;
- try {
- assert(0 != objVptr);
- result =
- ((pylith::bc::AbsorbingDampers*) 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 AbsorbingDampers_stableTimeStep_get(self.thisptr)
-
-
- property needNewJacobian:
- def __get__(self):
- """
- Set timeStep.
- """
- # create shim for method 'needNewJacobian'
- #embed{ int AbsorbingDampers_needNewJacobian_get(void* objVptr)
- int result = 0;
- try {
- assert(0 != objVptr);
- result =
- ((pylith::bc::AbsorbingDampers*) 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 AbsorbingDampers_needNewJacobian_get(self.thisptr)
-
-
- property useSolnIncr:
- def __set__(self, flag):
- """
- Set solution increment flag.
- """
- # create shim for method 'useSolnIncr'
- #embed{ void AbsorbingDampers_useSolnIncr_set(void* objVptr, int flag)
- try {
- assert(0 != objVptr);
- ((pylith::bc::AbsorbingDampers*) 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
- AbsorbingDampers_useSolnIncr_set(self.thisptr, flag)
-
-
-# ----------------------------------------------------------------------
-cdef class Neumann(BoundaryCondition):
-
- def __init__(self):
- """
- Constructor.
- """
- # create shim for constructor
- #embed{ void* Neumann_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::bc::Neumann);
- 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
- BoundaryCondition.__init__(self)
- self.thisptr = Neumann_constructor()
- self.handle = self._createHandle()
- return
-
-
- BoundaryCondition.__init__(self)
- self.thisptr = Neumann_constructor()
- self.handle = self._createHandle()
-
-
- def integrateResidual(self, residual, t, fields, mesh, cs):
- """
- Integrate contributions to residual term (r) for operator.
- """
- # create shim for method 'integrateResidual'
- #embed{ void Neumann_integrateResidual(void* objVptr, void* residualVptr, double t, void* fieldsVptr, void* meshVptr, void* csVptr)
- try {
- assert(0 != objVptr);
- assert(0 != residualVptr);
- assert(0 != fieldsVptr);
- assert(0 != meshVptr);
- assert(0 != csVptr);
- ALE::Obj<pylith::Mesh>* mesh =
- (ALE::Obj<pylith::Mesh>*) meshVptr;
- ALE::Obj<pylith::real_section_type>* residual =
- (ALE::Obj<pylith::real_section_type>*) residualVptr;
- pylith::topology::FieldsManager* fields =
- (pylith::topology::FieldsManager*) fieldsVptr;
- spatialdata::geocoords::CoordSys* cs =
- (spatialdata::geocoords::CoordSys*) csVptr;
- ((pylith::bc::Neumann*) objVptr)->integrateResidual(*residual,
- t, fields, *mesh, cs);
- } 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'."
- Neumann_integrateResidual(self.thisptr,
- PyCObject_AsVoidPtr(residual),
- t,
- ptrFromHandle(fields),
- ptrFromHandle(mesh),
- ptrFromHandle(cs))
- return
-
-
- def integrateJacobian(self, mat, t, fields, mesh):
- """
- Compute contributions to Jacobian matrix (A) associated with operator.
- """
- # create shim for method 'integrateJacobian'
- #embed{ void Neumann_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<pylith::Mesh>* mesh =
- (ALE::Obj<pylith::Mesh>*) meshVptr;
- PetscMat* mat = (PetscMat*) matVptr;
- pylith::topology::FieldsManager* fields =
- (pylith::topology::FieldsManager*) fieldsVptr;
- ((pylith::bc::Neumann*) 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'."
- Neumann_integrateJacobian(self.thisptr,
- PyCObject_AsVoidPtr(mat),
- t,
- ptrFromHandle(fields),
- ptrFromHandle(mesh))
- return
-
-
- def integrateResidualAssembled(self, residual, t, fields, mesh, cs):
- """
- Integrate contributions to residual term (r) for operator that do
- not require assembly over cells, vertices, or processors.
- """
- # create shim for method 'integrateResidualAssembled'
- #embed{ void Neumann_integrateResidualAssembled(void* objVptr, void* residualVptr, double t, void* fieldsVptr, void* meshVptr, void* csVptr)
- try {
- assert(0 != objVptr);
- assert(0 != residualVptr);
- assert(0 != fieldsVptr);
- assert(0 != meshVptr);
- assert(0 != csVptr);
- ALE::Obj<pylith::Mesh>* mesh =
- (ALE::Obj<pylith::Mesh>*) meshVptr;
- ALE::Obj<pylith::real_section_type>* residual =
- (ALE::Obj<pylith::real_section_type>*) residualVptr;
- pylith::topology::FieldsManager* fields =
- (pylith::topology::FieldsManager*) fieldsVptr;
- spatialdata::geocoords::CoordSys* cs =
- (spatialdata::geocoords::CoordSys*) csVptr;
- ((pylith::bc::Neumann*) objVptr)->integrateResidualAssembled(*residual,
- t, fields, *mesh, cs);
- } 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'."
- Neumann_integrateResidualAssembled(self.thisptr,
- PyCObject_AsVoidPtr(residual),
- t,
- ptrFromHandle(fields),
- ptrFromHandle(mesh),
- ptrFromHandle(cs))
- return
-
-
- def integrateJacobianAssembled(self, mat, t, fields, mesh):
- """
- Compute contributions to Jacobian matrix (A) associated with
- operator that do not require assembly over cells, vertices, or
- processors.
- """
- # create shim for method 'integrateJacobianAssembled'
- #embed{ void Neumann_integrateJacobianAssembled(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<pylith::Mesh>* mesh =
- (ALE::Obj<pylith::Mesh>*) meshVptr;
- PetscMat* mat = (PetscMat*) matVptr;
- pylith::topology::FieldsManager* fields =
- (pylith::topology::FieldsManager*) fieldsVptr;
- ((pylith::bc::Neumann*) objVptr)->integrateJacobianAssembled(
- 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'."
- Neumann_integrateJacobianAssembled(self.thisptr,
- PyCObject_AsVoidPtr(mat),
- t,
- ptrFromHandle(fields),
- ptrFromHandle(mesh))
- return
-
-
- def updateState(self, t, fields, mesh):
- """
- Update state variables as needed.
- """
- # create shim for method 'updateState'
- #embed{ void Neumann_updateState(void* objVptr, double t, void* fieldsVptr, void* meshVptr)
- try {
- assert(0 != objVptr);
- assert(0 != fieldsVptr);
- assert(0 != meshVptr);
- pylith::topology::FieldsManager* fields =
- (pylith::topology::FieldsManager*) fieldsVptr;
- ALE::Obj<pylith::Mesh>* mesh =
- (ALE::Obj<pylith::Mesh>*) meshVptr;
- ((pylith::bc::Neumann*) objVptr)->updateState(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 fields.name != "pylith_topology_FieldsManager":
- raise TypeError, \
- "Argument 'fields' must be extension module type 'FieldsManager'."
- if mesh.name != "pylith_topology_Mesh":
- raise TypeError, \
- "Argument 'mesh' must be extension module type 'Mesh'."
- Neumann_updateState(self.thisptr,
- t,
- ptrFromHandle(fields),
- ptrFromHandle(mesh))
- return
-
-
- def boundaryMesh(self, mesh):
- """
- Get mesh associated with fields over boundary.
- """
- # create shim for method 'boundaryMesh'
- #embed{ void Neumann_boundaryMesh(void* objVptr, void* meshVptr)
- try {
- assert(0 != objVptr);
- assert(0 != meshVptr);
- ALE::Obj<pylith::SubMesh>* mesh = (ALE::Obj<pylith::SubMesh>*) meshVptr;
- *mesh = ((pylith::bc::Neumann*) objVptr)->boundaryMesh();
- } 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'."
- Neumann_boundaryMesh(self.thisptr, ptrFromHandle(mesh))
- return
-
-
- def cellField(self, name, mesh, fields=None):
- """
- Get cell field.
- """
- # create shim for method 'cellField'
- #embed{ void* Neumann_cellField(void* objVptr, int* fieldPtr, char* name, void* meshVptr, void* fieldsVptr)
- void* result = 0;
- try {
- assert(0 != objVptr);
- assert(0 != fieldPtr);
- assert(0 != name);
- assert(0 != meshVptr);
- pylith::bc::Neumann* bc = (pylith::bc::Neumann*) objVptr;
- ALE::Obj<pylith::Mesh>* mesh = (ALE::Obj<pylith::Mesh>*) meshVptr;
- pylith::topology::FieldsManager* fields =
- (pylith::topology::FieldsManager*) fieldsVptr;
- pylith::VectorFieldEnum fieldType;
- const ALE::Obj<pylith::real_section_type>& field =
- bc->cellField(&fieldType, name, *mesh, fields);
- *fieldPtr = fieldType;
- result = (void*) &field;
- } 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
- if not mesh.name == "pylith_topology_Mesh":
- raise TypeError, \
- "Argument 'mesh' must be extension module type " \
- "'pylith::topology::Mesh'."
- if None != fields:
- if not fields.name == "pylith_topology_FieldsManager":
- raise TypeError, \
- "Argument 'fields' must be extension module type " \
- "'pylith::topology::FieldsManager'."
- cdef void* ptr
- cdef int fieldType
- if None != fields:
- ptr = Neumann_cellField(self.thisptr, &fieldType, name,
- ptrFromHandle(mesh), ptrFromHandle(fields))
- else:
- ptr = Neumann_cellField(self.thisptr, &fieldType, name,
- ptrFromHandle(mesh), NULL)
- return (PyCObject_FromVoidPtr(ptr, NULL), fieldType)
-
-
- def _createHandle(self):
- """
- Wrap pointer to C++ object in PyCObject.
- """
- return PyCObject_FromVoidPtr(self.thisptr, BoundaryCondition_destructor)
-
-
- property quadrature:
- def __set__(self, q):
- """
- Set quadrature.
- """
- # create shim for method 'quadrature'
- #embed{ void Neumann_quadrature_set(void* objVptr, void* qVptr)
- try {
- assert(0 != objVptr);
- pylith::feassemble::Quadrature* quadrature =
- (pylith::feassemble::Quadrature*) qVptr;
- ((pylith::bc::Neumann*) 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'."
- Neumann_quadrature_set(self.thisptr, ptrFromHandle(q))
-
-
- property normalizer:
- def __set__(self, value):
- """
- Set nondimensionalizer.
- """
- # create shim for method 'normalizer'
- #embed{ void Neumann_normalizer_set(void* objVptr, void* dimVptr)
- try {
- assert(0 != objVptr);
- assert(0 != dimVptr);
- spatialdata::units::Nondimensional* dim =
- (spatialdata::units::Nondimensional*) dimVptr;
- ((pylith::bc::Neumann*) objVptr)->normalizer(*dim);
- } 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_units_Nondimensional":
- raise TypeError, \
- "Argument must be extension module type " \
- "'spatialdata::units::Nondimensional'."
- Neumann_normalizer_set(self.thisptr, ptrFromHandle(value))
-
-
- property timeStep:
- def __set__(self, dt):
- """
- Set timeStep.
- """
- # create shim for method 'timeStep'
- #embed{ void Neumann_timeStep_set(void* objVptr, double dt)
- try {
- assert(0 != objVptr);
- ((pylith::bc::Neumann*) 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
- Neumann_timeStep_set(self.thisptr, dt)
-
-
- property stableTimeStep:
- def __get__(self):
- """
- Get stable time step.
- """
- # create shim for method 'stableTimeStep'
- #embed{ double Neumann_stableTimeStep_get(void* objVptr)
- double result = 0.0;
- try {
- assert(0 != objVptr);
- result =
- ((pylith::bc::Neumann*) 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 Neumann_stableTimeStep_get(self.thisptr)
-
-
- property needNewJacobian:
- def __get__(self):
- """
- Set timeStep.
- """
- # create shim for method 'needNewJacobian'
- #embed{ int Neumann_needNewJacobian_get(void* objVptr)
- int result = 0;
- try {
- assert(0 != objVptr);
- result =
- ((pylith::bc::Neumann*) 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 Neumann_needNewJacobian_get(self.thisptr)
-
-
- property useSolnIncr:
- def __set__(self, flag):
- """
- Set solution increment flag.
- """
- # create shim for method 'useSolnIncr'
- #embed{ void Neumann_useSolnIncr_set(void* objVptr, int flag)
- try {
- assert(0 != objVptr);
- ((pylith::bc::Neumann*) 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
- Neumann_useSolnIncr_set(self.thisptr, flag)
-
-
-# End of file
-
Deleted: short/3D/PyLith/branches/pylith-swig/modulesrc/feassemble/feassemble.pyxe.src
===================================================================
--- short/3D/PyLith/branches/pylith-swig/modulesrc/feassemble/feassemble.pyxe.src 2009-03-16 23:17:30 UTC (rev 14356)
+++ short/3D/PyLith/branches/pylith-swig/modulesrc/feassemble/feassemble.pyxe.src 2009-03-16 23:22:25 UTC (rev 14357)
@@ -1,1776 +0,0 @@
-# -*- Pyrex -*-
-#
-# ======================================================================
-#
-# Brad T. Aagaard
-# U.S. Geological Survey
-#
-# {LicenseText}
-#
-# ======================================================================
-#
-
-#header{
-#include "pylith/feassemble/CellGeometry.hh"
-#include "pylith/feassemble/GeometryPoint1D.hh"
-#include "pylith/feassemble/GeometryPoint2D.hh"
-#include "pylith/feassemble/GeometryPoint3D.hh"
-#include "pylith/feassemble/GeometryLine1D.hh"
-#include "pylith/feassemble/GeometryLine2D.hh"
-#include "pylith/feassemble/GeometryLine3D.hh"
-#include "pylith/feassemble/GeometryTri2D.hh"
-#include "pylith/feassemble/GeometryTri3D.hh"
-#include "pylith/feassemble/GeometryQuad2D.hh"
-#include "pylith/feassemble/GeometryQuad3D.hh"
-#include "pylith/feassemble/GeometryTet3D.hh"
-#include "pylith/feassemble/GeometryHex3D.hh"
-
-#include "pylith/feassemble/Quadrature.hh"
-#include "pylith/feassemble/Quadrature0D.hh"
-#include "pylith/feassemble/Quadrature1D.hh"
-#include "pylith/feassemble/Quadrature1Din2D.hh"
-#include "pylith/feassemble/Quadrature1Din3D.hh"
-#include "pylith/feassemble/Quadrature2D.hh"
-#include "pylith/feassemble/Quadrature2Din3D.hh"
-#include "pylith/feassemble/Quadrature3D.hh"
-
-#include "pylith/feassemble/Integrator.hh"
-#include "pylith/feassemble/IntegratorElasticity.hh"
-#include "pylith/feassemble/ElasticityExplicit.hh"
-#include "pylith/feassemble/ElasticityImplicit.hh"
-
-#include "pylith/feassemble/Constraint.hh"
-
-#include "pylith/utils/petscfwd.h"
-
-#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 CellGeometry_destructor(void* obj):
- """
- Destroy CellGeometry object.
- """
- # create shim for destructor
- #embed{ void CellGeometry_destructor_cpp(void* objVptr)
- pylith::feassemble::CellGeometry* pQ =
- (pylith::feassemble::CellGeometry*) objVptr;
- delete pQ;
- #}embed
- CellGeometry_destructor_cpp(obj)
- return
-
-cdef class CellGeometry:
-
- 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_feassemble_CellGeometry"
- return
-
-
- def _createHandle(self):
- """Wrap pointer to C++ object in PyCObject."""
- return PyCObject_FromVoidPtr(self.thisptr, CellGeometry_destructor)
-
-
-# ----------------------------------------------------------------------
-cdef class GeometryPoint1D(CellGeometry):
-
- def __init__(self):
- """Constructor."""
- # create shim for constructor
- #embed{ void* GeometryPoint1D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::GeometryPoint1D);
- 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
-
- CellGeometry.__init__(self)
- self.thisptr = GeometryPoint1D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class GeometryPoint2D(CellGeometry):
-
- def __init__(self):
- """Constructor."""
- # create shim for constructor
- #embed{ void* GeometryPoint2D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::GeometryPoint2D);
- 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
-
- CellGeometry.__init__(self)
- self.thisptr = GeometryPoint2D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class GeometryPoint3D(CellGeometry):
-
- def __init__(self):
- """Constructor."""
- # create shim for constructor
- #embed{ void* GeometryPoint3D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::GeometryPoint3D);
- 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
-
- CellGeometry.__init__(self)
- self.thisptr = GeometryPoint3D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class GeometryLine1D(CellGeometry):
-
- def __init__(self):
- """Constructor."""
- # create shim for constructor
- #embed{ void* GeometryLine1D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::GeometryLine1D);
- 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
-
- CellGeometry.__init__(self)
- self.thisptr = GeometryLine1D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class GeometryLine2D(CellGeometry):
-
- def __init__(self):
- """Constructor."""
- # create shim for constructor
- #embed{ void* GeometryLine2D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::GeometryLine2D);
- 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
-
- CellGeometry.__init__(self)
- self.thisptr = GeometryLine2D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class GeometryLine3D(CellGeometry):
-
- def __init__(self):
- """Constructor."""
- # create shim for constructor
- #embed{ void* GeometryLine3D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::GeometryLine3D);
- 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
-
- CellGeometry.__init__(self)
- self.thisptr = GeometryLine3D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class GeometryTri2D(CellGeometry):
-
- def __init__(self):
- """Constructor."""
- # create shim for constructor
- #embed{ void* GeometryTri2D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::GeometryTri2D);
- 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
-
- CellGeometry.__init__(self)
- self.thisptr = GeometryTri2D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class GeometryTri3D(CellGeometry):
-
- def __init__(self):
- """Constructor."""
- # create shim for constructor
- #embed{ void* GeometryTri3D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::GeometryTri3D);
- 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
-
- CellGeometry.__init__(self)
- self.thisptr = GeometryTri3D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class GeometryQuad2D(CellGeometry):
-
- def __init__(self):
- """Constructor."""
- # create shim for constructor
- #embed{ void* GeometryQuad2D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::GeometryQuad2D);
- 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
-
- CellGeometry.__init__(self)
- self.thisptr = GeometryQuad2D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class GeometryQuad3D(CellGeometry):
-
- def __init__(self):
- """Constructor."""
- # create shim for constructor
- #embed{ void* GeometryQuad3D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::GeometryQuad3D);
- 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
-
- CellGeometry.__init__(self)
- self.thisptr = GeometryQuad3D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class GeometryTet3D(CellGeometry):
-
- def __init__(self):
- """Constructor."""
- # create shim for constructor
- #embed{ void* GeometryTet3D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::GeometryTet3D);
- 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
-
- CellGeometry.__init__(self)
- self.thisptr = GeometryTet3D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class GeometryHex3D(CellGeometry):
-
- def __init__(self):
- """Constructor."""
- # create shim for constructor
- #embed{ void* GeometryHex3D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::GeometryHex3D);
- 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
-
- CellGeometry.__init__(self)
- self.thisptr = GeometryHex3D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef void Quadrature_destructor(void* obj):
- """
- Destroy Quadrature object.
- """
- # create shim for destructor
- #embed{ void Quadrature_destructor_cpp(void* objVptr)
- pylith::feassemble::Quadrature* pQ =
- (pylith::feassemble::Quadrature*) objVptr;
- delete pQ;
- #}embed
- Quadrature_destructor_cpp(obj)
- return
-
-cdef class Quadrature:
-
- 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_feassemble_Quadrature"
- return
-
-
- def initialize(self,
- basis, basisDeriv,
- quadPts, quadWts,
- cellDim, numBasis, numQuadPts, spaceDim):
- """
- Set basis functions and their derivatives, and coordinates and
- weights of quadrature points.
-
- @param basis Basis functions evaluated at the quadrature points
- @param basisDeriv Basis function derivatives evaluated at quad pts
- @param quadPts Coordinates of quadrature points in reference cell
- @param quadWts Weights of quadrature points
- @param cellDim Dimension of reference cell
- @param numBasis Number of basis functions
- @param numQuadPts Number of quadrature points
- @param spaceDim Number of dimensions associated with cell vertices
- """
- # create shim for method 'initialize'
- #embed{ void Quadrature_initialize(void* objVptr, double* basis, double* basisDeriv, double* quadPts, double* quadWts, int cellDim, int numBasis, int numQuadPts, int spaceDim)
- try {
- ((pylith::feassemble::Quadrature*) objVptr)->initialize(
- basis, basisDeriv,
- quadPts, quadWts,
- cellDim, numBasis,
- numQuadPts, spaceDim);
- } 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
-
- import spatialdata.utils.simplearray
-
- # basis
- basis = spatialdata.utils.simplearray.objAsSimpleArray(basis)
- if not basis.isCompatible(nd=2, simpletype="double",
- contiguous=True, notswapped=True):
- raise TypeError, \
- "Argument 'basis' must be a contiguous, 2-D array " \
- "of type double."
- if numQuadPts != basis.shape[0] or numBasis != basis.shape[1]:
- raise TypeError, \
- "Shape of argument 'basis' must be (numQuadPts, numBasis)."
-
- # basisDeriv
- basisDeriv = spatialdata.utils.simplearray.objAsSimpleArray(basisDeriv)
- if not basisDeriv.isCompatible(nd=3, simpletype="double",
- contiguous=True, notswapped=True):
- raise TypeError, \
- "Argument 'basisDeriv' must be a contiguous, 3-D array " \
- "of type double."
- if cellDim > 0:
- if numQuadPts != basisDeriv.shape[0] or \
- numBasis != basisDeriv.shape[1] or \
- cellDim != basisDeriv.shape[2]:
- raise TypeError, \
- "Shape of argument 'basisDeriv' must be (numQuadPts, " \
- "numBasis, cellDim)."
- else:
- if 1 != basisDeriv.shape[0] or \
- 1 != basisDeriv.shape[1] or \
- 1 != basisDeriv.shape[2]:
- raise TypeError, \
- "Shape of argument 'basisDeriv' must be (1, 1, 1) for 0-D cell."
-
- # quadPts
- quadPts = spatialdata.utils.simplearray.objAsSimpleArray(quadPts)
- if not quadPts.isCompatible(nd=2, simpletype="double",
- contiguous=True, notswapped=True):
- raise TypeError, \
- "Argument 'quadPts' must be a contiguous, 2-D array " \
- "of type double."
- if cellDim > 0:
- if numQuadPts != quadPts.shape[0] or cellDim != quadPts.shape[1]:
- raise TypeError, \
- "Shape of argument 'quadPts' must be (numQuadPts, cellDim)."
- else:
- if 1 != quadPts.shape[0] or 1 != quadPts.shape[1]:
- raise TypeError, \
- "Shape of argument 'quadPts' must be (1, 1) for 0-D cell."
-
- # quadWts
- quadWts = spatialdata.utils.simplearray.objAsSimpleArray(quadWts)
- if not quadWts.isCompatible(nd=1, simpletype="double",
- contiguous=True, notswapped=True):
- raise TypeError, \
- "Argument 'quadWts' must be a contiguous, 1-D array " \
- "of type double."
- if numQuadPts != quadWts.shape[0]:
- raise TypeError, \
- "Shape of argument 'quadWts' must be (numQuadPts)."
-
- cdef double* basisCpp
- cdef double* basisDerivCpp
- cdef double* quadPtsCpp
- cdef double* quadWtsCpp
- basisCpp = <double*> PyCObject_AsVoidPtr(basis.data)
- basisDerivCpp = <double*> PyCObject_AsVoidPtr(basisDeriv.data)
- quadPtsCpp = <double*> PyCObject_AsVoidPtr(quadPts.data)
- quadWtsCpp = <double*> PyCObject_AsVoidPtr(quadWts.data)
-
- Quadrature_initialize(self.thisptr,
- basisCpp, basisDerivCpp,
- quadPtsCpp, quadWtsCpp,
- cellDim, numBasis,
- numQuadPts, spaceDim)
- return
-
-
- def _createHandle(self):
- """Wrap pointer to C++ object in PyCObject."""
- return PyCObject_FromVoidPtr(self.thisptr, Quadrature_destructor)
-
-
- property minJacobian:
- def __set__(self, value):
- """Set minimum allowable Jacobian."""
- # create shim for method 'minJacobian'
- #embed{ void Quadrature_minJacobian_set(void* objVptr, double value)
- try {
- assert(0 != objVptr);
- ((pylith::feassemble::Quadrature*) objVptr)->minJacobian(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
- Quadrature_minJacobian_set(self.thisptr, value)
-
- def __get__(self):
- """Get minimum allowable Jacobian."""
- # create shim for method 'minJacobian'
- #embed{ double Quadrature_minJacobian_get(void* objVptr)
- double result = 0;
- try {
- assert(0 != objVptr);
- result = ((pylith::feassemble::Quadrature*) objVptr)->minJacobian();
- } 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 Quadrature_minJacobian_get(self.thisptr)
-
-
- property checkConditioning:
- def __set__(self, flag):
- """Set minimum allowable Jacobian."""
- # create shim for method 'checkConditioning'
- #embed{ void Quadrature_checkConditioning_set(void* objVptr, int flag)
- try {
- assert(0 != objVptr);
- ((pylith::feassemble::Quadrature*) objVptr)->checkConditioning(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
- Quadrature_checkConditioning_set(self.thisptr, flag)
-
- def __get__(self):
- """Get minimum allowable Jacobian."""
- # create shim for method 'checkConditioning'
- #embed{ int Quadrature_checkConditioning_get(void* objVptr)
- int result = 0;
- try {
- assert(0 != objVptr);
- result = ((pylith::feassemble::Quadrature*) objVptr)->checkConditioning();
- } 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 Quadrature_checkConditioning_get(self.thisptr)
-
-
- property refGeometry:
- def __set__(self, value):
- """
- Set geometry associated with reference cell.
- """
- # create shim for method 'refGeometry'
- #embed{ void Quadrature_refGeometry_set(void* objVptr, void* geomVptr)
- try {
- assert(0 != objVptr);
- assert(0 != geomVptr);
- pylith::feassemble::CellGeometry* geom =
- (pylith::feassemble::CellGeometry*) geomVptr;
- ((pylith::feassemble::Quadrature*) objVptr)->refGeometry(geom);
- } 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_feassemble_CellGeometry":
- raise TypeError, \
- "Argument must be extension module type " \
- "'pylith::feassemble::CellGeometry'."
- Quadrature_refGeometry_set(self.thisptr, ptrFromHandle(value))
-
-
-# ----------------------------------------------------------------------
-cdef class Quadrature0D(Quadrature):
-
- def __init__(self):
- """Constructor."""
- # create shim for constructor
- #embed{ void* Quadrature0D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::Quadrature0D);
- 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
-
- Quadrature.__init__(self)
- self.thisptr = Quadrature0D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class Quadrature1D(Quadrature):
-
- def __init__(self):
- """Constructor."""
- # create shim for constructor
- #embed{ void* Quadrature1D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::Quadrature1D);
- 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
-
- Quadrature.__init__(self)
- self.thisptr = Quadrature1D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class Quadrature1Din2D(Quadrature):
-
- def __init__(self):
- """Constructor."""
- # create shim for constructor
- #embed{ void* Quadrature1Din2D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::Quadrature1Din2D);
- 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
-
- Quadrature.__init__(self)
- self.thisptr = Quadrature1Din2D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class Quadrature1Din3D(Quadrature):
-
- def __init__(self):
- """Constructor."""
- # create shim for constructor
- #embed{ void* Quadrature1Din3D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::Quadrature1Din3D);
- 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
-
- Quadrature.__init__(self)
- self.thisptr = Quadrature1Din3D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class Quadrature2D(Quadrature):
-
- def __init__(self):
- """Constructor."""
- # create shim for constructor
- #embed{ void* Quadrature2D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::Quadrature2D);
- 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
-
- Quadrature.__init__(self)
- self.thisptr = Quadrature2D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class Quadrature2Din3D(Quadrature):
-
- def __init__(self):
- """Constructor."""
- # create shim for constructor
- #embed{ void* Quadrature2Din3D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::Quadrature2Din3D);
- 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
-
- Quadrature.__init__(self)
- self.thisptr = Quadrature2Din3D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class Quadrature3D(Quadrature):
-
- def __init__(self):
- """Constructor."""
- # create shim for constructor
- #embed{ void* Quadrature3D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::Quadrature3D);
- 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
-
- Quadrature.__init__(self)
- self.thisptr = Quadrature3D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef void Integrator_destructor(void* obj):
- """
- Destroy Integrator object.
- """
- # create shim for destructor
- #embed{ void Integrator_destructor_cpp(void* objVptr)
- pylith::feassemble::Integrator* pQ =
- (pylith::feassemble::Integrator*) objVptr;
- delete pQ;
- #}embed
- Integrator_destructor_cpp(obj)
- return
-
-
-cdef class Integrator:
-
- 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_feassemble_integrator"
- return
-
-
- def integrateResidual(self, residual, t, fields, mesh, cs):
- """
- Integrate contributions to residual term (r) for operator.
- """
- # create shim for method 'integrateResidual'
- #embed{ void Integrator_integrateResidual(void* objVptr, void* residualVptr, double t, void* fieldsVptr, void* meshVptr, void* csVptr)
- try {
- assert(0 != objVptr);
- assert(0 != residualVptr);
- assert(0 != fieldsVptr);
- assert(0 != meshVptr);
- assert(0 != csVptr);
- ALE::Obj<pylith::Mesh>* mesh =
- (ALE::Obj<pylith::Mesh>*) meshVptr;
- ALE::Obj<pylith::real_section_type>* residual =
- (ALE::Obj<pylith::real_section_type>*) residualVptr;
- pylith::topology::FieldsManager* fields =
- (pylith::topology::FieldsManager*) fieldsVptr;
- spatialdata::geocoords::CoordSys* cs =
- (spatialdata::geocoords::CoordSys*) csVptr;
- ((pylith::feassemble::Integrator*) objVptr)->integrateResidual(*residual,
- t, fields, *mesh,
- cs);
- } 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'."
- Integrator_integrateResidual(self.thisptr,
- PyCObject_AsVoidPtr(residual),
- t,
- ptrFromHandle(fields),
- ptrFromHandle(mesh),
- ptrFromHandle(cs))
- return
-
-
- def integrateJacobian(self, mat, t, fields, mesh):
- """
- Compute contributions to Jacobian matrix (A) associated with operator.
- """
- # create shim for method 'integrateJacobian'
- #embed{ void Integrator_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<pylith::Mesh>* mesh =
- (ALE::Obj<pylith::Mesh>*) meshVptr;
- PetscMat* mat = (PetscMat*) matVptr;
- pylith::topology::FieldsManager* fields =
- (pylith::topology::FieldsManager*) fieldsVptr;
- ((pylith::feassemble::Integrator*) 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 fields.name != "pylith_topology_FieldsManager":
- raise TypeError, \
- "Argument 'fields' must be extension module type 'FieldsManager'."
- if mesh.name != "pylith_topology_Mesh":
- raise TypeError, \
- "Argument 'mesh' must be extension module type 'Mesh'."
- Integrator_integrateJacobian(self.thisptr,
- PyCObject_AsVoidPtr(mat),
- t,
- ptrFromHandle(fields),
- ptrFromHandle(mesh))
- return
-
-
- def integrateResidualAssembled(self, residual, t, fields, mesh, cs):
- """
- Integrate contributions to residual term (r) for operator that do
- not require assembly over cells, vertices, or processors.
- """
- # create shim for method 'integrateResidualAssembled'
- #embed{ void Integrator_integrateResidualAssembled(void* objVptr, void* residualVptr, double t, void* fieldsVptr, void* meshVptr, void* csVptr)
- try {
- assert(0 != objVptr);
- assert(0 != residualVptr);
- assert(0 != fieldsVptr);
- assert(0 != meshVptr);
- assert(0 != csVptr);
- ALE::Obj<pylith::Mesh>* mesh =
- (ALE::Obj<pylith::Mesh>*) meshVptr;
- ALE::Obj<pylith::real_section_type>* residual =
- (ALE::Obj<pylith::real_section_type>*) residualVptr;
- pylith::topology::FieldsManager* fields =
- (pylith::topology::FieldsManager*) fieldsVptr;
- spatialdata::geocoords::CoordSys* cs =
- (spatialdata::geocoords::CoordSys*) csVptr;
- ((pylith::feassemble::Integrator*) objVptr)->integrateResidualAssembled(*residual,
- t, fields, *mesh,
- cs);
- } 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'."
- Integrator_integrateResidualAssembled(self.thisptr,
- PyCObject_AsVoidPtr(residual),
- t,
- ptrFromHandle(fields),
- ptrFromHandle(mesh),
- ptrFromHandle(cs))
- return
-
-
- def integrateJacobianAssembled(self, mat, t, fields, mesh):
- """
- Compute contributions to Jacobian matrix (A) associated with
- operator that do not require assembly over cells, vertices, or
- processors.
- """
- # create shim for method 'integrateJacobianAssembled'
- #embed{ void Integrator_integrateJacobianAssembled(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<pylith::Mesh>* mesh =
- (ALE::Obj<pylith::Mesh>*) meshVptr;
- PetscMat* mat = (PetscMat*) matVptr;
- pylith::topology::FieldsManager* fields =
- (pylith::topology::FieldsManager*) fieldsVptr;
- ((pylith::feassemble::Integrator*) objVptr)->integrateJacobianAssembled(
- 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 fields.name != "pylith_topology_FieldsManager":
- raise TypeError, \
- "Argument 'fields' must be extension module type 'FieldsManager'."
- if mesh.name != "pylith_topology_Mesh":
- raise TypeError, \
- "Argument 'mesh' must be extension module type 'Mesh'."
- Integrator_integrateJacobianAssembled(self.thisptr,
- PyCObject_AsVoidPtr(mat),
- t,
- ptrFromHandle(fields),
- ptrFromHandle(mesh))
- return
-
-
- def updateState(self, t, fields, mesh):
- """
- Update state variables as needed.
- """
- # create shim for method 'updateState'
- #embed{ void Integrator_updateState(void* objVptr, double t, void* fieldsVptr, void* meshVptr)
- try {
- assert(0 != objVptr);
- assert(0 != fieldsVptr);
- assert(0 != meshVptr);
- pylith::topology::FieldsManager* fields =
- (pylith::topology::FieldsManager*) fieldsVptr;
- ALE::Obj<pylith::Mesh>* mesh =
- (ALE::Obj<pylith::Mesh>*) meshVptr;
- ((pylith::feassemble::Integrator*) objVptr)->updateState(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 fields.name != "pylith_topology_FieldsManager":
- raise TypeError, \
- "Argument 'fields' must be extension module type 'FieldsManager'."
- if mesh.name != "pylith_topology_Mesh":
- raise TypeError, \
- "Argument 'mesh' must be extension module type 'Mesh'."
- Integrator_updateState(self.thisptr,
- t,
- ptrFromHandle(fields),
- ptrFromHandle(mesh))
- return
-
-
- def verifyConfiguration(self, mesh):
- """
- Verify compatibility of configuration settings.
- """
- # create shim for method 'verifyConfiguration'
- #embed{ void Integrator_verifyConfiguration(void* objVptr, void* meshVptr)
- try {
- assert(0 != objVptr);
- assert(0 != meshVptr);
- ALE::Obj<pylith::Mesh>* mesh =
- (ALE::Obj<pylith::Mesh>*) meshVptr;
- ((pylith::feassemble::Integrator*) objVptr)->verifyConfiguration(*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'."
- Integrator_verifyConfiguration(self.thisptr,
- ptrFromHandle(mesh))
- return
-
-
- def _createHandle(self):
- """
- Wrap pointer to C++ object in PyCObject.
- """
- return PyCObject_FromVoidPtr(self.thisptr, Integrator_destructor)
-
-
- property quadrature:
- def __set__(self, q):
- """
- Set quadrature.
- """
- # create shim for method 'quadrature'
- #embed{ void Integrator_quadrature_set(void* objVptr, void* qVptr)
- try {
- assert(0 != objVptr);
- assert(0 != qVptr);
- pylith::feassemble::Quadrature* quadrature =
- (pylith::feassemble::Quadrature*) qVptr;
- ((pylith::feassemble::Integrator*) 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'."
- Integrator_quadrature_set(self.thisptr, ptrFromHandle(q))
-
-
- property normalizer:
- def __set__(self, value):
- """
- Set nondimensionalizer.
- """
- # create shim for method 'normalizer'
- #embed{ void Integrator_normalizer_set(void* objVptr, void* dimVptr)
- try {
- assert(0 != objVptr);
- assert(0 != dimVptr);
- spatialdata::units::Nondimensional* dim =
- (spatialdata::units::Nondimensional*) dimVptr;
- ((pylith::feassemble::Integrator*) objVptr)->normalizer(*dim);
- } 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_units_Nondimensional":
- raise TypeError, \
- "Argument must be extension module type " \
- "'spatialdata::units::Nondimensional'."
- Integrator_normalizer_set(self.thisptr, ptrFromHandle(value))
-
-
- property gravityField:
- def __set__(self, g):
- """
- Set gravity field.
- """
- # create shim for method 'gravityField'
- #embed{ void Integrator_gravityField_set(void* objVptr, void* gVptr)
- try {
- assert(0 != objVptr);
- spatialdata::spatialdb::GravityField* gravityField =
- (spatialdata::spatialdb::GravityField*) gVptr;
- ((pylith::feassemble::Integrator*) objVptr)->gravityField(gravityField);
- } 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 g.name == "spatialdata_spatialdb_SpatialDB":
- raise TypeError, \
- "Argument must be extension module type 'SpatialDB'."
- if None == g:
- Integrator_gravityField_set(self.thisptr, NULL)
- else:
- Integrator_gravityField_set(self.thisptr, ptrFromHandle(g))
-
-
- property timeStep:
- def __set__(self, dt):
- """
- Set timeStep.
- """
- # create shim for method 'timeStep'
- #embed{ void Integrator_timeStep_set(void* objVptr, double dt)
- try {
- assert(0 != objVptr);
- ((pylith::feassemble::Integrator*) 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
- Integrator_timeStep_set(self.thisptr, dt)
-
-
- property stableTimeStep:
- def __get__(self):
- """
- Get stable time step.
- """
- # create shim for method 'stableTimeStep'
- #embed{ double Integrator_stableTimeStep_get(void* objVptr)
- double result = 0.0;
- try {
- assert(0 != objVptr);
- result =
- ((pylith::feassemble::Integrator*) 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 Integrator_stableTimeStep_get(self.thisptr)
-
-
- property needNewJacobian:
- def __get__(self):
- """
- Set timeStep.
- """
- # create shim for method 'needNewJacobian'
- #embed{ int Integrator_needNewJacobian_get(void* objVptr)
- int result = 0;
- try {
- assert(0 != objVptr);
- result =
- ((pylith::feassemble::Integrator*) 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 Integrator_needNewJacobian_get(self.thisptr)
-
-
- property useSolnIncr:
- def __set__(self, flag):
- """
- Set solution increment flag.
- """
- # create shim for method 'useSolnIncr'
- #embed{ void Integrator_useSolnIncr_set(void* objVptr, int flag)
- try {
- assert(0 != objVptr);
- ((pylith::feassemble::Integrator*) 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
- Integrator_useSolnIncr_set(self.thisptr, flag)
-
-
-# ----------------------------------------------------------------------
-cdef class IntegratorElasticity(Integrator):
-
- def __init__(self):
- """
- Constructor.
- """
- Integrator.__init__(self)
- return
-
-
- def cellField(self, name, mesh, fields=None):
- """
- Get cell field.
- """
- # create shim for method 'cellField'
- #embed{ void* IntegratorElasticity_cellField(void* objVptr, int* fieldPtr, char* name, void* meshVptr, void* fieldsVptr)
- void* result = 0;
- try {
- assert(0 != objVptr);
- assert(0 != fieldPtr);
- assert(0 != name);
- assert(0 != meshVptr);
- pylith::feassemble::IntegratorElasticity* integrator = (pylith::feassemble::IntegratorElasticity*) objVptr;
- ALE::Obj<pylith::Mesh>* mesh = (ALE::Obj<pylith::Mesh>*) meshVptr;
- pylith::topology::FieldsManager* fields =
- (pylith::topology::FieldsManager*) fieldsVptr;
- pylith::VectorFieldEnum fieldType;
- const ALE::Obj<pylith::real_section_type>& field =
- integrator->cellField(&fieldType, name, *mesh, fields);
- *fieldPtr = fieldType;
- result = (void*) &field;
- } 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
- if not mesh.name == "pylith_topology_Mesh":
- raise TypeError, \
- "Argument 'mesh' must be extension module type " \
- "'pylith::topology::Mesh'."
- if None != fields:
- if not fields.name == "pylith_topology_FieldsManager":
- raise TypeError, \
- "Argument 'fields' must be extension module type " \
- "'pylith::topology::FieldsManager'."
- cdef void* ptr
- cdef int fieldType
- fieldType = 3
- if None != fields:
- ptr = IntegratorElasticity_cellField(self.thisptr, &fieldType, name,
- ptrFromHandle(mesh),
- ptrFromHandle(fields))
- else:
- ptr = IntegratorElasticity_cellField(self.thisptr, &fieldType, name,
- ptrFromHandle(mesh), NULL)
- return (PyCObject_FromVoidPtr(ptr, NULL), fieldType)
-
-
- property material:
- def __set__(self, m):
- """
- Set material.
- """
- # create shim for method 'material'
- #embed{ void IntegratorElasticity_material_set(void* objVptr, void* mVptr)
- try {
- assert(0 != objVptr);
- pylith::materials::ElasticMaterial* material =
- (pylith::materials::ElasticMaterial*) mVptr;
- ((pylith::feassemble::IntegratorElasticity*) objVptr)->material(material);
- } 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 m.name == "pylith_materials_ElasticMaterial":
- raise TypeError, \
- "Argument must be extension module type 'ElasticMaterial'."
- IntegratorElasticity_material_set(self.thisptr, ptrFromHandle(m))
-
-
-# ----------------------------------------------------------------------
-cdef class ElasticityExplicit(IntegratorElasticity):
-
- def __init__(self):
- """
- Constructor.
- """
- # create shim for constructor
- #embed{ void* ElasticityExplicit_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::ElasticityExplicit);
- 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
-
- Integrator.__init__(self)
- self.thisptr = ElasticityExplicit_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class ElasticityImplicit(IntegratorElasticity):
-
- def __init__(self):
- """
- Constructor.
- """
- # create shim for constructor
- #embed{ void* ElasticityImplicit_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::feassemble::ElasticityImplicit);
- 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
-
- Integrator.__init__(self)
- self.thisptr = ElasticityImplicit_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef void Constraint_destructor(void* obj):
- """
- Destroy Constraint object.
- """
- # create shim for destructor
- #embed{ void Constraint_destructor_cpp(void* objVptr)
- pylith::feassemble::Constraint* pQ =
- (pylith::feassemble::Constraint*) objVptr;
- delete pQ;
- #}embed
- Constraint_destructor_cpp(obj)
- return
-
-
-cdef class Constraint:
-
- 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_feassemble_constraint"
- return
-
-
- def setConstraintSizes(self, field, mesh):
- """
- Set number of degrees of freedom that are constrained at points in field.
- """
- # create shim for method 'setConstraintSizes'
- #embed{ void Constraint_setConstraintSizes(void* objVptr, 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<pylith::Mesh>* mesh = (ALE::Obj<pylith::Mesh>*) meshVptr;
- ((pylith::feassemble::Constraint*) objVptr)->setConstraintSizes(*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 not mesh.name == "pylith_topology_Mesh":
- raise TypeError, \
- "Argument 'mesh' must be extension module type " \
- "'pylith::topology::Mesh'."
- Constraint_setConstraintSizes(self.thisptr, PyCObject_AsVoidPtr(field),
- ptrFromHandle(mesh))
- return
-
-
- def setConstraints(self, field, mesh):
- """
- Set which degrees of freedom that are constrained at points in field.
- """
- # create shim for method 'setConstraints'
- #embed{ void Constraint_setConstraints(void* objVptr, 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<pylith::Mesh>* mesh = (ALE::Obj<pylith::Mesh>*) meshVptr;
- ((pylith::feassemble::Constraint*) objVptr)->setConstraints(*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 not mesh.name == "pylith_topology_Mesh":
- raise TypeError, \
- "Argument 'mesh' must be extension module type " \
- "'pylith::topology::Mesh'."
- Constraint_setConstraints(self.thisptr, PyCObject_AsVoidPtr(field), ptrFromHandle(mesh))
- return
-
-
- def setField(self, t, field, mesh):
- """
- Set values in field.
- """
- # create shim for method 'setField'
- #embed{ void Constraint_setField(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<pylith::Mesh>* mesh = (ALE::Obj<pylith::Mesh>*) meshVptr;
- ((pylith::feassemble::Constraint*) objVptr)->setField(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 not mesh.name == "pylith_topology_Mesh":
- raise TypeError, \
- "Argument 'mesh' must be extension module type " \
- "'pylith::topology::Mesh'."
- Constraint_setField(self.thisptr, t, PyCObject_AsVoidPtr(field),
- ptrFromHandle(mesh))
- return
-
-
- property normalizer:
- def __set__(self, value):
- """
- Set nondimensionalizer.
- """
- # create shim for method 'normalizer'
- #embed{ void Constraint_normalizer_set(void* objVptr, void* dimVptr)
- try {
- assert(0 != objVptr);
- assert(0 != dimVptr);
- spatialdata::units::Nondimensional* dim =
- (spatialdata::units::Nondimensional*) dimVptr;
- ((pylith::feassemble::Constraint*) objVptr)->normalizer(*dim);
- } 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_units_Nondimensional":
- raise TypeError, \
- "Argument must be extension module type " \
- "'spatialdata::units::Nondimensional'."
- Constraint_normalizer_set(self.thisptr, ptrFromHandle(value))
-
-
- property useSolnIncr:
- def __set__(self, flag):
- """
- Set use solution increment flag.
- """
- # create shim for method 'useSolnIncr'
- #embed{ void Constraint_useSolnIncr_set(void* objVptr, int flag)
- try {
- assert(0 != objVptr);
- ((pylith::feassemble::Constraint*) 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
- Constraint_useSolnIncr_set(self.thisptr, flag)
-
-
- def _createHandle(self):
- """
- Wrap pointer to C++ object in PyCObject.
- """
- return PyCObject_FromVoidPtr(self.thisptr, Constraint_destructor)
-
-
-# End of file
Deleted: short/3D/PyLith/branches/pylith-swig/modulesrc/materials/materials.pyxe.src
===================================================================
--- short/3D/PyLith/branches/pylith-swig/modulesrc/materials/materials.pyxe.src 2009-03-16 23:17:30 UTC (rev 14356)
+++ short/3D/PyLith/branches/pylith-swig/modulesrc/materials/materials.pyxe.src 2009-03-16 23:22:25 UTC (rev 14357)
@@ -1,581 +0,0 @@
-# -*- Pyrex -*-
-#
-# ======================================================================
-#
-# Brad T. Aagaard
-# U.S. Geological Survey
-#
-# {LicenseText}
-#
-# ======================================================================
-#
-
-#header{
-#include "pylith/materials/Material.hh"
-#include "pylith/materials/ElasticMaterial.hh"
-#include "pylith/materials/ElasticStrain1D.hh"
-#include "pylith/materials/ElasticStress1D.hh"
-#include "pylith/materials/ElasticIsotropic3D.hh"
-#include "pylith/materials/ElasticPlaneStrain.hh"
-#include "pylith/materials/ElasticPlaneStress.hh"
-#include "pylith/materials/MaxwellIsotropic3D.hh"
-#include "pylith/materials/GenMaxwellIsotropic3D.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 Material_destructor(void* obj):
- """
- Destroy Material object.
- """
- # create shim for destructor
- #embed{ void Material_destructor_cpp(void* pObj)
- pylith::materials::Material* pM =
- (pylith::materials::Material*) pObj;
- delete pM;
- #}embed
- Material_destructor_cpp(obj)
- return
-
-
-# ----------------------------------------------------------------------
-cdef class Material:
-
- 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_materials_Material"
- return
-
-
- def initialize(self, mesh, cs, quadrature):
- """
- Initialize material by getting physical property parameters from
- database.
- """
- # create shim for method 'initialize'
- #embed{ void Material_initialize(void* objVptr, void* meshVptr, void* csVptr, void* qVptr)
- try {
- assert(0 != objVptr);
- assert(0 != meshVptr);
- assert(0 != csVptr);
- assert(0 != qVptr);
- ALE::Obj<pylith::Mesh>* mesh = (ALE::Obj<pylith::Mesh>*) meshVptr;
- spatialdata::geocoords::CoordSys* cs =
- (spatialdata::geocoords::CoordSys*) csVptr;
- pylith::feassemble::Quadrature* quadrature =
- (pylith::feassemble::Quadrature*) qVptr;
- ((pylith::materials::Material*) objVptr)->initialize(*mesh, cs, 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 mesh.name == "pylith_topology_Mesh":
- raise TypeError, \
- "Argument must be extension module type " \
- "'pylith::topology::Mesh'."
- if not cs.name == "spatialdata_geocoords_CoordSys":
- raise TypeError, \
- "Argument must be extension module type " \
- "'spatialdata::geocoords::CoordSys'."
- if not quadrature.name == "pylith_feassemble_Quadrature":
- raise TypeError, \
- "Argument must be extension module type " \
- "'pylith::feassemble::Quadrature'."
- Material_initialize(self.thisptr, ptrFromHandle(mesh), ptrFromHandle(cs),
- ptrFromHandle(quadrature))
- return
-
-
- def _createHandle(self):
- """
- Wrap pointer to C++ object in PyCObject.
- """
- return PyCObject_FromVoidPtr(self.thisptr, Material_destructor)
-
-
- property db:
- def __set__(self, value):
- """
- Set database for physical property parameters.
- """
- # create shim for method 'db'
- #embed{ void Material_db_set(void* objVptr, void* dbVptr)
- try {
- assert(0 != objVptr);
- assert(0 != dbVptr);
- spatialdata::spatialdb::SpatialDB* db =
- (spatialdata::spatialdb::SpatialDB*) dbVptr;
- ((pylith::materials::Material*) objVptr)->db(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'."
- Material_db_set(self.thisptr, ptrFromHandle(value))
-
-
- property initialStateDB:
- def __set__(self, value):
- """
- Set database for initial state variables.
- """
- # create shim for method 'initialStateDB'
- #embed{ void Material_initialStateDB_set(void* objVptr, void* isVptr)
- try {
- assert(0 != objVptr);
- spatialdata::spatialdb::SpatialDB* initialStateDB =
- (spatialdata::spatialdb::SpatialDB*) isVptr;
- ((pylith::materials::Material*) objVptr)->initialStateDB(initialStateDB);
- } 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'."
- if None == value:
- Material_initialStateDB_set(self.thisptr, NULL)
- else:
- Material_initialStateDB_set(self.thisptr, ptrFromHandle(value))
-
-
-
- property id:
- def __set__(self, value):
- """
- Set identifier of material.
- """
- # create shim for method 'id'
- #embed{ void Material_id_set(void* objVptr, int value)
- try {
- assert(0 != objVptr);
- ((pylith::materials::Material*) 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
- Material_id_set(self.thisptr, value)
-
- def __get__(self):
- """
- Get identifier of material.
- """
- # create shim for method 'id'
- #embed{ int Material_id_get(void* objVptr)
- int result = 0;
- try {
- assert(0 != objVptr);
- result = ((pylith::materials::Material*) 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 Material_id_get(self.thisptr)
-
-
- property label:
- def __set__(self, value):
- """
- Set label of material.
- """
- # create shim for method 'label'
- #embed{ void Material_label_set(void* objVptr, char* value)
- try {
- assert(0 != objVptr);
- ((pylith::materials::Material*) 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
- Material_label_set(self.thisptr, value)
-
-
- property dimension:
- def __get__(self):
- """
- Get dimension associated with material.
- """
- # create shim for method 'dimension'
- #embed{ int Material_dimension_get(void* objVptr)
- int result = 0;
- try {
- assert(0 != objVptr);
- result = ((pylith::materials::Material*) objVptr)->dimension();
- } 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 Material_dimension_get(self.thisptr)
-
-
- property normalizer:
- def __set__(self, value):
- """
- Set scales for nondimensionalizing physical properties.
- """
- # create shim for method 'normalizer'
- #embed{ void Material_normalizer_set(void* objVptr, void* dimVptr)
- try {
- assert(0 != objVptr);
- assert(0 != dimVptr);
- spatialdata::units::Nondimensional* dim =
- (spatialdata::units::Nondimensional*) dimVptr;
- ((pylith::materials::Material*) objVptr)->normalizer(*dim);
- } 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_units_Nondimensional":
- raise TypeError, \
- "Argument must be extension module type " \
- "'spatialdata::units::Nondimensional'."
- Material_normalizer_set(self.thisptr, ptrFromHandle(value))
-
-
-# ----------------------------------------------------------------------
-cdef class ElasticMaterial(Material):
-
- def __init__(self):
- """
- Constructor.
- """
- Material.__init__(self)
- self.name = "pylith_materials_ElasticMaterial"
- return
-
-
- property useElasticBehavior:
- def __set__(self, value):
- """
- Set useElasticBehavior flag.
- """
- # create shim for method 'useElasticBehavior'
- #embed{ void Material_useElasticBehavior_set(void* objVptr, int value)
- try {
- assert(0 != objVptr);
- ((pylith::materials::ElasticMaterial*) objVptr)->useElasticBehavior(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
- Material_useElasticBehavior_set(self.thisptr, value)
-
-
-# ----------------------------------------------------------------------
-cdef class ElasticStrain1D(ElasticMaterial):
-
- def __init__(self):
- """
- Constructor.
- """
- # create shim for constructor
- #embed{ void* ElasticStrain1D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::materials::ElasticStrain1D);
- 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
-
- ElasticMaterial.__init__(self)
- self.thisptr = ElasticStrain1D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class ElasticStress1D(ElasticMaterial):
-
- def __init__(self):
- """
- Constructor.
- """
- # create shim for constructor
- #embed{ void* ElasticStress1D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::materials::ElasticStress1D);
- 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
-
- ElasticMaterial.__init__(self)
- self.thisptr = ElasticStress1D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class ElasticPlaneStrain(ElasticMaterial):
-
- def __init__(self):
- """
- Constructor.
- """
- # create shim for constructor
- #embed{ void* ElasticPlaneStrain_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::materials::ElasticPlaneStrain);
- 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
-
- ElasticMaterial.__init__(self)
- self.thisptr = ElasticPlaneStrain_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class ElasticPlaneStress(ElasticMaterial):
-
- def __init__(self):
- """
- Constructor.
- """
- # create shim for constructor
- #embed{ void* ElasticPlaneStress_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::materials::ElasticPlaneStress);
- 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
-
- ElasticMaterial.__init__(self)
- self.thisptr = ElasticPlaneStress_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class ElasticIsotropic3D(ElasticMaterial):
-
- def __init__(self):
- """
- Constructor.
- """
- # create shim for constructor
- #embed{ void* ElasticIsotropic3D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::materials::ElasticIsotropic3D);
- 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
-
- ElasticMaterial.__init__(self)
- self.thisptr = ElasticIsotropic3D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class GenMaxwellIsotropic3D(ElasticMaterial):
-
- def __init__(self):
- """
- Constructor.
- """
- # create shim for constructor
- #embed{ void* GenMaxwellIsotropic3D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::materials::GenMaxwellIsotropic3D);
- 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
-
- ElasticMaterial.__init__(self)
- self.thisptr = GenMaxwellIsotropic3D_constructor()
- self.handle = self._createHandle()
- return
-
-
-# ----------------------------------------------------------------------
-cdef class MaxwellIsotropic3D(ElasticMaterial):
-
- def __init__(self):
- """
- Constructor.
- """
- # create shim for constructor
- #embed{ void* MaxwellIsotropic3D_constructor()
- void* result = 0;
- try {
- result = (void*)(new pylith::materials::MaxwellIsotropic3D);
- 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
-
- ElasticMaterial.__init__(self)
- self.thisptr = MaxwellIsotropic3D_constructor()
- self.handle = self._createHandle()
- return
-
-# End of file
More information about the CIG-COMMITS
mailing list