diff --git a/dynamic/wrappers/cell_based/AbstractCentreBasedDivisionRule2_2.cppwg.cpp b/dynamic/wrappers/cell_based/AbstractCentreBasedDivisionRule2_2.cppwg.cpp new file mode 100644 index 00000000..8ab05c0d --- /dev/null +++ b/dynamic/wrappers/cell_based/AbstractCentreBasedDivisionRule2_2.cppwg.cpp @@ -0,0 +1,50 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "AbstractCentreBasedDivisionRule.hpp" + +#include "AbstractCentreBasedDivisionRule2_2.cppwg.hpp" + +namespace py = pybind11; +typedef AbstractCentreBasedDivisionRule<2 > AbstractCentreBasedDivisionRule2_2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); +typedef ::std::pair, boost::numeric::ublas::c_vector> _std_pair_lt_boost_numeric_ublas_c_vector_lt_double_2_gt__boost_numeric_ublas_c_vector_lt_double_2_gt__gt_; + +class AbstractCentreBasedDivisionRule2_2_Overloads : public AbstractCentreBasedDivisionRule2_2{ + public: + using AbstractCentreBasedDivisionRule2_2::AbstractCentreBasedDivisionRule; + ::std::pair, boost::numeric::ublas::c_vector> CalculateCellDivisionVector(::CellPtr pParentCell, ::AbstractCentreBasedCellPopulation<2, 2> & rCellPopulation) override { + PYBIND11_OVERLOAD_PURE( + _std_pair_lt_boost_numeric_ublas_c_vector_lt_double_2_gt__boost_numeric_ublas_c_vector_lt_double_2_gt__gt_, + AbstractCentreBasedDivisionRule2_2, + CalculateCellDivisionVector, + pParentCell, +rCellPopulation); + } + void OutputCellCentreBasedDivisionRuleParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + AbstractCentreBasedDivisionRule2_2, + OutputCellCentreBasedDivisionRuleParameters, + rParamsFile); + } + +}; +void register_AbstractCentreBasedDivisionRule2_2_class(py::module &m){ +py::class_ >(m, "AbstractCentreBasedDivisionRule2_2") + .def(py::init< >()) + .def( + "CalculateCellDivisionVector", + (::std::pair, boost::numeric::ublas::c_vector>(AbstractCentreBasedDivisionRule2_2::*)(::CellPtr, ::AbstractCentreBasedCellPopulation<2, 2> &)) &AbstractCentreBasedDivisionRule2_2::CalculateCellDivisionVector, + " " , py::arg("pParentCell"), py::arg("rCellPopulation") ) + .def( + "OutputCellCentreBasedDivisionRuleInfo", + (void(AbstractCentreBasedDivisionRule2_2::*)(::out_stream &)) &AbstractCentreBasedDivisionRule2_2::OutputCellCentreBasedDivisionRuleInfo, + " " , py::arg("rParamsFile") ) + ; +} diff --git a/dynamic/wrappers/cell_based/AbstractCentreBasedDivisionRule2_2.cppwg.hpp b/dynamic/wrappers/cell_based/AbstractCentreBasedDivisionRule2_2.cppwg.hpp new file mode 100644 index 00000000..7a78e450 --- /dev/null +++ b/dynamic/wrappers/cell_based/AbstractCentreBasedDivisionRule2_2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef AbstractCentreBasedDivisionRule2_2_hpp__pyplusplus_wrapper +#define AbstractCentreBasedDivisionRule2_2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_AbstractCentreBasedDivisionRule2_2_class(py::module &m); +#endif // AbstractCentreBasedDivisionRule2_2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/AbstractCentreBasedDivisionRule3_3.cppwg.cpp b/dynamic/wrappers/cell_based/AbstractCentreBasedDivisionRule3_3.cppwg.cpp new file mode 100644 index 00000000..c1f1720c --- /dev/null +++ b/dynamic/wrappers/cell_based/AbstractCentreBasedDivisionRule3_3.cppwg.cpp @@ -0,0 +1,50 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "AbstractCentreBasedDivisionRule.hpp" + +#include "AbstractCentreBasedDivisionRule3_3.cppwg.hpp" + +namespace py = pybind11; +typedef AbstractCentreBasedDivisionRule<3 > AbstractCentreBasedDivisionRule3_3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); +typedef ::std::pair, boost::numeric::ublas::c_vector> _std_pair_lt_boost_numeric_ublas_c_vector_lt_double_3_gt__boost_numeric_ublas_c_vector_lt_double_3_gt__gt_; + +class AbstractCentreBasedDivisionRule3_3_Overloads : public AbstractCentreBasedDivisionRule3_3{ + public: + using AbstractCentreBasedDivisionRule3_3::AbstractCentreBasedDivisionRule; + ::std::pair, boost::numeric::ublas::c_vector> CalculateCellDivisionVector(::CellPtr pParentCell, ::AbstractCentreBasedCellPopulation<3, 3> & rCellPopulation) override { + PYBIND11_OVERLOAD_PURE( + _std_pair_lt_boost_numeric_ublas_c_vector_lt_double_3_gt__boost_numeric_ublas_c_vector_lt_double_3_gt__gt_, + AbstractCentreBasedDivisionRule3_3, + CalculateCellDivisionVector, + pParentCell, +rCellPopulation); + } + void OutputCellCentreBasedDivisionRuleParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + AbstractCentreBasedDivisionRule3_3, + OutputCellCentreBasedDivisionRuleParameters, + rParamsFile); + } + +}; +void register_AbstractCentreBasedDivisionRule3_3_class(py::module &m){ +py::class_ >(m, "AbstractCentreBasedDivisionRule3_3") + .def(py::init< >()) + .def( + "CalculateCellDivisionVector", + (::std::pair, boost::numeric::ublas::c_vector>(AbstractCentreBasedDivisionRule3_3::*)(::CellPtr, ::AbstractCentreBasedCellPopulation<3, 3> &)) &AbstractCentreBasedDivisionRule3_3::CalculateCellDivisionVector, + " " , py::arg("pParentCell"), py::arg("rCellPopulation") ) + .def( + "OutputCellCentreBasedDivisionRuleInfo", + (void(AbstractCentreBasedDivisionRule3_3::*)(::out_stream &)) &AbstractCentreBasedDivisionRule3_3::OutputCellCentreBasedDivisionRuleInfo, + " " , py::arg("rParamsFile") ) + ; +} diff --git a/dynamic/wrappers/cell_based/AbstractCentreBasedDivisionRule3_3.cppwg.hpp b/dynamic/wrappers/cell_based/AbstractCentreBasedDivisionRule3_3.cppwg.hpp new file mode 100644 index 00000000..c520a5ef --- /dev/null +++ b/dynamic/wrappers/cell_based/AbstractCentreBasedDivisionRule3_3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef AbstractCentreBasedDivisionRule3_3_hpp__pyplusplus_wrapper +#define AbstractCentreBasedDivisionRule3_3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_AbstractCentreBasedDivisionRule3_3_class(py::module &m); +#endif // AbstractCentreBasedDivisionRule3_3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/AbstractImmersedBoundaryDivisionRule2.cppwg.cpp b/dynamic/wrappers/cell_based/AbstractImmersedBoundaryDivisionRule2.cppwg.cpp new file mode 100644 index 00000000..6bc96ff0 --- /dev/null +++ b/dynamic/wrappers/cell_based/AbstractImmersedBoundaryDivisionRule2.cppwg.cpp @@ -0,0 +1,50 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "AbstractImmersedBoundaryDivisionRule.hpp" + +#include "AbstractImmersedBoundaryDivisionRule2.cppwg.hpp" + +namespace py = pybind11; +typedef AbstractImmersedBoundaryDivisionRule<2 > AbstractImmersedBoundaryDivisionRule2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); +typedef ::boost::numeric::ublas::c_vector _boost_numeric_ublas_c_vector_lt_double_2_gt_; + +class AbstractImmersedBoundaryDivisionRule2_Overloads : public AbstractImmersedBoundaryDivisionRule2{ + public: + using AbstractImmersedBoundaryDivisionRule2::AbstractImmersedBoundaryDivisionRule; + ::boost::numeric::ublas::c_vector CalculateCellDivisionVector(::CellPtr pParentCell, ::ImmersedBoundaryCellPopulation<2> & rCellPopulation) override { + PYBIND11_OVERLOAD_PURE( + _boost_numeric_ublas_c_vector_lt_double_2_gt_, + AbstractImmersedBoundaryDivisionRule2, + CalculateCellDivisionVector, + pParentCell, +rCellPopulation); + } + void OutputCellImmersedBoundaryDivisionRuleParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + AbstractImmersedBoundaryDivisionRule2, + OutputCellImmersedBoundaryDivisionRuleParameters, + rParamsFile); + } + +}; +void register_AbstractImmersedBoundaryDivisionRule2_class(py::module &m){ +py::class_ >(m, "AbstractImmersedBoundaryDivisionRule2") + .def(py::init< >()) + .def( + "CalculateCellDivisionVector", + (::boost::numeric::ublas::c_vector(AbstractImmersedBoundaryDivisionRule2::*)(::CellPtr, ::ImmersedBoundaryCellPopulation<2> &)) &AbstractImmersedBoundaryDivisionRule2::CalculateCellDivisionVector, + " " , py::arg("pParentCell"), py::arg("rCellPopulation") ) + .def( + "OutputCellImmersedBoundaryDivisionRuleInfo", + (void(AbstractImmersedBoundaryDivisionRule2::*)(::out_stream &)) &AbstractImmersedBoundaryDivisionRule2::OutputCellImmersedBoundaryDivisionRuleInfo, + " " , py::arg("rParamsFile") ) + ; +} diff --git a/dynamic/wrappers/cell_based/AbstractImmersedBoundaryDivisionRule2.cppwg.hpp b/dynamic/wrappers/cell_based/AbstractImmersedBoundaryDivisionRule2.cppwg.hpp new file mode 100644 index 00000000..6aeb9eb8 --- /dev/null +++ b/dynamic/wrappers/cell_based/AbstractImmersedBoundaryDivisionRule2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef AbstractImmersedBoundaryDivisionRule2_hpp__pyplusplus_wrapper +#define AbstractImmersedBoundaryDivisionRule2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_AbstractImmersedBoundaryDivisionRule2_class(py::module &m); +#endif // AbstractImmersedBoundaryDivisionRule2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/AbstractImmersedBoundaryDivisionRule3.cppwg.cpp b/dynamic/wrappers/cell_based/AbstractImmersedBoundaryDivisionRule3.cppwg.cpp new file mode 100644 index 00000000..4ec3cc48 --- /dev/null +++ b/dynamic/wrappers/cell_based/AbstractImmersedBoundaryDivisionRule3.cppwg.cpp @@ -0,0 +1,50 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "AbstractImmersedBoundaryDivisionRule.hpp" + +#include "AbstractImmersedBoundaryDivisionRule3.cppwg.hpp" + +namespace py = pybind11; +typedef AbstractImmersedBoundaryDivisionRule<3 > AbstractImmersedBoundaryDivisionRule3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); +typedef ::boost::numeric::ublas::c_vector _boost_numeric_ublas_c_vector_lt_double_3_gt_; + +class AbstractImmersedBoundaryDivisionRule3_Overloads : public AbstractImmersedBoundaryDivisionRule3{ + public: + using AbstractImmersedBoundaryDivisionRule3::AbstractImmersedBoundaryDivisionRule; + ::boost::numeric::ublas::c_vector CalculateCellDivisionVector(::CellPtr pParentCell, ::ImmersedBoundaryCellPopulation<3> & rCellPopulation) override { + PYBIND11_OVERLOAD_PURE( + _boost_numeric_ublas_c_vector_lt_double_3_gt_, + AbstractImmersedBoundaryDivisionRule3, + CalculateCellDivisionVector, + pParentCell, +rCellPopulation); + } + void OutputCellImmersedBoundaryDivisionRuleParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + AbstractImmersedBoundaryDivisionRule3, + OutputCellImmersedBoundaryDivisionRuleParameters, + rParamsFile); + } + +}; +void register_AbstractImmersedBoundaryDivisionRule3_class(py::module &m){ +py::class_ >(m, "AbstractImmersedBoundaryDivisionRule3") + .def(py::init< >()) + .def( + "CalculateCellDivisionVector", + (::boost::numeric::ublas::c_vector(AbstractImmersedBoundaryDivisionRule3::*)(::CellPtr, ::ImmersedBoundaryCellPopulation<3> &)) &AbstractImmersedBoundaryDivisionRule3::CalculateCellDivisionVector, + " " , py::arg("pParentCell"), py::arg("rCellPopulation") ) + .def( + "OutputCellImmersedBoundaryDivisionRuleInfo", + (void(AbstractImmersedBoundaryDivisionRule3::*)(::out_stream &)) &AbstractImmersedBoundaryDivisionRule3::OutputCellImmersedBoundaryDivisionRuleInfo, + " " , py::arg("rParamsFile") ) + ; +} diff --git a/dynamic/wrappers/cell_based/AbstractImmersedBoundaryDivisionRule3.cppwg.hpp b/dynamic/wrappers/cell_based/AbstractImmersedBoundaryDivisionRule3.cppwg.hpp new file mode 100644 index 00000000..09b36588 --- /dev/null +++ b/dynamic/wrappers/cell_based/AbstractImmersedBoundaryDivisionRule3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef AbstractImmersedBoundaryDivisionRule3_hpp__pyplusplus_wrapper +#define AbstractImmersedBoundaryDivisionRule3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_AbstractImmersedBoundaryDivisionRule3_class(py::module &m); +#endif // AbstractImmersedBoundaryDivisionRule3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/AbstractImmersedBoundaryForce2.cppwg.cpp b/dynamic/wrappers/cell_based/AbstractImmersedBoundaryForce2.cppwg.cpp new file mode 100644 index 00000000..9ebbbd42 --- /dev/null +++ b/dynamic/wrappers/cell_based/AbstractImmersedBoundaryForce2.cppwg.cpp @@ -0,0 +1,73 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "AbstractImmersedBoundaryForce.hpp" + +#include "AbstractImmersedBoundaryForce2.cppwg.hpp" + +namespace py = pybind11; +typedef AbstractImmersedBoundaryForce<2 > AbstractImmersedBoundaryForce2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class AbstractImmersedBoundaryForce2_Overloads : public AbstractImmersedBoundaryForce2{ + public: + using AbstractImmersedBoundaryForce2::AbstractImmersedBoundaryForce; + void AddImmersedBoundaryForceContribution(::std::vector *, Node<2> *>> & rNodePairs, ::ImmersedBoundaryCellPopulation<2> & rCellPopulation) override { + PYBIND11_OVERLOAD_PURE( + void, + AbstractImmersedBoundaryForce2, + AddImmersedBoundaryForceContribution, + rNodePairs, +rCellPopulation); + } + void OutputImmersedBoundaryForceParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD_PURE( + void, + AbstractImmersedBoundaryForce2, + OutputImmersedBoundaryForceParameters, + rParamsFile); + } + +}; +void register_AbstractImmersedBoundaryForce2_class(py::module &m){ +py::class_ >(m, "AbstractImmersedBoundaryForce2") + .def(py::init< >()) + .def( + "AddImmersedBoundaryForceContribution", + (void(AbstractImmersedBoundaryForce2::*)(::std::vector *, Node<2> *>> &, ::ImmersedBoundaryCellPopulation<2> &)) &AbstractImmersedBoundaryForce2::AddImmersedBoundaryForceContribution, + " " , py::arg("rNodePairs"), py::arg("rCellPopulation") ) + .def( + "OutputImmersedBoundaryForceParameters", + (void(AbstractImmersedBoundaryForce2::*)(::out_stream &)) &AbstractImmersedBoundaryForce2::OutputImmersedBoundaryForceParameters, + " " , py::arg("rParamsFile") ) + .def( + "GetAdditiveNormalNoise", + (bool(AbstractImmersedBoundaryForce2::*)() const ) &AbstractImmersedBoundaryForce2::GetAdditiveNormalNoise, + " " ) + .def( + "SetAdditiveNormalNoise", + (void(AbstractImmersedBoundaryForce2::*)(bool)) &AbstractImmersedBoundaryForce2::SetAdditiveNormalNoise, + " " , py::arg("additiveNormalNoise") ) + .def( + "GetNormalNoiseMean", + (double(AbstractImmersedBoundaryForce2::*)() const ) &AbstractImmersedBoundaryForce2::GetNormalNoiseMean, + " " ) + .def( + "SetNormalNoiseMean", + (void(AbstractImmersedBoundaryForce2::*)(double)) &AbstractImmersedBoundaryForce2::SetNormalNoiseMean, + " " , py::arg("normalNoiseMean") ) + .def( + "GetNormalNoiseStdDev", + (double(AbstractImmersedBoundaryForce2::*)() const ) &AbstractImmersedBoundaryForce2::GetNormalNoiseStdDev, + " " ) + .def( + "SetNormalNoiseStdDev", + (void(AbstractImmersedBoundaryForce2::*)(double)) &AbstractImmersedBoundaryForce2::SetNormalNoiseStdDev, + " " , py::arg("normalNoiseStdDev") ) + ; +} diff --git a/dynamic/wrappers/cell_based/AbstractImmersedBoundaryForce2.cppwg.hpp b/dynamic/wrappers/cell_based/AbstractImmersedBoundaryForce2.cppwg.hpp new file mode 100644 index 00000000..a442dae0 --- /dev/null +++ b/dynamic/wrappers/cell_based/AbstractImmersedBoundaryForce2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef AbstractImmersedBoundaryForce2_hpp__pyplusplus_wrapper +#define AbstractImmersedBoundaryForce2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_AbstractImmersedBoundaryForce2_class(py::module &m); +#endif // AbstractImmersedBoundaryForce2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/AbstractImmersedBoundaryForce3.cppwg.cpp b/dynamic/wrappers/cell_based/AbstractImmersedBoundaryForce3.cppwg.cpp new file mode 100644 index 00000000..823c673f --- /dev/null +++ b/dynamic/wrappers/cell_based/AbstractImmersedBoundaryForce3.cppwg.cpp @@ -0,0 +1,73 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "AbstractImmersedBoundaryForce.hpp" + +#include "AbstractImmersedBoundaryForce3.cppwg.hpp" + +namespace py = pybind11; +typedef AbstractImmersedBoundaryForce<3 > AbstractImmersedBoundaryForce3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class AbstractImmersedBoundaryForce3_Overloads : public AbstractImmersedBoundaryForce3{ + public: + using AbstractImmersedBoundaryForce3::AbstractImmersedBoundaryForce; + void AddImmersedBoundaryForceContribution(::std::vector *, Node<3> *>> & rNodePairs, ::ImmersedBoundaryCellPopulation<3> & rCellPopulation) override { + PYBIND11_OVERLOAD_PURE( + void, + AbstractImmersedBoundaryForce3, + AddImmersedBoundaryForceContribution, + rNodePairs, +rCellPopulation); + } + void OutputImmersedBoundaryForceParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD_PURE( + void, + AbstractImmersedBoundaryForce3, + OutputImmersedBoundaryForceParameters, + rParamsFile); + } + +}; +void register_AbstractImmersedBoundaryForce3_class(py::module &m){ +py::class_ >(m, "AbstractImmersedBoundaryForce3") + .def(py::init< >()) + .def( + "AddImmersedBoundaryForceContribution", + (void(AbstractImmersedBoundaryForce3::*)(::std::vector *, Node<3> *>> &, ::ImmersedBoundaryCellPopulation<3> &)) &AbstractImmersedBoundaryForce3::AddImmersedBoundaryForceContribution, + " " , py::arg("rNodePairs"), py::arg("rCellPopulation") ) + .def( + "OutputImmersedBoundaryForceParameters", + (void(AbstractImmersedBoundaryForce3::*)(::out_stream &)) &AbstractImmersedBoundaryForce3::OutputImmersedBoundaryForceParameters, + " " , py::arg("rParamsFile") ) + .def( + "GetAdditiveNormalNoise", + (bool(AbstractImmersedBoundaryForce3::*)() const ) &AbstractImmersedBoundaryForce3::GetAdditiveNormalNoise, + " " ) + .def( + "SetAdditiveNormalNoise", + (void(AbstractImmersedBoundaryForce3::*)(bool)) &AbstractImmersedBoundaryForce3::SetAdditiveNormalNoise, + " " , py::arg("additiveNormalNoise") ) + .def( + "GetNormalNoiseMean", + (double(AbstractImmersedBoundaryForce3::*)() const ) &AbstractImmersedBoundaryForce3::GetNormalNoiseMean, + " " ) + .def( + "SetNormalNoiseMean", + (void(AbstractImmersedBoundaryForce3::*)(double)) &AbstractImmersedBoundaryForce3::SetNormalNoiseMean, + " " , py::arg("normalNoiseMean") ) + .def( + "GetNormalNoiseStdDev", + (double(AbstractImmersedBoundaryForce3::*)() const ) &AbstractImmersedBoundaryForce3::GetNormalNoiseStdDev, + " " ) + .def( + "SetNormalNoiseStdDev", + (void(AbstractImmersedBoundaryForce3::*)(double)) &AbstractImmersedBoundaryForce3::SetNormalNoiseStdDev, + " " , py::arg("normalNoiseStdDev") ) + ; +} diff --git a/dynamic/wrappers/cell_based/AbstractImmersedBoundaryForce3.cppwg.hpp b/dynamic/wrappers/cell_based/AbstractImmersedBoundaryForce3.cppwg.hpp new file mode 100644 index 00000000..ec43503e --- /dev/null +++ b/dynamic/wrappers/cell_based/AbstractImmersedBoundaryForce3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef AbstractImmersedBoundaryForce3_hpp__pyplusplus_wrapper +#define AbstractImmersedBoundaryForce3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_AbstractImmersedBoundaryForce3_class(py::module &m); +#endif // AbstractImmersedBoundaryForce3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/FixedCentreBasedDivisionRule2_2.cppwg.cpp b/dynamic/wrappers/cell_based/FixedCentreBasedDivisionRule2_2.cppwg.cpp new file mode 100644 index 00000000..c7f058c4 --- /dev/null +++ b/dynamic/wrappers/cell_based/FixedCentreBasedDivisionRule2_2.cppwg.cpp @@ -0,0 +1,43 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "FixedCentreBasedDivisionRule.hpp" + +#include "FixedCentreBasedDivisionRule2_2.cppwg.hpp" + +namespace py = pybind11; +typedef FixedCentreBasedDivisionRule<2 > FixedCentreBasedDivisionRule2_2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); +typedef ::std::pair, boost::numeric::ublas::c_vector> _std_pair_lt_boost_numeric_ublas_c_vector_lt_double_2_gt__boost_numeric_ublas_c_vector_lt_double_2_gt__gt_; + +class FixedCentreBasedDivisionRule2_2_Overloads : public FixedCentreBasedDivisionRule2_2{ + public: + using FixedCentreBasedDivisionRule2_2::FixedCentreBasedDivisionRule; + ::std::pair, boost::numeric::ublas::c_vector> CalculateCellDivisionVector(::CellPtr pParentCell, ::AbstractCentreBasedCellPopulation<2, 2> & rCellPopulation) override { + PYBIND11_OVERLOAD( + _std_pair_lt_boost_numeric_ublas_c_vector_lt_double_2_gt__boost_numeric_ublas_c_vector_lt_double_2_gt__gt_, + FixedCentreBasedDivisionRule2_2, + CalculateCellDivisionVector, + pParentCell, +rCellPopulation); + } + +}; +void register_FixedCentreBasedDivisionRule2_2_class(py::module &m){ +py::class_ , AbstractCentreBasedDivisionRule<2> >(m, "FixedCentreBasedDivisionRule2_2") + .def(py::init<::boost::numeric::ublas::c_vector & >(), py::arg("rDaughterLocation")) + .def( + "rGetDaughterLocation", + (::boost::numeric::ublas::c_vector const &(FixedCentreBasedDivisionRule2_2::*)() const ) &FixedCentreBasedDivisionRule2_2::rGetDaughterLocation, + " " , py::return_value_policy::reference_internal) + .def( + "CalculateCellDivisionVector", + (::std::pair, boost::numeric::ublas::c_vector>(FixedCentreBasedDivisionRule2_2::*)(::CellPtr, ::AbstractCentreBasedCellPopulation<2, 2> &)) &FixedCentreBasedDivisionRule2_2::CalculateCellDivisionVector, + " " , py::arg("pParentCell"), py::arg("rCellPopulation") ) + ; +} diff --git a/dynamic/wrappers/cell_based/FixedCentreBasedDivisionRule2_2.cppwg.hpp b/dynamic/wrappers/cell_based/FixedCentreBasedDivisionRule2_2.cppwg.hpp new file mode 100644 index 00000000..42ed2320 --- /dev/null +++ b/dynamic/wrappers/cell_based/FixedCentreBasedDivisionRule2_2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef FixedCentreBasedDivisionRule2_2_hpp__pyplusplus_wrapper +#define FixedCentreBasedDivisionRule2_2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_FixedCentreBasedDivisionRule2_2_class(py::module &m); +#endif // FixedCentreBasedDivisionRule2_2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/FixedCentreBasedDivisionRule3_3.cppwg.cpp b/dynamic/wrappers/cell_based/FixedCentreBasedDivisionRule3_3.cppwg.cpp new file mode 100644 index 00000000..c8aa20f1 --- /dev/null +++ b/dynamic/wrappers/cell_based/FixedCentreBasedDivisionRule3_3.cppwg.cpp @@ -0,0 +1,43 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "FixedCentreBasedDivisionRule.hpp" + +#include "FixedCentreBasedDivisionRule3_3.cppwg.hpp" + +namespace py = pybind11; +typedef FixedCentreBasedDivisionRule<3 > FixedCentreBasedDivisionRule3_3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); +typedef ::std::pair, boost::numeric::ublas::c_vector> _std_pair_lt_boost_numeric_ublas_c_vector_lt_double_3_gt__boost_numeric_ublas_c_vector_lt_double_3_gt__gt_; + +class FixedCentreBasedDivisionRule3_3_Overloads : public FixedCentreBasedDivisionRule3_3{ + public: + using FixedCentreBasedDivisionRule3_3::FixedCentreBasedDivisionRule; + ::std::pair, boost::numeric::ublas::c_vector> CalculateCellDivisionVector(::CellPtr pParentCell, ::AbstractCentreBasedCellPopulation<3, 3> & rCellPopulation) override { + PYBIND11_OVERLOAD( + _std_pair_lt_boost_numeric_ublas_c_vector_lt_double_3_gt__boost_numeric_ublas_c_vector_lt_double_3_gt__gt_, + FixedCentreBasedDivisionRule3_3, + CalculateCellDivisionVector, + pParentCell, +rCellPopulation); + } + +}; +void register_FixedCentreBasedDivisionRule3_3_class(py::module &m){ +py::class_ , AbstractCentreBasedDivisionRule<3> >(m, "FixedCentreBasedDivisionRule3_3") + .def(py::init<::boost::numeric::ublas::c_vector & >(), py::arg("rDaughterLocation")) + .def( + "rGetDaughterLocation", + (::boost::numeric::ublas::c_vector const &(FixedCentreBasedDivisionRule3_3::*)() const ) &FixedCentreBasedDivisionRule3_3::rGetDaughterLocation, + " " , py::return_value_policy::reference_internal) + .def( + "CalculateCellDivisionVector", + (::std::pair, boost::numeric::ublas::c_vector>(FixedCentreBasedDivisionRule3_3::*)(::CellPtr, ::AbstractCentreBasedCellPopulation<3, 3> &)) &FixedCentreBasedDivisionRule3_3::CalculateCellDivisionVector, + " " , py::arg("pParentCell"), py::arg("rCellPopulation") ) + ; +} diff --git a/dynamic/wrappers/cell_based/FixedCentreBasedDivisionRule3_3.cppwg.hpp b/dynamic/wrappers/cell_based/FixedCentreBasedDivisionRule3_3.cppwg.hpp new file mode 100644 index 00000000..1142c372 --- /dev/null +++ b/dynamic/wrappers/cell_based/FixedCentreBasedDivisionRule3_3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef FixedCentreBasedDivisionRule3_3_hpp__pyplusplus_wrapper +#define FixedCentreBasedDivisionRule3_3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_FixedCentreBasedDivisionRule3_3_class(py::module &m); +#endif // FixedCentreBasedDivisionRule3_3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryBoundaryCellWriter2_2.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundaryBoundaryCellWriter2_2.cppwg.cpp new file mode 100644 index 00000000..86a2c1d5 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryBoundaryCellWriter2_2.cppwg.cpp @@ -0,0 +1,51 @@ +#include +#include +#include "ImmersedBoundaryCellPopulation.hpp" +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryBoundaryCellWriter.hpp" + +#include "ImmersedBoundaryBoundaryCellWriter2_2.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryBoundaryCellWriter<2,2 > ImmersedBoundaryBoundaryCellWriter2_2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryBoundaryCellWriter2_2_Overloads : public ImmersedBoundaryBoundaryCellWriter2_2{ + public: + using ImmersedBoundaryBoundaryCellWriter2_2::ImmersedBoundaryBoundaryCellWriter; + double GetCellDataForVtkOutput(::CellPtr pCell, ::AbstractCellPopulation<2> * pCellPopulation) override { + PYBIND11_OVERLOAD( + double, + ImmersedBoundaryBoundaryCellWriter2_2, + GetCellDataForVtkOutput, + pCell, +pCellPopulation); + } + void VisitCell(::CellPtr pCell, ::AbstractCellPopulation<2> * pCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryBoundaryCellWriter2_2, + VisitCell, + pCell, +pCellPopulation); + } + +}; +void register_ImmersedBoundaryBoundaryCellWriter2_2_class(py::module &m){ +py::class_ , AbstractCellWriter<2, 2> >(m, "ImmersedBoundaryBoundaryCellWriter2_2") + .def(py::init< >()) + .def( + "GetCellDataForVtkOutput", + (double(ImmersedBoundaryBoundaryCellWriter2_2::*)(::CellPtr, ::AbstractCellPopulation<2> *)) &ImmersedBoundaryBoundaryCellWriter2_2::GetCellDataForVtkOutput, + " " , py::arg("pCell"), py::arg("pCellPopulation") ) + .def( + "VisitCell", + (void(ImmersedBoundaryBoundaryCellWriter2_2::*)(::CellPtr, ::AbstractCellPopulation<2> *)) &ImmersedBoundaryBoundaryCellWriter2_2::VisitCell, + " " , py::arg("pCell"), py::arg("pCellPopulation") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryBoundaryCellWriter2_2.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundaryBoundaryCellWriter2_2.cppwg.hpp new file mode 100644 index 00000000..7d47cd85 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryBoundaryCellWriter2_2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryBoundaryCellWriter2_2_hpp__pyplusplus_wrapper +#define ImmersedBoundaryBoundaryCellWriter2_2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryBoundaryCellWriter2_2_class(py::module &m); +#endif // ImmersedBoundaryBoundaryCellWriter2_2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryBoundaryCellWriter3_3.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundaryBoundaryCellWriter3_3.cppwg.cpp new file mode 100644 index 00000000..94c01e57 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryBoundaryCellWriter3_3.cppwg.cpp @@ -0,0 +1,51 @@ +#include +#include +#include "ImmersedBoundaryCellPopulation.hpp" +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryBoundaryCellWriter.hpp" + +#include "ImmersedBoundaryBoundaryCellWriter3_3.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryBoundaryCellWriter<3,3 > ImmersedBoundaryBoundaryCellWriter3_3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryBoundaryCellWriter3_3_Overloads : public ImmersedBoundaryBoundaryCellWriter3_3{ + public: + using ImmersedBoundaryBoundaryCellWriter3_3::ImmersedBoundaryBoundaryCellWriter; + double GetCellDataForVtkOutput(::CellPtr pCell, ::AbstractCellPopulation<3> * pCellPopulation) override { + PYBIND11_OVERLOAD( + double, + ImmersedBoundaryBoundaryCellWriter3_3, + GetCellDataForVtkOutput, + pCell, +pCellPopulation); + } + void VisitCell(::CellPtr pCell, ::AbstractCellPopulation<3> * pCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryBoundaryCellWriter3_3, + VisitCell, + pCell, +pCellPopulation); + } + +}; +void register_ImmersedBoundaryBoundaryCellWriter3_3_class(py::module &m){ +py::class_ , AbstractCellWriter<3, 3> >(m, "ImmersedBoundaryBoundaryCellWriter3_3") + .def(py::init< >()) + .def( + "GetCellDataForVtkOutput", + (double(ImmersedBoundaryBoundaryCellWriter3_3::*)(::CellPtr, ::AbstractCellPopulation<3> *)) &ImmersedBoundaryBoundaryCellWriter3_3::GetCellDataForVtkOutput, + " " , py::arg("pCell"), py::arg("pCellPopulation") ) + .def( + "VisitCell", + (void(ImmersedBoundaryBoundaryCellWriter3_3::*)(::CellPtr, ::AbstractCellPopulation<3> *)) &ImmersedBoundaryBoundaryCellWriter3_3::VisitCell, + " " , py::arg("pCell"), py::arg("pCellPopulation") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryBoundaryCellWriter3_3.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundaryBoundaryCellWriter3_3.cppwg.hpp new file mode 100644 index 00000000..6d162e87 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryBoundaryCellWriter3_3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryBoundaryCellWriter3_3_hpp__pyplusplus_wrapper +#define ImmersedBoundaryBoundaryCellWriter3_3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryBoundaryCellWriter3_3_class(py::module &m); +#endif // ImmersedBoundaryBoundaryCellWriter3_3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryCellPopulation2.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundaryCellPopulation2.cppwg.cpp new file mode 100644 index 00000000..d49cbda8 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryCellPopulation2.cppwg.cpp @@ -0,0 +1,443 @@ +#include +#include +#include "AbstractImmersedBoundaryDivisionRule.hpp" +#include "CellAgesWriter.hpp" +#include "CellAncestorWriter.hpp" +#include "CellAppliedForceWriter.hpp" +#include "CellCycleModelProteinConcentrationsWriter.hpp" +#include "CellDataItemWriter.hpp" +#include "CellDeltaNotchWriter.hpp" +#include "CellDivisionLocationsWriter.hpp" +#include "CellIdWriter.hpp" +#include "CellLabelWriter.hpp" +#include "CellLocationIndexWriter.hpp" +#include "CellMutationStatesCountWriter.hpp" +#include "CellMutationStatesWriter.hpp" +#include "CellPopulationAdjacencyMatrixWriter.hpp" +#include "CellPopulationAreaWriter.hpp" +#include "CellPopulationElementWriter.hpp" +#include "CellProliferativePhasesCountWriter.hpp" +#include "CellProliferativePhasesWriter.hpp" +#include "CellProliferativeTypesCountWriter.hpp" +#include "CellProliferativeTypesWriter.hpp" +#include "CellRadiusWriter.hpp" +#include "CellRemovalLocationsWriter.hpp" +#include "CellRosetteRankWriter.hpp" +#include "CellVolumesWriter.hpp" +#include "HeterotypicBoundaryLengthWriter.hpp" +#include "LegacyCellProliferativeTypesWriter.hpp" +#include "NodeLocationWriter.hpp" +#include "NodeVelocityWriter.hpp" +#include "PottsMeshWriter.hpp" +#include "RadialCellDataDistributionWriter.hpp" +#include "VertexIntersectionSwapLocationsWriter.hpp" +#include "VertexT1SwapLocationsWriter.hpp" +#include "VertexT2SwapLocationsWriter.hpp" +#include "VertexT3SwapLocationsWriter.hpp" +#include "VoronoiDataWriter.hpp" +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryCellPopulation.hpp" + +#include "ImmersedBoundaryCellPopulation2.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryCellPopulation<2 > ImmersedBoundaryCellPopulation2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); +typedef unsigned int unsignedint; +typedef ::boost::numeric::ublas::c_vector _boost_numeric_ublas_c_vector_lt_double_2_gt_; +typedef ::Node<2> * _Node_lt_2_gt_Ptr; +typedef ::std::set _std_set_lt_unsignedint_gt_; +typedef unsigned int unsignedint; +typedef ::CellPtr _CellPtr; +typedef unsigned int unsignedint; +typedef ::std::set _std_set_lt_unsignedint_gt_; +typedef ::TetrahedralMesh<2, 2> * _TetrahedralMesh_lt_2_2_gt_Ptr; + +class ImmersedBoundaryCellPopulation2_Overloads : public ImmersedBoundaryCellPopulation2{ + public: + using ImmersedBoundaryCellPopulation2::ImmersedBoundaryCellPopulation; + double GetDampingConstant(unsigned int nodeIndex) override { + PYBIND11_OVERLOAD( + double, + ImmersedBoundaryCellPopulation2, + GetDampingConstant, + nodeIndex); + } + unsigned int GetNumNodes() override { + PYBIND11_OVERLOAD( + unsignedint, + ImmersedBoundaryCellPopulation2, + GetNumNodes, + ); + } + ::boost::numeric::ublas::c_vector GetLocationOfCellCentre(::CellPtr pCell) override { + PYBIND11_OVERLOAD( + _boost_numeric_ublas_c_vector_lt_double_2_gt_, + ImmersedBoundaryCellPopulation2, + GetLocationOfCellCentre, + pCell); + } + ::Node<2> * GetNode(unsigned int index) override { + PYBIND11_OVERLOAD( + _Node_lt_2_gt_Ptr, + ImmersedBoundaryCellPopulation2, + GetNode, + index); + } + ::std::set GetNeighbouringLocationIndices(::CellPtr pCell) override { + PYBIND11_OVERLOAD( + _std_set_lt_unsignedint_gt_, + ImmersedBoundaryCellPopulation2, + GetNeighbouringLocationIndices, + pCell); + } + unsigned int AddNode(::Node<2> * pNewNode) override { + PYBIND11_OVERLOAD( + unsignedint, + ImmersedBoundaryCellPopulation2, + AddNode, + pNewNode); + } + void UpdateNodeLocations(double dt) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation2, + UpdateNodeLocations, + dt); + } + void SetNode(unsigned int index, ::ChastePoint<2> & rNewLocation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation2, + SetNode, + index, +rNewLocation); + } + ::CellPtr AddCell(::CellPtr pNewCell, ::CellPtr pParentCell) override { + PYBIND11_OVERLOAD( + _CellPtr, + ImmersedBoundaryCellPopulation2, + AddCell, + pNewCell, +pParentCell); + } + unsigned int RemoveDeadCells() override { + PYBIND11_OVERLOAD( + unsignedint, + ImmersedBoundaryCellPopulation2, + RemoveDeadCells, + ); + } + bool IsCellAssociatedWithADeletedLocation(::CellPtr pCell) override { + PYBIND11_OVERLOAD( + bool, + ImmersedBoundaryCellPopulation2, + IsCellAssociatedWithADeletedLocation, + pCell); + } + void Update(bool hasHadBirthsOrDeaths) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation2, + Update, + hasHadBirthsOrDeaths); + } + void OpenWritersFiles(::OutputFileHandler & rOutputFileHandler) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation2, + OpenWritersFiles, + rOutputFileHandler); + } + void AcceptPopulationWriter(::boost::shared_ptr> pPopulationWriter) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation2, + AcceptPopulationWriter, + pPopulationWriter); + } + void AcceptPopulationEventWriter(::boost::shared_ptr> pPopulationEventWriter) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation2, + AcceptPopulationEventWriter, + pPopulationEventWriter); + } + void AcceptPopulationCountWriter(::boost::shared_ptr> pPopulationCountWriter) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation2, + AcceptPopulationCountWriter, + pPopulationCountWriter); + } + void AcceptCellWriter(::boost::shared_ptr> pCellWriter, ::CellPtr pCell) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation2, + AcceptCellWriter, + pCellWriter, +pCell); + } + double GetVolumeOfCell(::CellPtr pCell) override { + PYBIND11_OVERLOAD( + double, + ImmersedBoundaryCellPopulation2, + GetVolumeOfCell, + pCell); + } + void OutputCellPopulationParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation2, + OutputCellPopulationParameters, + rParamsFile); + } + double GetWidth(unsigned int const & rDimension) override { + PYBIND11_OVERLOAD( + double, + ImmersedBoundaryCellPopulation2, + GetWidth, + rDimension); + } + ::std::set GetNeighbouringNodeIndices(unsigned int index) override { + PYBIND11_OVERLOAD( + _std_set_lt_unsignedint_gt_, + ImmersedBoundaryCellPopulation2, + GetNeighbouringNodeIndices, + index); + } + ::TetrahedralMesh<2, 2> * GetTetrahedralMeshForPdeModifier() override { + PYBIND11_OVERLOAD( + _TetrahedralMesh_lt_2_2_gt_Ptr, + ImmersedBoundaryCellPopulation2, + GetTetrahedralMeshForPdeModifier, + ); + } + bool IsPdeNodeAssociatedWithNonApoptoticCell(unsigned int pdeNodeIndex) override { + PYBIND11_OVERLOAD( + bool, + ImmersedBoundaryCellPopulation2, + IsPdeNodeAssociatedWithNonApoptoticCell, + pdeNodeIndex); + } + double GetCellDataItemAtPdeNode(unsigned int pdeNodeIndex, ::std::string & rVariableName, bool dirichletBoundaryConditionApplies, double dirichletBoundaryValue) override { + PYBIND11_OVERLOAD( + double, + ImmersedBoundaryCellPopulation2, + GetCellDataItemAtPdeNode, + pdeNodeIndex, +rVariableName, +dirichletBoundaryConditionApplies, +dirichletBoundaryValue); + } + void CheckForStepSizeException(unsigned int nodeIndex, ::boost::numeric::ublas::c_vector & rDisplacement, double dt) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation2, + CheckForStepSizeException, + nodeIndex, +rDisplacement, +dt); + } + double GetDefaultTimeStep() override { + PYBIND11_OVERLOAD( + double, + ImmersedBoundaryCellPopulation2, + GetDefaultTimeStep, + ); + } + +}; +void register_ImmersedBoundaryCellPopulation2_class(py::module &m){ +py::class_ , AbstractOffLatticeCellPopulation<2> >(m, "ImmersedBoundaryCellPopulation2") + .def(py::init<::ImmersedBoundaryMesh<2, 2> &, ::std::vector> &, bool, bool, ::std::vector const >(), py::arg("rMesh"), py::arg("rCells"), py::arg("deleteMesh") = false, py::arg("validate") = true, py::arg("locationIndices") = std::vector()) + .def(py::init<::ImmersedBoundaryMesh<2, 2> & >(), py::arg("rMesh")) + .def( + "GetDampingConstant", + (double(ImmersedBoundaryCellPopulation2::*)(unsigned int)) &ImmersedBoundaryCellPopulation2::GetDampingConstant, + " " , py::arg("nodeIndex") ) + .def( + "GetElement", + (::ImmersedBoundaryElement<2, 2> *(ImmersedBoundaryCellPopulation2::*)(unsigned int)) &ImmersedBoundaryCellPopulation2::GetElement, + " " , py::arg("elementIndex") , py::return_value_policy::reference) + .def( + "GetLamina", + (::ImmersedBoundaryElement<1, 2> *(ImmersedBoundaryCellPopulation2::*)(unsigned int)) &ImmersedBoundaryCellPopulation2::GetLamina, + " " , py::arg("laminaIndex") , py::return_value_policy::reference) + .def( + "GetNumElements", + (unsigned int(ImmersedBoundaryCellPopulation2::*)()) &ImmersedBoundaryCellPopulation2::GetNumElements, + " " ) + .def( + "GetNumLaminas", + (unsigned int(ImmersedBoundaryCellPopulation2::*)()) &ImmersedBoundaryCellPopulation2::GetNumLaminas, + " " ) + .def( + "GetNumNodes", + (unsigned int(ImmersedBoundaryCellPopulation2::*)()) &ImmersedBoundaryCellPopulation2::GetNumNodes, + " " ) + .def( + "SetInteractionDistance", + (void(ImmersedBoundaryCellPopulation2::*)(double)) &ImmersedBoundaryCellPopulation2::SetInteractionDistance, + " " , py::arg("newDistance") ) + .def( + "GetInteractionDistance", + (double(ImmersedBoundaryCellPopulation2::*)() const ) &ImmersedBoundaryCellPopulation2::GetInteractionDistance, + " " ) + .def( + "SetReMeshFrequency", + (void(ImmersedBoundaryCellPopulation2::*)(unsigned int)) &ImmersedBoundaryCellPopulation2::SetReMeshFrequency, + " " , py::arg("newFrequency") ) + .def( + "GetReMeshFrequency", + (unsigned int(ImmersedBoundaryCellPopulation2::*)() const ) &ImmersedBoundaryCellPopulation2::GetReMeshFrequency, + " " ) + .def( + "SetThrowsStepSizeException", + (void(ImmersedBoundaryCellPopulation2::*)(bool)) &ImmersedBoundaryCellPopulation2::SetThrowsStepSizeException, + " " , py::arg("throws") ) + .def( + "ThrowsStepSizeException", + (bool(ImmersedBoundaryCellPopulation2::*)() const ) &ImmersedBoundaryCellPopulation2::ThrowsStepSizeException, + " " ) + .def( + "GetIntrinsicSpacing", + (double(ImmersedBoundaryCellPopulation2::*)() const ) &ImmersedBoundaryCellPopulation2::GetIntrinsicSpacing, + " " ) + .def( + "SetCellRearrangementThreshold", + (void(ImmersedBoundaryCellPopulation2::*)(double)) &ImmersedBoundaryCellPopulation2::SetCellRearrangementThreshold, + " " , py::arg("newThreshold") ) + .def( + "GetCellRearrangementThreshold", + (double(ImmersedBoundaryCellPopulation2::*)() const ) &ImmersedBoundaryCellPopulation2::GetCellRearrangementThreshold, + " " ) + .def( + "GetLocationOfCellCentre", + (::boost::numeric::ublas::c_vector(ImmersedBoundaryCellPopulation2::*)(::CellPtr)) &ImmersedBoundaryCellPopulation2::GetLocationOfCellCentre, + " " , py::arg("pCell") ) + .def( + "GetNode", + (::Node<2> *(ImmersedBoundaryCellPopulation2::*)(unsigned int)) &ImmersedBoundaryCellPopulation2::GetNode, + " " , py::arg("index") , py::return_value_policy::reference) + .def( + "GetNeighbouringLocationIndices", + (::std::set(ImmersedBoundaryCellPopulation2::*)(::CellPtr)) &ImmersedBoundaryCellPopulation2::GetNeighbouringLocationIndices, + " " , py::arg("pCell") ) + .def( + "AddNode", + (unsigned int(ImmersedBoundaryCellPopulation2::*)(::Node<2> *)) &ImmersedBoundaryCellPopulation2::AddNode, + " " , py::arg("pNewNode") ) + .def( + "UpdateNodeLocations", + (void(ImmersedBoundaryCellPopulation2::*)(double)) &ImmersedBoundaryCellPopulation2::UpdateNodeLocations, + " " , py::arg("dt") ) + .def( + "SetNode", + (void(ImmersedBoundaryCellPopulation2::*)(unsigned int, ::ChastePoint<2> &)) &ImmersedBoundaryCellPopulation2::SetNode, + " " , py::arg("index"), py::arg("rNewLocation") ) + .def( + "GetElementCorrespondingToCell", + (::ImmersedBoundaryElement<2, 2> *(ImmersedBoundaryCellPopulation2::*)(::CellPtr)) &ImmersedBoundaryCellPopulation2::GetElementCorrespondingToCell, + " " , py::arg("pCell") , py::return_value_policy::reference) + .def( + "AddCell", + (::CellPtr(ImmersedBoundaryCellPopulation2::*)(::CellPtr, ::CellPtr)) &ImmersedBoundaryCellPopulation2::AddCell, + " " , py::arg("pNewCell"), py::arg("pParentCell") = ::CellPtr( ) ) + .def( + "RemoveDeadCells", + (unsigned int(ImmersedBoundaryCellPopulation2::*)()) &ImmersedBoundaryCellPopulation2::RemoveDeadCells, + " " ) + .def( + "IsCellAssociatedWithADeletedLocation", + (bool(ImmersedBoundaryCellPopulation2::*)(::CellPtr)) &ImmersedBoundaryCellPopulation2::IsCellAssociatedWithADeletedLocation, + " " , py::arg("pCell") ) + .def( + "Update", + (void(ImmersedBoundaryCellPopulation2::*)(bool)) &ImmersedBoundaryCellPopulation2::Update, + " " , py::arg("hasHadBirthsOrDeaths") = true ) + .def( + "OpenWritersFiles", + (void(ImmersedBoundaryCellPopulation2::*)(::OutputFileHandler &)) &ImmersedBoundaryCellPopulation2::OpenWritersFiles, + " " , py::arg("rOutputFileHandler") ) + .def( + "AcceptPopulationWriter", + (void(ImmersedBoundaryCellPopulation2::*)(::boost::shared_ptr>)) &ImmersedBoundaryCellPopulation2::AcceptPopulationWriter, + " " , py::arg("pPopulationWriter") ) + .def( + "AcceptPopulationEventWriter", + (void(ImmersedBoundaryCellPopulation2::*)(::boost::shared_ptr>)) &ImmersedBoundaryCellPopulation2::AcceptPopulationEventWriter, + " " , py::arg("pPopulationEventWriter") ) + .def( + "AcceptPopulationCountWriter", + (void(ImmersedBoundaryCellPopulation2::*)(::boost::shared_ptr>)) &ImmersedBoundaryCellPopulation2::AcceptPopulationCountWriter, + " " , py::arg("pPopulationCountWriter") ) + .def( + "AcceptCellWriter", + (void(ImmersedBoundaryCellPopulation2::*)(::boost::shared_ptr>, ::CellPtr)) &ImmersedBoundaryCellPopulation2::AcceptCellWriter, + " " , py::arg("pCellWriter"), py::arg("pCell") ) + .def( + "GetVolumeOfCell", + (double(ImmersedBoundaryCellPopulation2::*)(::CellPtr)) &ImmersedBoundaryCellPopulation2::GetVolumeOfCell, + " " , py::arg("pCell") ) + .def( + "OutputCellPopulationParameters", + (void(ImmersedBoundaryCellPopulation2::*)(::out_stream &)) &ImmersedBoundaryCellPopulation2::OutputCellPopulationParameters, + " " , py::arg("rParamsFile") ) + .def( + "GetWidth", + (double(ImmersedBoundaryCellPopulation2::*)(unsigned int const &)) &ImmersedBoundaryCellPopulation2::GetWidth, + " " , py::arg("rDimension") ) + .def( + "GetNeighbouringNodeIndices", + (::std::set(ImmersedBoundaryCellPopulation2::*)(unsigned int)) &ImmersedBoundaryCellPopulation2::GetNeighbouringNodeIndices, + " " , py::arg("index") ) + .def( + "IsPdeNodeAssociatedWithNonApoptoticCell", + (bool(ImmersedBoundaryCellPopulation2::*)(unsigned int)) &ImmersedBoundaryCellPopulation2::IsPdeNodeAssociatedWithNonApoptoticCell, + " " , py::arg("pdeNodeIndex") ) + .def( + "GetCellDataItemAtPdeNode", + (double(ImmersedBoundaryCellPopulation2::*)(unsigned int, ::std::string &, bool, double)) &ImmersedBoundaryCellPopulation2::GetCellDataItemAtPdeNode, + " " , py::arg("pdeNodeIndex"), py::arg("rVariableName"), py::arg("dirichletBoundaryConditionApplies") = false, py::arg("dirichletBoundaryValue") = 0. ) + .def( + "GetImmersedBoundaryDivisionRule", + (::boost::shared_ptr >(ImmersedBoundaryCellPopulation2::*)()) &ImmersedBoundaryCellPopulation2::GetImmersedBoundaryDivisionRule, + " " ) + .def( + "SetImmersedBoundaryDivisionRule", + (void(ImmersedBoundaryCellPopulation2::*)(::boost::shared_ptr >)) &ImmersedBoundaryCellPopulation2::SetImmersedBoundaryDivisionRule, + " " , py::arg("pImmersedBoundaryDivisionRule") ) + .def( + "DoesPopulationHaveActiveSources", + (bool(ImmersedBoundaryCellPopulation2::*)() const ) &ImmersedBoundaryCellPopulation2::DoesPopulationHaveActiveSources, + " " ) + .def( + "IsCellOnBoundary", + (bool(ImmersedBoundaryCellPopulation2::*)(::CellPtr)) &ImmersedBoundaryCellPopulation2::IsCellOnBoundary, + " " , py::arg("pCell") ) + .def( + "SetIfPopulationHasActiveSources", + (void(ImmersedBoundaryCellPopulation2::*)(bool)) &ImmersedBoundaryCellPopulation2::SetIfPopulationHasActiveSources, + " " , py::arg("hasActiveSources") ) + .def( + "SetOutputNodeRegionToVtk", + (void(ImmersedBoundaryCellPopulation2::*)(bool)) &ImmersedBoundaryCellPopulation2::SetOutputNodeRegionToVtk, + " " , py::arg("outputNodeRegionsToVtk") ) + .def( + "CheckForStepSizeException", + (void(ImmersedBoundaryCellPopulation2::*)(unsigned int, ::boost::numeric::ublas::c_vector &, double)) &ImmersedBoundaryCellPopulation2::CheckForStepSizeException, + " " , py::arg("nodeIndex"), py::arg("rDisplacement"), py::arg("dt") ) + .def( + "GetDefaultTimeStep", + (double(ImmersedBoundaryCellPopulation2::*)()) &ImmersedBoundaryCellPopulation2::GetDefaultTimeStep, + " " ) + .def("AddPopulationWriterVoronoiDataWriter", &ImmersedBoundaryCellPopulation2::AddPopulationWriter) + .def("AddCellWriterCellLabelWriter", &ImmersedBoundaryCellPopulation2::AddCellWriter) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryCellPopulation2.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundaryCellPopulation2.cppwg.hpp new file mode 100644 index 00000000..7b850ef5 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryCellPopulation2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryCellPopulation2_hpp__pyplusplus_wrapper +#define ImmersedBoundaryCellPopulation2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryCellPopulation2_class(py::module &m); +#endif // ImmersedBoundaryCellPopulation2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryCellPopulation3.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundaryCellPopulation3.cppwg.cpp new file mode 100644 index 00000000..4c126ee0 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryCellPopulation3.cppwg.cpp @@ -0,0 +1,443 @@ +#include +#include +#include "AbstractImmersedBoundaryDivisionRule.hpp" +#include "CellAgesWriter.hpp" +#include "CellAncestorWriter.hpp" +#include "CellAppliedForceWriter.hpp" +#include "CellCycleModelProteinConcentrationsWriter.hpp" +#include "CellDataItemWriter.hpp" +#include "CellDeltaNotchWriter.hpp" +#include "CellDivisionLocationsWriter.hpp" +#include "CellIdWriter.hpp" +#include "CellLabelWriter.hpp" +#include "CellLocationIndexWriter.hpp" +#include "CellMutationStatesCountWriter.hpp" +#include "CellMutationStatesWriter.hpp" +#include "CellPopulationAdjacencyMatrixWriter.hpp" +#include "CellPopulationAreaWriter.hpp" +#include "CellPopulationElementWriter.hpp" +#include "CellProliferativePhasesCountWriter.hpp" +#include "CellProliferativePhasesWriter.hpp" +#include "CellProliferativeTypesCountWriter.hpp" +#include "CellProliferativeTypesWriter.hpp" +#include "CellRadiusWriter.hpp" +#include "CellRemovalLocationsWriter.hpp" +#include "CellRosetteRankWriter.hpp" +#include "CellVolumesWriter.hpp" +#include "HeterotypicBoundaryLengthWriter.hpp" +#include "LegacyCellProliferativeTypesWriter.hpp" +#include "NodeLocationWriter.hpp" +#include "NodeVelocityWriter.hpp" +#include "PottsMeshWriter.hpp" +#include "RadialCellDataDistributionWriter.hpp" +#include "VertexIntersectionSwapLocationsWriter.hpp" +#include "VertexT1SwapLocationsWriter.hpp" +#include "VertexT2SwapLocationsWriter.hpp" +#include "VertexT3SwapLocationsWriter.hpp" +#include "VoronoiDataWriter.hpp" +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryCellPopulation.hpp" + +#include "ImmersedBoundaryCellPopulation3.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryCellPopulation<3 > ImmersedBoundaryCellPopulation3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); +typedef unsigned int unsignedint; +typedef ::boost::numeric::ublas::c_vector _boost_numeric_ublas_c_vector_lt_double_3_gt_; +typedef ::Node<3> * _Node_lt_3_gt_Ptr; +typedef ::std::set _std_set_lt_unsignedint_gt_; +typedef unsigned int unsignedint; +typedef ::CellPtr _CellPtr; +typedef unsigned int unsignedint; +typedef ::std::set _std_set_lt_unsignedint_gt_; +typedef ::TetrahedralMesh<3, 3> * _TetrahedralMesh_lt_3_3_gt_Ptr; + +class ImmersedBoundaryCellPopulation3_Overloads : public ImmersedBoundaryCellPopulation3{ + public: + using ImmersedBoundaryCellPopulation3::ImmersedBoundaryCellPopulation; + double GetDampingConstant(unsigned int nodeIndex) override { + PYBIND11_OVERLOAD( + double, + ImmersedBoundaryCellPopulation3, + GetDampingConstant, + nodeIndex); + } + unsigned int GetNumNodes() override { + PYBIND11_OVERLOAD( + unsignedint, + ImmersedBoundaryCellPopulation3, + GetNumNodes, + ); + } + ::boost::numeric::ublas::c_vector GetLocationOfCellCentre(::CellPtr pCell) override { + PYBIND11_OVERLOAD( + _boost_numeric_ublas_c_vector_lt_double_3_gt_, + ImmersedBoundaryCellPopulation3, + GetLocationOfCellCentre, + pCell); + } + ::Node<3> * GetNode(unsigned int index) override { + PYBIND11_OVERLOAD( + _Node_lt_3_gt_Ptr, + ImmersedBoundaryCellPopulation3, + GetNode, + index); + } + ::std::set GetNeighbouringLocationIndices(::CellPtr pCell) override { + PYBIND11_OVERLOAD( + _std_set_lt_unsignedint_gt_, + ImmersedBoundaryCellPopulation3, + GetNeighbouringLocationIndices, + pCell); + } + unsigned int AddNode(::Node<3> * pNewNode) override { + PYBIND11_OVERLOAD( + unsignedint, + ImmersedBoundaryCellPopulation3, + AddNode, + pNewNode); + } + void UpdateNodeLocations(double dt) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation3, + UpdateNodeLocations, + dt); + } + void SetNode(unsigned int index, ::ChastePoint<3> & rNewLocation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation3, + SetNode, + index, +rNewLocation); + } + ::CellPtr AddCell(::CellPtr pNewCell, ::CellPtr pParentCell) override { + PYBIND11_OVERLOAD( + _CellPtr, + ImmersedBoundaryCellPopulation3, + AddCell, + pNewCell, +pParentCell); + } + unsigned int RemoveDeadCells() override { + PYBIND11_OVERLOAD( + unsignedint, + ImmersedBoundaryCellPopulation3, + RemoveDeadCells, + ); + } + bool IsCellAssociatedWithADeletedLocation(::CellPtr pCell) override { + PYBIND11_OVERLOAD( + bool, + ImmersedBoundaryCellPopulation3, + IsCellAssociatedWithADeletedLocation, + pCell); + } + void Update(bool hasHadBirthsOrDeaths) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation3, + Update, + hasHadBirthsOrDeaths); + } + void OpenWritersFiles(::OutputFileHandler & rOutputFileHandler) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation3, + OpenWritersFiles, + rOutputFileHandler); + } + void AcceptPopulationWriter(::boost::shared_ptr> pPopulationWriter) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation3, + AcceptPopulationWriter, + pPopulationWriter); + } + void AcceptPopulationEventWriter(::boost::shared_ptr> pPopulationEventWriter) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation3, + AcceptPopulationEventWriter, + pPopulationEventWriter); + } + void AcceptPopulationCountWriter(::boost::shared_ptr> pPopulationCountWriter) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation3, + AcceptPopulationCountWriter, + pPopulationCountWriter); + } + void AcceptCellWriter(::boost::shared_ptr> pCellWriter, ::CellPtr pCell) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation3, + AcceptCellWriter, + pCellWriter, +pCell); + } + double GetVolumeOfCell(::CellPtr pCell) override { + PYBIND11_OVERLOAD( + double, + ImmersedBoundaryCellPopulation3, + GetVolumeOfCell, + pCell); + } + void OutputCellPopulationParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation3, + OutputCellPopulationParameters, + rParamsFile); + } + double GetWidth(unsigned int const & rDimension) override { + PYBIND11_OVERLOAD( + double, + ImmersedBoundaryCellPopulation3, + GetWidth, + rDimension); + } + ::std::set GetNeighbouringNodeIndices(unsigned int index) override { + PYBIND11_OVERLOAD( + _std_set_lt_unsignedint_gt_, + ImmersedBoundaryCellPopulation3, + GetNeighbouringNodeIndices, + index); + } + ::TetrahedralMesh<3, 3> * GetTetrahedralMeshForPdeModifier() override { + PYBIND11_OVERLOAD( + _TetrahedralMesh_lt_3_3_gt_Ptr, + ImmersedBoundaryCellPopulation3, + GetTetrahedralMeshForPdeModifier, + ); + } + bool IsPdeNodeAssociatedWithNonApoptoticCell(unsigned int pdeNodeIndex) override { + PYBIND11_OVERLOAD( + bool, + ImmersedBoundaryCellPopulation3, + IsPdeNodeAssociatedWithNonApoptoticCell, + pdeNodeIndex); + } + double GetCellDataItemAtPdeNode(unsigned int pdeNodeIndex, ::std::string & rVariableName, bool dirichletBoundaryConditionApplies, double dirichletBoundaryValue) override { + PYBIND11_OVERLOAD( + double, + ImmersedBoundaryCellPopulation3, + GetCellDataItemAtPdeNode, + pdeNodeIndex, +rVariableName, +dirichletBoundaryConditionApplies, +dirichletBoundaryValue); + } + void CheckForStepSizeException(unsigned int nodeIndex, ::boost::numeric::ublas::c_vector & rDisplacement, double dt) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryCellPopulation3, + CheckForStepSizeException, + nodeIndex, +rDisplacement, +dt); + } + double GetDefaultTimeStep() override { + PYBIND11_OVERLOAD( + double, + ImmersedBoundaryCellPopulation3, + GetDefaultTimeStep, + ); + } + +}; +void register_ImmersedBoundaryCellPopulation3_class(py::module &m){ +py::class_ , AbstractOffLatticeCellPopulation<3> >(m, "ImmersedBoundaryCellPopulation3") + .def(py::init<::ImmersedBoundaryMesh<3, 3> &, ::std::vector> &, bool, bool, ::std::vector const >(), py::arg("rMesh"), py::arg("rCells"), py::arg("deleteMesh") = false, py::arg("validate") = true, py::arg("locationIndices") = std::vector()) + .def(py::init<::ImmersedBoundaryMesh<3, 3> & >(), py::arg("rMesh")) + .def( + "GetDampingConstant", + (double(ImmersedBoundaryCellPopulation3::*)(unsigned int)) &ImmersedBoundaryCellPopulation3::GetDampingConstant, + " " , py::arg("nodeIndex") ) + .def( + "GetElement", + (::ImmersedBoundaryElement<3, 3> *(ImmersedBoundaryCellPopulation3::*)(unsigned int)) &ImmersedBoundaryCellPopulation3::GetElement, + " " , py::arg("elementIndex") , py::return_value_policy::reference) + .def( + "GetLamina", + (::ImmersedBoundaryElement<2, 3> *(ImmersedBoundaryCellPopulation3::*)(unsigned int)) &ImmersedBoundaryCellPopulation3::GetLamina, + " " , py::arg("laminaIndex") , py::return_value_policy::reference) + .def( + "GetNumElements", + (unsigned int(ImmersedBoundaryCellPopulation3::*)()) &ImmersedBoundaryCellPopulation3::GetNumElements, + " " ) + .def( + "GetNumLaminas", + (unsigned int(ImmersedBoundaryCellPopulation3::*)()) &ImmersedBoundaryCellPopulation3::GetNumLaminas, + " " ) + .def( + "GetNumNodes", + (unsigned int(ImmersedBoundaryCellPopulation3::*)()) &ImmersedBoundaryCellPopulation3::GetNumNodes, + " " ) + .def( + "SetInteractionDistance", + (void(ImmersedBoundaryCellPopulation3::*)(double)) &ImmersedBoundaryCellPopulation3::SetInteractionDistance, + " " , py::arg("newDistance") ) + .def( + "GetInteractionDistance", + (double(ImmersedBoundaryCellPopulation3::*)() const ) &ImmersedBoundaryCellPopulation3::GetInteractionDistance, + " " ) + .def( + "SetReMeshFrequency", + (void(ImmersedBoundaryCellPopulation3::*)(unsigned int)) &ImmersedBoundaryCellPopulation3::SetReMeshFrequency, + " " , py::arg("newFrequency") ) + .def( + "GetReMeshFrequency", + (unsigned int(ImmersedBoundaryCellPopulation3::*)() const ) &ImmersedBoundaryCellPopulation3::GetReMeshFrequency, + " " ) + .def( + "SetThrowsStepSizeException", + (void(ImmersedBoundaryCellPopulation3::*)(bool)) &ImmersedBoundaryCellPopulation3::SetThrowsStepSizeException, + " " , py::arg("throws") ) + .def( + "ThrowsStepSizeException", + (bool(ImmersedBoundaryCellPopulation3::*)() const ) &ImmersedBoundaryCellPopulation3::ThrowsStepSizeException, + " " ) + .def( + "GetIntrinsicSpacing", + (double(ImmersedBoundaryCellPopulation3::*)() const ) &ImmersedBoundaryCellPopulation3::GetIntrinsicSpacing, + " " ) + .def( + "SetCellRearrangementThreshold", + (void(ImmersedBoundaryCellPopulation3::*)(double)) &ImmersedBoundaryCellPopulation3::SetCellRearrangementThreshold, + " " , py::arg("newThreshold") ) + .def( + "GetCellRearrangementThreshold", + (double(ImmersedBoundaryCellPopulation3::*)() const ) &ImmersedBoundaryCellPopulation3::GetCellRearrangementThreshold, + " " ) + .def( + "GetLocationOfCellCentre", + (::boost::numeric::ublas::c_vector(ImmersedBoundaryCellPopulation3::*)(::CellPtr)) &ImmersedBoundaryCellPopulation3::GetLocationOfCellCentre, + " " , py::arg("pCell") ) + .def( + "GetNode", + (::Node<3> *(ImmersedBoundaryCellPopulation3::*)(unsigned int)) &ImmersedBoundaryCellPopulation3::GetNode, + " " , py::arg("index") , py::return_value_policy::reference) + .def( + "GetNeighbouringLocationIndices", + (::std::set(ImmersedBoundaryCellPopulation3::*)(::CellPtr)) &ImmersedBoundaryCellPopulation3::GetNeighbouringLocationIndices, + " " , py::arg("pCell") ) + .def( + "AddNode", + (unsigned int(ImmersedBoundaryCellPopulation3::*)(::Node<3> *)) &ImmersedBoundaryCellPopulation3::AddNode, + " " , py::arg("pNewNode") ) + .def( + "UpdateNodeLocations", + (void(ImmersedBoundaryCellPopulation3::*)(double)) &ImmersedBoundaryCellPopulation3::UpdateNodeLocations, + " " , py::arg("dt") ) + .def( + "SetNode", + (void(ImmersedBoundaryCellPopulation3::*)(unsigned int, ::ChastePoint<3> &)) &ImmersedBoundaryCellPopulation3::SetNode, + " " , py::arg("index"), py::arg("rNewLocation") ) + .def( + "GetElementCorrespondingToCell", + (::ImmersedBoundaryElement<3, 3> *(ImmersedBoundaryCellPopulation3::*)(::CellPtr)) &ImmersedBoundaryCellPopulation3::GetElementCorrespondingToCell, + " " , py::arg("pCell") , py::return_value_policy::reference) + .def( + "AddCell", + (::CellPtr(ImmersedBoundaryCellPopulation3::*)(::CellPtr, ::CellPtr)) &ImmersedBoundaryCellPopulation3::AddCell, + " " , py::arg("pNewCell"), py::arg("pParentCell") = ::CellPtr( ) ) + .def( + "RemoveDeadCells", + (unsigned int(ImmersedBoundaryCellPopulation3::*)()) &ImmersedBoundaryCellPopulation3::RemoveDeadCells, + " " ) + .def( + "IsCellAssociatedWithADeletedLocation", + (bool(ImmersedBoundaryCellPopulation3::*)(::CellPtr)) &ImmersedBoundaryCellPopulation3::IsCellAssociatedWithADeletedLocation, + " " , py::arg("pCell") ) + .def( + "Update", + (void(ImmersedBoundaryCellPopulation3::*)(bool)) &ImmersedBoundaryCellPopulation3::Update, + " " , py::arg("hasHadBirthsOrDeaths") = true ) + .def( + "OpenWritersFiles", + (void(ImmersedBoundaryCellPopulation3::*)(::OutputFileHandler &)) &ImmersedBoundaryCellPopulation3::OpenWritersFiles, + " " , py::arg("rOutputFileHandler") ) + .def( + "AcceptPopulationWriter", + (void(ImmersedBoundaryCellPopulation3::*)(::boost::shared_ptr>)) &ImmersedBoundaryCellPopulation3::AcceptPopulationWriter, + " " , py::arg("pPopulationWriter") ) + .def( + "AcceptPopulationEventWriter", + (void(ImmersedBoundaryCellPopulation3::*)(::boost::shared_ptr>)) &ImmersedBoundaryCellPopulation3::AcceptPopulationEventWriter, + " " , py::arg("pPopulationEventWriter") ) + .def( + "AcceptPopulationCountWriter", + (void(ImmersedBoundaryCellPopulation3::*)(::boost::shared_ptr>)) &ImmersedBoundaryCellPopulation3::AcceptPopulationCountWriter, + " " , py::arg("pPopulationCountWriter") ) + .def( + "AcceptCellWriter", + (void(ImmersedBoundaryCellPopulation3::*)(::boost::shared_ptr>, ::CellPtr)) &ImmersedBoundaryCellPopulation3::AcceptCellWriter, + " " , py::arg("pCellWriter"), py::arg("pCell") ) + .def( + "GetVolumeOfCell", + (double(ImmersedBoundaryCellPopulation3::*)(::CellPtr)) &ImmersedBoundaryCellPopulation3::GetVolumeOfCell, + " " , py::arg("pCell") ) + .def( + "OutputCellPopulationParameters", + (void(ImmersedBoundaryCellPopulation3::*)(::out_stream &)) &ImmersedBoundaryCellPopulation3::OutputCellPopulationParameters, + " " , py::arg("rParamsFile") ) + .def( + "GetWidth", + (double(ImmersedBoundaryCellPopulation3::*)(unsigned int const &)) &ImmersedBoundaryCellPopulation3::GetWidth, + " " , py::arg("rDimension") ) + .def( + "GetNeighbouringNodeIndices", + (::std::set(ImmersedBoundaryCellPopulation3::*)(unsigned int)) &ImmersedBoundaryCellPopulation3::GetNeighbouringNodeIndices, + " " , py::arg("index") ) + .def( + "IsPdeNodeAssociatedWithNonApoptoticCell", + (bool(ImmersedBoundaryCellPopulation3::*)(unsigned int)) &ImmersedBoundaryCellPopulation3::IsPdeNodeAssociatedWithNonApoptoticCell, + " " , py::arg("pdeNodeIndex") ) + .def( + "GetCellDataItemAtPdeNode", + (double(ImmersedBoundaryCellPopulation3::*)(unsigned int, ::std::string &, bool, double)) &ImmersedBoundaryCellPopulation3::GetCellDataItemAtPdeNode, + " " , py::arg("pdeNodeIndex"), py::arg("rVariableName"), py::arg("dirichletBoundaryConditionApplies") = false, py::arg("dirichletBoundaryValue") = 0. ) + .def( + "GetImmersedBoundaryDivisionRule", + (::boost::shared_ptr>(ImmersedBoundaryCellPopulation3::*)()) &ImmersedBoundaryCellPopulation3::GetImmersedBoundaryDivisionRule, + " " ) + .def( + "SetImmersedBoundaryDivisionRule", + (void(ImmersedBoundaryCellPopulation3::*)(::boost::shared_ptr>)) &ImmersedBoundaryCellPopulation3::SetImmersedBoundaryDivisionRule, + " " , py::arg("pImmersedBoundaryDivisionRule") ) + .def( + "DoesPopulationHaveActiveSources", + (bool(ImmersedBoundaryCellPopulation3::*)() const ) &ImmersedBoundaryCellPopulation3::DoesPopulationHaveActiveSources, + " " ) + .def( + "IsCellOnBoundary", + (bool(ImmersedBoundaryCellPopulation3::*)(::CellPtr)) &ImmersedBoundaryCellPopulation3::IsCellOnBoundary, + " " , py::arg("pCell") ) + .def( + "SetIfPopulationHasActiveSources", + (void(ImmersedBoundaryCellPopulation3::*)(bool)) &ImmersedBoundaryCellPopulation3::SetIfPopulationHasActiveSources, + " " , py::arg("hasActiveSources") ) + .def( + "SetOutputNodeRegionToVtk", + (void(ImmersedBoundaryCellPopulation3::*)(bool)) &ImmersedBoundaryCellPopulation3::SetOutputNodeRegionToVtk, + " " , py::arg("outputNodeRegionsToVtk") ) + .def( + "CheckForStepSizeException", + (void(ImmersedBoundaryCellPopulation3::*)(unsigned int, ::boost::numeric::ublas::c_vector &, double)) &ImmersedBoundaryCellPopulation3::CheckForStepSizeException, + " " , py::arg("nodeIndex"), py::arg("rDisplacement"), py::arg("dt") ) + .def( + "GetDefaultTimeStep", + (double(ImmersedBoundaryCellPopulation3::*)()) &ImmersedBoundaryCellPopulation3::GetDefaultTimeStep, + " " ) + .def("AddPopulationWriterVoronoiDataWriter", &ImmersedBoundaryCellPopulation3::AddPopulationWriter) + .def("AddCellWriterCellLabelWriter", &ImmersedBoundaryCellPopulation3::AddCellWriter) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryCellPopulation3.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundaryCellPopulation3.cppwg.hpp new file mode 100644 index 00000000..b6d94022 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryCellPopulation3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryCellPopulation3_hpp__pyplusplus_wrapper +#define ImmersedBoundaryCellPopulation3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryCellPopulation3_class(py::module &m); +#endif // ImmersedBoundaryCellPopulation3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryKinematicFeedbackForce2.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundaryKinematicFeedbackForce2.cppwg.cpp new file mode 100644 index 00000000..e9ad5d7e --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryKinematicFeedbackForce2.cppwg.cpp @@ -0,0 +1,57 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryKinematicFeedbackForce.hpp" + +#include "ImmersedBoundaryKinematicFeedbackForce2.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryKinematicFeedbackForce<2 > ImmersedBoundaryKinematicFeedbackForce2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryKinematicFeedbackForce2_Overloads : public ImmersedBoundaryKinematicFeedbackForce2{ + public: + using ImmersedBoundaryKinematicFeedbackForce2::ImmersedBoundaryKinematicFeedbackForce; + void AddImmersedBoundaryForceContribution(::std::vector *, Node<2> *>> & rNodePairs, ::ImmersedBoundaryCellPopulation<2> & rCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryKinematicFeedbackForce2, + AddImmersedBoundaryForceContribution, + rNodePairs, +rCellPopulation); + } + void OutputImmersedBoundaryForceParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryKinematicFeedbackForce2, + OutputImmersedBoundaryForceParameters, + rParamsFile); + } + +}; +void register_ImmersedBoundaryKinematicFeedbackForce2_class(py::module &m){ +py::class_ , AbstractImmersedBoundaryForce<2> >(m, "ImmersedBoundaryKinematicFeedbackForce2") + .def(py::init< >()) + .def( + "AddImmersedBoundaryForceContribution", + (void(ImmersedBoundaryKinematicFeedbackForce2::*)(::std::vector *, Node<2> *>> &, ::ImmersedBoundaryCellPopulation<2> &)) &ImmersedBoundaryKinematicFeedbackForce2::AddImmersedBoundaryForceContribution, + " " , py::arg("rNodePairs"), py::arg("rCellPopulation") ) + .def( + "OutputImmersedBoundaryForceParameters", + (void(ImmersedBoundaryKinematicFeedbackForce2::*)(::out_stream &)) &ImmersedBoundaryKinematicFeedbackForce2::OutputImmersedBoundaryForceParameters, + " " , py::arg("rParamsFile") ) + .def( + "GetSpringConst", + (double(ImmersedBoundaryKinematicFeedbackForce2::*)() const ) &ImmersedBoundaryKinematicFeedbackForce2::GetSpringConst, + " " ) + .def( + "SetSpringConst", + (void(ImmersedBoundaryKinematicFeedbackForce2::*)(double)) &ImmersedBoundaryKinematicFeedbackForce2::SetSpringConst, + " " , py::arg("springConst") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryKinematicFeedbackForce2.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundaryKinematicFeedbackForce2.cppwg.hpp new file mode 100644 index 00000000..aed2c12b --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryKinematicFeedbackForce2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryKinematicFeedbackForce2_hpp__pyplusplus_wrapper +#define ImmersedBoundaryKinematicFeedbackForce2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryKinematicFeedbackForce2_class(py::module &m); +#endif // ImmersedBoundaryKinematicFeedbackForce2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryKinematicFeedbackForce3.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundaryKinematicFeedbackForce3.cppwg.cpp new file mode 100644 index 00000000..53e2da16 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryKinematicFeedbackForce3.cppwg.cpp @@ -0,0 +1,57 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryKinematicFeedbackForce.hpp" + +#include "ImmersedBoundaryKinematicFeedbackForce3.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryKinematicFeedbackForce<3 > ImmersedBoundaryKinematicFeedbackForce3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryKinematicFeedbackForce3_Overloads : public ImmersedBoundaryKinematicFeedbackForce3{ + public: + using ImmersedBoundaryKinematicFeedbackForce3::ImmersedBoundaryKinematicFeedbackForce; + void AddImmersedBoundaryForceContribution(::std::vector *, Node<3> *>> & rNodePairs, ::ImmersedBoundaryCellPopulation<3> & rCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryKinematicFeedbackForce3, + AddImmersedBoundaryForceContribution, + rNodePairs, +rCellPopulation); + } + void OutputImmersedBoundaryForceParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryKinematicFeedbackForce3, + OutputImmersedBoundaryForceParameters, + rParamsFile); + } + +}; +void register_ImmersedBoundaryKinematicFeedbackForce3_class(py::module &m){ +py::class_ , AbstractImmersedBoundaryForce<3> >(m, "ImmersedBoundaryKinematicFeedbackForce3") + .def(py::init< >()) + .def( + "AddImmersedBoundaryForceContribution", + (void(ImmersedBoundaryKinematicFeedbackForce3::*)(::std::vector *, Node<3> *>> &, ::ImmersedBoundaryCellPopulation<3> &)) &ImmersedBoundaryKinematicFeedbackForce3::AddImmersedBoundaryForceContribution, + " " , py::arg("rNodePairs"), py::arg("rCellPopulation") ) + .def( + "OutputImmersedBoundaryForceParameters", + (void(ImmersedBoundaryKinematicFeedbackForce3::*)(::out_stream &)) &ImmersedBoundaryKinematicFeedbackForce3::OutputImmersedBoundaryForceParameters, + " " , py::arg("rParamsFile") ) + .def( + "GetSpringConst", + (double(ImmersedBoundaryKinematicFeedbackForce3::*)() const ) &ImmersedBoundaryKinematicFeedbackForce3::GetSpringConst, + " " ) + .def( + "SetSpringConst", + (void(ImmersedBoundaryKinematicFeedbackForce3::*)(double)) &ImmersedBoundaryKinematicFeedbackForce3::SetSpringConst, + " " , py::arg("springConst") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryKinematicFeedbackForce3.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundaryKinematicFeedbackForce3.cppwg.hpp new file mode 100644 index 00000000..b67c7797 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryKinematicFeedbackForce3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryKinematicFeedbackForce3_hpp__pyplusplus_wrapper +#define ImmersedBoundaryKinematicFeedbackForce3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryKinematicFeedbackForce3_class(py::module &m); +#endif // ImmersedBoundaryKinematicFeedbackForce3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryLinearDifferentialAdhesionForce2.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearDifferentialAdhesionForce2.cppwg.cpp new file mode 100644 index 00000000..f2f8d144 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearDifferentialAdhesionForce2.cppwg.cpp @@ -0,0 +1,81 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryLinearDifferentialAdhesionForce.hpp" + +#include "ImmersedBoundaryLinearDifferentialAdhesionForce2.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryLinearDifferentialAdhesionForce<2 > ImmersedBoundaryLinearDifferentialAdhesionForce2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryLinearDifferentialAdhesionForce2_Overloads : public ImmersedBoundaryLinearDifferentialAdhesionForce2{ + public: + using ImmersedBoundaryLinearDifferentialAdhesionForce2::ImmersedBoundaryLinearDifferentialAdhesionForce; + void AddImmersedBoundaryForceContribution(::std::vector *, Node<2> *>> & rNodePairs, ::ImmersedBoundaryCellPopulation<2> & rCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryLinearDifferentialAdhesionForce2, + AddImmersedBoundaryForceContribution, + rNodePairs, +rCellPopulation); + } + void OutputImmersedBoundaryForceParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryLinearDifferentialAdhesionForce2, + OutputImmersedBoundaryForceParameters, + rParamsFile); + } + +}; +void register_ImmersedBoundaryLinearDifferentialAdhesionForce2_class(py::module &m){ +py::class_ , AbstractImmersedBoundaryForce<2> >(m, "ImmersedBoundaryLinearDifferentialAdhesionForce2") + .def(py::init< >()) + .def( + "AddImmersedBoundaryForceContribution", + (void(ImmersedBoundaryLinearDifferentialAdhesionForce2::*)(::std::vector *, Node<2> *>> &, ::ImmersedBoundaryCellPopulation<2> &)) &ImmersedBoundaryLinearDifferentialAdhesionForce2::AddImmersedBoundaryForceContribution, + " " , py::arg("rNodePairs"), py::arg("rCellPopulation") ) + .def( + "OutputImmersedBoundaryForceParameters", + (void(ImmersedBoundaryLinearDifferentialAdhesionForce2::*)(::out_stream &)) &ImmersedBoundaryLinearDifferentialAdhesionForce2::OutputImmersedBoundaryForceParameters, + " " , py::arg("rParamsFile") ) + .def( + "GetLabelledCellToLabelledCellSpringConst", + (double(ImmersedBoundaryLinearDifferentialAdhesionForce2::*)() const ) &ImmersedBoundaryLinearDifferentialAdhesionForce2::GetLabelledCellToLabelledCellSpringConst, + " " ) + .def( + "SetLabelledCellToLabelledCellSpringConst", + (void(ImmersedBoundaryLinearDifferentialAdhesionForce2::*)(double)) &ImmersedBoundaryLinearDifferentialAdhesionForce2::SetLabelledCellToLabelledCellSpringConst, + " " , py::arg("labelledCellToLabelledCellSpringConst") ) + .def( + "GetLabelledCellToCellSpringConst", + (double(ImmersedBoundaryLinearDifferentialAdhesionForce2::*)() const ) &ImmersedBoundaryLinearDifferentialAdhesionForce2::GetLabelledCellToCellSpringConst, + " " ) + .def( + "SetLabelledCellToCellSpringConst", + (void(ImmersedBoundaryLinearDifferentialAdhesionForce2::*)(double)) &ImmersedBoundaryLinearDifferentialAdhesionForce2::SetLabelledCellToCellSpringConst, + " " , py::arg("labelledCellToCellSpringConst") ) + .def( + "GetCellToCellSpringConst", + (double(ImmersedBoundaryLinearDifferentialAdhesionForce2::*)() const ) &ImmersedBoundaryLinearDifferentialAdhesionForce2::GetCellToCellSpringConst, + " " ) + .def( + "SetCellToCellSpringConst", + (void(ImmersedBoundaryLinearDifferentialAdhesionForce2::*)(double)) &ImmersedBoundaryLinearDifferentialAdhesionForce2::SetCellToCellSpringConst, + " " , py::arg("cellToCellSpringConst") ) + .def( + "GetRestLength", + (double(ImmersedBoundaryLinearDifferentialAdhesionForce2::*)() const ) &ImmersedBoundaryLinearDifferentialAdhesionForce2::GetRestLength, + " " ) + .def( + "SetRestLength", + (void(ImmersedBoundaryLinearDifferentialAdhesionForce2::*)(double)) &ImmersedBoundaryLinearDifferentialAdhesionForce2::SetRestLength, + " " , py::arg("restLength") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryLinearDifferentialAdhesionForce2.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearDifferentialAdhesionForce2.cppwg.hpp new file mode 100644 index 00000000..77ac16e4 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearDifferentialAdhesionForce2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryLinearDifferentialAdhesionForce2_hpp__pyplusplus_wrapper +#define ImmersedBoundaryLinearDifferentialAdhesionForce2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryLinearDifferentialAdhesionForce2_class(py::module &m); +#endif // ImmersedBoundaryLinearDifferentialAdhesionForce2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryLinearDifferentialAdhesionForce3.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearDifferentialAdhesionForce3.cppwg.cpp new file mode 100644 index 00000000..c78ea789 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearDifferentialAdhesionForce3.cppwg.cpp @@ -0,0 +1,81 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryLinearDifferentialAdhesionForce.hpp" + +#include "ImmersedBoundaryLinearDifferentialAdhesionForce3.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryLinearDifferentialAdhesionForce<3 > ImmersedBoundaryLinearDifferentialAdhesionForce3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryLinearDifferentialAdhesionForce3_Overloads : public ImmersedBoundaryLinearDifferentialAdhesionForce3{ + public: + using ImmersedBoundaryLinearDifferentialAdhesionForce3::ImmersedBoundaryLinearDifferentialAdhesionForce; + void AddImmersedBoundaryForceContribution(::std::vector *, Node<3> *>> & rNodePairs, ::ImmersedBoundaryCellPopulation<3> & rCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryLinearDifferentialAdhesionForce3, + AddImmersedBoundaryForceContribution, + rNodePairs, +rCellPopulation); + } + void OutputImmersedBoundaryForceParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryLinearDifferentialAdhesionForce3, + OutputImmersedBoundaryForceParameters, + rParamsFile); + } + +}; +void register_ImmersedBoundaryLinearDifferentialAdhesionForce3_class(py::module &m){ +py::class_ , AbstractImmersedBoundaryForce<3> >(m, "ImmersedBoundaryLinearDifferentialAdhesionForce3") + .def(py::init< >()) + .def( + "AddImmersedBoundaryForceContribution", + (void(ImmersedBoundaryLinearDifferentialAdhesionForce3::*)(::std::vector *, Node<3> *>> &, ::ImmersedBoundaryCellPopulation<3> &)) &ImmersedBoundaryLinearDifferentialAdhesionForce3::AddImmersedBoundaryForceContribution, + " " , py::arg("rNodePairs"), py::arg("rCellPopulation") ) + .def( + "OutputImmersedBoundaryForceParameters", + (void(ImmersedBoundaryLinearDifferentialAdhesionForce3::*)(::out_stream &)) &ImmersedBoundaryLinearDifferentialAdhesionForce3::OutputImmersedBoundaryForceParameters, + " " , py::arg("rParamsFile") ) + .def( + "GetLabelledCellToLabelledCellSpringConst", + (double(ImmersedBoundaryLinearDifferentialAdhesionForce3::*)() const ) &ImmersedBoundaryLinearDifferentialAdhesionForce3::GetLabelledCellToLabelledCellSpringConst, + " " ) + .def( + "SetLabelledCellToLabelledCellSpringConst", + (void(ImmersedBoundaryLinearDifferentialAdhesionForce3::*)(double)) &ImmersedBoundaryLinearDifferentialAdhesionForce3::SetLabelledCellToLabelledCellSpringConst, + " " , py::arg("labelledCellToLabelledCellSpringConst") ) + .def( + "GetLabelledCellToCellSpringConst", + (double(ImmersedBoundaryLinearDifferentialAdhesionForce3::*)() const ) &ImmersedBoundaryLinearDifferentialAdhesionForce3::GetLabelledCellToCellSpringConst, + " " ) + .def( + "SetLabelledCellToCellSpringConst", + (void(ImmersedBoundaryLinearDifferentialAdhesionForce3::*)(double)) &ImmersedBoundaryLinearDifferentialAdhesionForce3::SetLabelledCellToCellSpringConst, + " " , py::arg("labelledCellToCellSpringConst") ) + .def( + "GetCellToCellSpringConst", + (double(ImmersedBoundaryLinearDifferentialAdhesionForce3::*)() const ) &ImmersedBoundaryLinearDifferentialAdhesionForce3::GetCellToCellSpringConst, + " " ) + .def( + "SetCellToCellSpringConst", + (void(ImmersedBoundaryLinearDifferentialAdhesionForce3::*)(double)) &ImmersedBoundaryLinearDifferentialAdhesionForce3::SetCellToCellSpringConst, + " " , py::arg("cellToCellSpringConst") ) + .def( + "GetRestLength", + (double(ImmersedBoundaryLinearDifferentialAdhesionForce3::*)() const ) &ImmersedBoundaryLinearDifferentialAdhesionForce3::GetRestLength, + " " ) + .def( + "SetRestLength", + (void(ImmersedBoundaryLinearDifferentialAdhesionForce3::*)(double)) &ImmersedBoundaryLinearDifferentialAdhesionForce3::SetRestLength, + " " , py::arg("restLength") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryLinearDifferentialAdhesionForce3.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearDifferentialAdhesionForce3.cppwg.hpp new file mode 100644 index 00000000..2eed97d1 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearDifferentialAdhesionForce3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryLinearDifferentialAdhesionForce3_hpp__pyplusplus_wrapper +#define ImmersedBoundaryLinearDifferentialAdhesionForce3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryLinearDifferentialAdhesionForce3_class(py::module &m); +#endif // ImmersedBoundaryLinearDifferentialAdhesionForce3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryLinearInteractionForce2.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearInteractionForce2.cppwg.cpp new file mode 100644 index 00000000..63896b56 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearInteractionForce2.cppwg.cpp @@ -0,0 +1,81 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryLinearInteractionForce.hpp" + +#include "ImmersedBoundaryLinearInteractionForce2.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryLinearInteractionForce<2 > ImmersedBoundaryLinearInteractionForce2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryLinearInteractionForce2_Overloads : public ImmersedBoundaryLinearInteractionForce2{ + public: + using ImmersedBoundaryLinearInteractionForce2::ImmersedBoundaryLinearInteractionForce; + void AddImmersedBoundaryForceContribution(::std::vector *, Node<2> *>> & rNodePairs, ::ImmersedBoundaryCellPopulation<2> & rCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryLinearInteractionForce2, + AddImmersedBoundaryForceContribution, + rNodePairs, +rCellPopulation); + } + void OutputImmersedBoundaryForceParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryLinearInteractionForce2, + OutputImmersedBoundaryForceParameters, + rParamsFile); + } + +}; +void register_ImmersedBoundaryLinearInteractionForce2_class(py::module &m){ +py::class_ , AbstractImmersedBoundaryForce<2> >(m, "ImmersedBoundaryLinearInteractionForce2") + .def(py::init< >()) + .def( + "AddImmersedBoundaryForceContribution", + (void(ImmersedBoundaryLinearInteractionForce2::*)(::std::vector *, Node<2> *>> &, ::ImmersedBoundaryCellPopulation<2> &)) &ImmersedBoundaryLinearInteractionForce2::AddImmersedBoundaryForceContribution, + " " , py::arg("rNodePairs"), py::arg("rCellPopulation") ) + .def( + "OutputImmersedBoundaryForceParameters", + (void(ImmersedBoundaryLinearInteractionForce2::*)(::out_stream &)) &ImmersedBoundaryLinearInteractionForce2::OutputImmersedBoundaryForceParameters, + " " , py::arg("rParamsFile") ) + .def( + "GetSpringConst", + (double(ImmersedBoundaryLinearInteractionForce2::*)() const ) &ImmersedBoundaryLinearInteractionForce2::GetSpringConst, + " " ) + .def( + "SetSpringConst", + (void(ImmersedBoundaryLinearInteractionForce2::*)(double)) &ImmersedBoundaryLinearInteractionForce2::SetSpringConst, + " " , py::arg("springConst") ) + .def( + "GetRestLength", + (double(ImmersedBoundaryLinearInteractionForce2::*)() const ) &ImmersedBoundaryLinearInteractionForce2::GetRestLength, + " " ) + .def( + "SetRestLength", + (void(ImmersedBoundaryLinearInteractionForce2::*)(double)) &ImmersedBoundaryLinearInteractionForce2::SetRestLength, + " " , py::arg("restLength") ) + .def( + "GetLaminaSpringConstMult", + (double(ImmersedBoundaryLinearInteractionForce2::*)() const ) &ImmersedBoundaryLinearInteractionForce2::GetLaminaSpringConstMult, + " " ) + .def( + "SetLaminaSpringConstMult", + (void(ImmersedBoundaryLinearInteractionForce2::*)(double)) &ImmersedBoundaryLinearInteractionForce2::SetLaminaSpringConstMult, + " " , py::arg("laminaSpringConstMult") ) + .def( + "GetLaminaRestLengthMult", + (double(ImmersedBoundaryLinearInteractionForce2::*)() const ) &ImmersedBoundaryLinearInteractionForce2::GetLaminaRestLengthMult, + " " ) + .def( + "SetLaminaRestLengthMult", + (void(ImmersedBoundaryLinearInteractionForce2::*)(double)) &ImmersedBoundaryLinearInteractionForce2::SetLaminaRestLengthMult, + " " , py::arg("laminaRestLengthMult") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryLinearInteractionForce2.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearInteractionForce2.cppwg.hpp new file mode 100644 index 00000000..1b282923 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearInteractionForce2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryLinearInteractionForce2_hpp__pyplusplus_wrapper +#define ImmersedBoundaryLinearInteractionForce2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryLinearInteractionForce2_class(py::module &m); +#endif // ImmersedBoundaryLinearInteractionForce2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryLinearInteractionForce3.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearInteractionForce3.cppwg.cpp new file mode 100644 index 00000000..6762d720 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearInteractionForce3.cppwg.cpp @@ -0,0 +1,81 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryLinearInteractionForce.hpp" + +#include "ImmersedBoundaryLinearInteractionForce3.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryLinearInteractionForce<3 > ImmersedBoundaryLinearInteractionForce3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryLinearInteractionForce3_Overloads : public ImmersedBoundaryLinearInteractionForce3{ + public: + using ImmersedBoundaryLinearInteractionForce3::ImmersedBoundaryLinearInteractionForce; + void AddImmersedBoundaryForceContribution(::std::vector *, Node<3> *>> & rNodePairs, ::ImmersedBoundaryCellPopulation<3> & rCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryLinearInteractionForce3, + AddImmersedBoundaryForceContribution, + rNodePairs, +rCellPopulation); + } + void OutputImmersedBoundaryForceParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryLinearInteractionForce3, + OutputImmersedBoundaryForceParameters, + rParamsFile); + } + +}; +void register_ImmersedBoundaryLinearInteractionForce3_class(py::module &m){ +py::class_ , AbstractImmersedBoundaryForce<3> >(m, "ImmersedBoundaryLinearInteractionForce3") + .def(py::init< >()) + .def( + "AddImmersedBoundaryForceContribution", + (void(ImmersedBoundaryLinearInteractionForce3::*)(::std::vector *, Node<3> *>> &, ::ImmersedBoundaryCellPopulation<3> &)) &ImmersedBoundaryLinearInteractionForce3::AddImmersedBoundaryForceContribution, + " " , py::arg("rNodePairs"), py::arg("rCellPopulation") ) + .def( + "OutputImmersedBoundaryForceParameters", + (void(ImmersedBoundaryLinearInteractionForce3::*)(::out_stream &)) &ImmersedBoundaryLinearInteractionForce3::OutputImmersedBoundaryForceParameters, + " " , py::arg("rParamsFile") ) + .def( + "GetSpringConst", + (double(ImmersedBoundaryLinearInteractionForce3::*)() const ) &ImmersedBoundaryLinearInteractionForce3::GetSpringConst, + " " ) + .def( + "SetSpringConst", + (void(ImmersedBoundaryLinearInteractionForce3::*)(double)) &ImmersedBoundaryLinearInteractionForce3::SetSpringConst, + " " , py::arg("springConst") ) + .def( + "GetRestLength", + (double(ImmersedBoundaryLinearInteractionForce3::*)() const ) &ImmersedBoundaryLinearInteractionForce3::GetRestLength, + " " ) + .def( + "SetRestLength", + (void(ImmersedBoundaryLinearInteractionForce3::*)(double)) &ImmersedBoundaryLinearInteractionForce3::SetRestLength, + " " , py::arg("restLength") ) + .def( + "GetLaminaSpringConstMult", + (double(ImmersedBoundaryLinearInteractionForce3::*)() const ) &ImmersedBoundaryLinearInteractionForce3::GetLaminaSpringConstMult, + " " ) + .def( + "SetLaminaSpringConstMult", + (void(ImmersedBoundaryLinearInteractionForce3::*)(double)) &ImmersedBoundaryLinearInteractionForce3::SetLaminaSpringConstMult, + " " , py::arg("laminaSpringConstMult") ) + .def( + "GetLaminaRestLengthMult", + (double(ImmersedBoundaryLinearInteractionForce3::*)() const ) &ImmersedBoundaryLinearInteractionForce3::GetLaminaRestLengthMult, + " " ) + .def( + "SetLaminaRestLengthMult", + (void(ImmersedBoundaryLinearInteractionForce3::*)(double)) &ImmersedBoundaryLinearInteractionForce3::SetLaminaRestLengthMult, + " " , py::arg("laminaRestLengthMult") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryLinearInteractionForce3.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearInteractionForce3.cppwg.hpp new file mode 100644 index 00000000..6ee4fbaf --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearInteractionForce3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryLinearInteractionForce3_hpp__pyplusplus_wrapper +#define ImmersedBoundaryLinearInteractionForce3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryLinearInteractionForce3_class(py::module &m); +#endif // ImmersedBoundaryLinearInteractionForce3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryLinearMembraneForce2.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearMembraneForce2.cppwg.cpp new file mode 100644 index 00000000..9c368612 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearMembraneForce2.cppwg.cpp @@ -0,0 +1,81 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryLinearMembraneForce.hpp" + +#include "ImmersedBoundaryLinearMembraneForce2.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryLinearMembraneForce<2 > ImmersedBoundaryLinearMembraneForce2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryLinearMembraneForce2_Overloads : public ImmersedBoundaryLinearMembraneForce2{ + public: + using ImmersedBoundaryLinearMembraneForce2::ImmersedBoundaryLinearMembraneForce; + void AddImmersedBoundaryForceContribution(::std::vector *, Node<2> *>> & rNodePairs, ::ImmersedBoundaryCellPopulation<2> & rCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryLinearMembraneForce2, + AddImmersedBoundaryForceContribution, + rNodePairs, +rCellPopulation); + } + void OutputImmersedBoundaryForceParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryLinearMembraneForce2, + OutputImmersedBoundaryForceParameters, + rParamsFile); + } + +}; +void register_ImmersedBoundaryLinearMembraneForce2_class(py::module &m){ +py::class_ , AbstractImmersedBoundaryForce<2> >(m, "ImmersedBoundaryLinearMembraneForce2") + .def(py::init< >()) + .def( + "AddImmersedBoundaryForceContribution", + (void(ImmersedBoundaryLinearMembraneForce2::*)(::std::vector *, Node<2> *>> &, ::ImmersedBoundaryCellPopulation<2> &)) &ImmersedBoundaryLinearMembraneForce2::AddImmersedBoundaryForceContribution, + " " , py::arg("rNodePairs"), py::arg("rCellPopulation") ) + .def( + "OutputImmersedBoundaryForceParameters", + (void(ImmersedBoundaryLinearMembraneForce2::*)(::out_stream &)) &ImmersedBoundaryLinearMembraneForce2::OutputImmersedBoundaryForceParameters, + " " , py::arg("rParamsFile") ) + .def( + "GetElementSpringConst", + (double(ImmersedBoundaryLinearMembraneForce2::*)() const ) &ImmersedBoundaryLinearMembraneForce2::GetElementSpringConst, + " " ) + .def( + "SetElementSpringConst", + (void(ImmersedBoundaryLinearMembraneForce2::*)(double)) &ImmersedBoundaryLinearMembraneForce2::SetElementSpringConst, + " " , py::arg("elementSpringConst") ) + .def( + "GetElementRestLength", + (double(ImmersedBoundaryLinearMembraneForce2::*)() const ) &ImmersedBoundaryLinearMembraneForce2::GetElementRestLength, + " " ) + .def( + "SetElementRestLength", + (void(ImmersedBoundaryLinearMembraneForce2::*)(double)) &ImmersedBoundaryLinearMembraneForce2::SetElementRestLength, + " " , py::arg("elementRestLength") ) + .def( + "GetLaminaSpringConst", + (double(ImmersedBoundaryLinearMembraneForce2::*)() const ) &ImmersedBoundaryLinearMembraneForce2::GetLaminaSpringConst, + " " ) + .def( + "SetLaminaSpringConst", + (void(ImmersedBoundaryLinearMembraneForce2::*)(double)) &ImmersedBoundaryLinearMembraneForce2::SetLaminaSpringConst, + " " , py::arg("laminaSpringConst") ) + .def( + "GetLaminaRestLength", + (double(ImmersedBoundaryLinearMembraneForce2::*)() const ) &ImmersedBoundaryLinearMembraneForce2::GetLaminaRestLength, + " " ) + .def( + "SetLaminaRestLength", + (void(ImmersedBoundaryLinearMembraneForce2::*)(double)) &ImmersedBoundaryLinearMembraneForce2::SetLaminaRestLength, + " " , py::arg("laminaRestLength") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryLinearMembraneForce2.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearMembraneForce2.cppwg.hpp new file mode 100644 index 00000000..4018d1e7 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearMembraneForce2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryLinearMembraneForce2_hpp__pyplusplus_wrapper +#define ImmersedBoundaryLinearMembraneForce2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryLinearMembraneForce2_class(py::module &m); +#endif // ImmersedBoundaryLinearMembraneForce2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryLinearMembraneForce3.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearMembraneForce3.cppwg.cpp new file mode 100644 index 00000000..acbb2836 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearMembraneForce3.cppwg.cpp @@ -0,0 +1,81 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryLinearMembraneForce.hpp" + +#include "ImmersedBoundaryLinearMembraneForce3.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryLinearMembraneForce<3 > ImmersedBoundaryLinearMembraneForce3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryLinearMembraneForce3_Overloads : public ImmersedBoundaryLinearMembraneForce3{ + public: + using ImmersedBoundaryLinearMembraneForce3::ImmersedBoundaryLinearMembraneForce; + void AddImmersedBoundaryForceContribution(::std::vector *, Node<3> *>> & rNodePairs, ::ImmersedBoundaryCellPopulation<3> & rCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryLinearMembraneForce3, + AddImmersedBoundaryForceContribution, + rNodePairs, +rCellPopulation); + } + void OutputImmersedBoundaryForceParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryLinearMembraneForce3, + OutputImmersedBoundaryForceParameters, + rParamsFile); + } + +}; +void register_ImmersedBoundaryLinearMembraneForce3_class(py::module &m){ +py::class_ , AbstractImmersedBoundaryForce<3> >(m, "ImmersedBoundaryLinearMembraneForce3") + .def(py::init< >()) + .def( + "AddImmersedBoundaryForceContribution", + (void(ImmersedBoundaryLinearMembraneForce3::*)(::std::vector *, Node<3> *>> &, ::ImmersedBoundaryCellPopulation<3> &)) &ImmersedBoundaryLinearMembraneForce3::AddImmersedBoundaryForceContribution, + " " , py::arg("rNodePairs"), py::arg("rCellPopulation") ) + .def( + "OutputImmersedBoundaryForceParameters", + (void(ImmersedBoundaryLinearMembraneForce3::*)(::out_stream &)) &ImmersedBoundaryLinearMembraneForce3::OutputImmersedBoundaryForceParameters, + " " , py::arg("rParamsFile") ) + .def( + "GetElementSpringConst", + (double(ImmersedBoundaryLinearMembraneForce3::*)() const ) &ImmersedBoundaryLinearMembraneForce3::GetElementSpringConst, + " " ) + .def( + "SetElementSpringConst", + (void(ImmersedBoundaryLinearMembraneForce3::*)(double)) &ImmersedBoundaryLinearMembraneForce3::SetElementSpringConst, + " " , py::arg("elementSpringConst") ) + .def( + "GetElementRestLength", + (double(ImmersedBoundaryLinearMembraneForce3::*)() const ) &ImmersedBoundaryLinearMembraneForce3::GetElementRestLength, + " " ) + .def( + "SetElementRestLength", + (void(ImmersedBoundaryLinearMembraneForce3::*)(double)) &ImmersedBoundaryLinearMembraneForce3::SetElementRestLength, + " " , py::arg("elementRestLength") ) + .def( + "GetLaminaSpringConst", + (double(ImmersedBoundaryLinearMembraneForce3::*)() const ) &ImmersedBoundaryLinearMembraneForce3::GetLaminaSpringConst, + " " ) + .def( + "SetLaminaSpringConst", + (void(ImmersedBoundaryLinearMembraneForce3::*)(double)) &ImmersedBoundaryLinearMembraneForce3::SetLaminaSpringConst, + " " , py::arg("laminaSpringConst") ) + .def( + "GetLaminaRestLength", + (double(ImmersedBoundaryLinearMembraneForce3::*)() const ) &ImmersedBoundaryLinearMembraneForce3::GetLaminaRestLength, + " " ) + .def( + "SetLaminaRestLength", + (void(ImmersedBoundaryLinearMembraneForce3::*)(double)) &ImmersedBoundaryLinearMembraneForce3::SetLaminaRestLength, + " " , py::arg("laminaRestLength") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryLinearMembraneForce3.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearMembraneForce3.cppwg.hpp new file mode 100644 index 00000000..688dfaec --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryLinearMembraneForce3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryLinearMembraneForce3_hpp__pyplusplus_wrapper +#define ImmersedBoundaryLinearMembraneForce3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryLinearMembraneForce3_class(py::module &m); +#endif // ImmersedBoundaryLinearMembraneForce3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryMorseInteractionForce2.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundaryMorseInteractionForce2.cppwg.cpp new file mode 100644 index 00000000..668211a5 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryMorseInteractionForce2.cppwg.cpp @@ -0,0 +1,89 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryMorseInteractionForce.hpp" + +#include "ImmersedBoundaryMorseInteractionForce2.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryMorseInteractionForce<2 > ImmersedBoundaryMorseInteractionForce2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryMorseInteractionForce2_Overloads : public ImmersedBoundaryMorseInteractionForce2{ + public: + using ImmersedBoundaryMorseInteractionForce2::ImmersedBoundaryMorseInteractionForce; + void AddImmersedBoundaryForceContribution(::std::vector *, Node<2> *>> & rNodePairs, ::ImmersedBoundaryCellPopulation<2> & rCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryMorseInteractionForce2, + AddImmersedBoundaryForceContribution, + rNodePairs, +rCellPopulation); + } + void OutputImmersedBoundaryForceParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryMorseInteractionForce2, + OutputImmersedBoundaryForceParameters, + rParamsFile); + } + +}; +void register_ImmersedBoundaryMorseInteractionForce2_class(py::module &m){ +py::class_ , AbstractImmersedBoundaryForce<2> >(m, "ImmersedBoundaryMorseInteractionForce2") + .def(py::init< >()) + .def( + "AddImmersedBoundaryForceContribution", + (void(ImmersedBoundaryMorseInteractionForce2::*)(::std::vector *, Node<2> *>> &, ::ImmersedBoundaryCellPopulation<2> &)) &ImmersedBoundaryMorseInteractionForce2::AddImmersedBoundaryForceContribution, + " " , py::arg("rNodePairs"), py::arg("rCellPopulation") ) + .def( + "OutputImmersedBoundaryForceParameters", + (void(ImmersedBoundaryMorseInteractionForce2::*)(::out_stream &)) &ImmersedBoundaryMorseInteractionForce2::OutputImmersedBoundaryForceParameters, + " " , py::arg("rParamsFile") ) + .def( + "GetWellDepth", + (double(ImmersedBoundaryMorseInteractionForce2::*)() const ) &ImmersedBoundaryMorseInteractionForce2::GetWellDepth, + " " ) + .def( + "SetWellDepth", + (void(ImmersedBoundaryMorseInteractionForce2::*)(double)) &ImmersedBoundaryMorseInteractionForce2::SetWellDepth, + " " , py::arg("wellDepth") ) + .def( + "GetRestLength", + (double(ImmersedBoundaryMorseInteractionForce2::*)() const ) &ImmersedBoundaryMorseInteractionForce2::GetRestLength, + " " ) + .def( + "SetRestLength", + (void(ImmersedBoundaryMorseInteractionForce2::*)(double)) &ImmersedBoundaryMorseInteractionForce2::SetRestLength, + " " , py::arg("restLength") ) + .def( + "GetLaminaWellDepthMult", + (double(ImmersedBoundaryMorseInteractionForce2::*)() const ) &ImmersedBoundaryMorseInteractionForce2::GetLaminaWellDepthMult, + " " ) + .def( + "SetLaminaWellDepthMult", + (void(ImmersedBoundaryMorseInteractionForce2::*)(double)) &ImmersedBoundaryMorseInteractionForce2::SetLaminaWellDepthMult, + " " , py::arg("laminaWellDepthMult") ) + .def( + "GetLaminaRestLengthMult", + (double(ImmersedBoundaryMorseInteractionForce2::*)() const ) &ImmersedBoundaryMorseInteractionForce2::GetLaminaRestLengthMult, + " " ) + .def( + "SetLaminaRestLengthMult", + (void(ImmersedBoundaryMorseInteractionForce2::*)(double)) &ImmersedBoundaryMorseInteractionForce2::SetLaminaRestLengthMult, + " " , py::arg("laminaRestLengthMult") ) + .def( + "GetWellWidth", + (double(ImmersedBoundaryMorseInteractionForce2::*)() const ) &ImmersedBoundaryMorseInteractionForce2::GetWellWidth, + " " ) + .def( + "SetWellWidth", + (void(ImmersedBoundaryMorseInteractionForce2::*)(double)) &ImmersedBoundaryMorseInteractionForce2::SetWellWidth, + " " , py::arg("wellWidth") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryMorseInteractionForce2.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundaryMorseInteractionForce2.cppwg.hpp new file mode 100644 index 00000000..72453f4c --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryMorseInteractionForce2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryMorseInteractionForce2_hpp__pyplusplus_wrapper +#define ImmersedBoundaryMorseInteractionForce2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryMorseInteractionForce2_class(py::module &m); +#endif // ImmersedBoundaryMorseInteractionForce2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryMorseInteractionForce3.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundaryMorseInteractionForce3.cppwg.cpp new file mode 100644 index 00000000..4ff6b8f1 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryMorseInteractionForce3.cppwg.cpp @@ -0,0 +1,89 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryMorseInteractionForce.hpp" + +#include "ImmersedBoundaryMorseInteractionForce3.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryMorseInteractionForce<3 > ImmersedBoundaryMorseInteractionForce3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryMorseInteractionForce3_Overloads : public ImmersedBoundaryMorseInteractionForce3{ + public: + using ImmersedBoundaryMorseInteractionForce3::ImmersedBoundaryMorseInteractionForce; + void AddImmersedBoundaryForceContribution(::std::vector *, Node<3> *>> & rNodePairs, ::ImmersedBoundaryCellPopulation<3> & rCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryMorseInteractionForce3, + AddImmersedBoundaryForceContribution, + rNodePairs, +rCellPopulation); + } + void OutputImmersedBoundaryForceParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryMorseInteractionForce3, + OutputImmersedBoundaryForceParameters, + rParamsFile); + } + +}; +void register_ImmersedBoundaryMorseInteractionForce3_class(py::module &m){ +py::class_ , AbstractImmersedBoundaryForce<3> >(m, "ImmersedBoundaryMorseInteractionForce3") + .def(py::init< >()) + .def( + "AddImmersedBoundaryForceContribution", + (void(ImmersedBoundaryMorseInteractionForce3::*)(::std::vector *, Node<3> *>> &, ::ImmersedBoundaryCellPopulation<3> &)) &ImmersedBoundaryMorseInteractionForce3::AddImmersedBoundaryForceContribution, + " " , py::arg("rNodePairs"), py::arg("rCellPopulation") ) + .def( + "OutputImmersedBoundaryForceParameters", + (void(ImmersedBoundaryMorseInteractionForce3::*)(::out_stream &)) &ImmersedBoundaryMorseInteractionForce3::OutputImmersedBoundaryForceParameters, + " " , py::arg("rParamsFile") ) + .def( + "GetWellDepth", + (double(ImmersedBoundaryMorseInteractionForce3::*)() const ) &ImmersedBoundaryMorseInteractionForce3::GetWellDepth, + " " ) + .def( + "SetWellDepth", + (void(ImmersedBoundaryMorseInteractionForce3::*)(double)) &ImmersedBoundaryMorseInteractionForce3::SetWellDepth, + " " , py::arg("wellDepth") ) + .def( + "GetRestLength", + (double(ImmersedBoundaryMorseInteractionForce3::*)() const ) &ImmersedBoundaryMorseInteractionForce3::GetRestLength, + " " ) + .def( + "SetRestLength", + (void(ImmersedBoundaryMorseInteractionForce3::*)(double)) &ImmersedBoundaryMorseInteractionForce3::SetRestLength, + " " , py::arg("restLength") ) + .def( + "GetLaminaWellDepthMult", + (double(ImmersedBoundaryMorseInteractionForce3::*)() const ) &ImmersedBoundaryMorseInteractionForce3::GetLaminaWellDepthMult, + " " ) + .def( + "SetLaminaWellDepthMult", + (void(ImmersedBoundaryMorseInteractionForce3::*)(double)) &ImmersedBoundaryMorseInteractionForce3::SetLaminaWellDepthMult, + " " , py::arg("laminaWellDepthMult") ) + .def( + "GetLaminaRestLengthMult", + (double(ImmersedBoundaryMorseInteractionForce3::*)() const ) &ImmersedBoundaryMorseInteractionForce3::GetLaminaRestLengthMult, + " " ) + .def( + "SetLaminaRestLengthMult", + (void(ImmersedBoundaryMorseInteractionForce3::*)(double)) &ImmersedBoundaryMorseInteractionForce3::SetLaminaRestLengthMult, + " " , py::arg("laminaRestLengthMult") ) + .def( + "GetWellWidth", + (double(ImmersedBoundaryMorseInteractionForce3::*)() const ) &ImmersedBoundaryMorseInteractionForce3::GetWellWidth, + " " ) + .def( + "SetWellWidth", + (void(ImmersedBoundaryMorseInteractionForce3::*)(double)) &ImmersedBoundaryMorseInteractionForce3::SetWellWidth, + " " , py::arg("wellWidth") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryMorseInteractionForce3.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundaryMorseInteractionForce3.cppwg.hpp new file mode 100644 index 00000000..3dee75eb --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryMorseInteractionForce3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryMorseInteractionForce3_hpp__pyplusplus_wrapper +#define ImmersedBoundaryMorseInteractionForce3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryMorseInteractionForce3_class(py::module &m); +#endif // ImmersedBoundaryMorseInteractionForce3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryMorseMembraneForce2.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundaryMorseMembraneForce2.cppwg.cpp new file mode 100644 index 00000000..20fcf74e --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryMorseMembraneForce2.cppwg.cpp @@ -0,0 +1,89 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryMorseMembraneForce.hpp" + +#include "ImmersedBoundaryMorseMembraneForce2.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryMorseMembraneForce<2 > ImmersedBoundaryMorseMembraneForce2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryMorseMembraneForce2_Overloads : public ImmersedBoundaryMorseMembraneForce2{ + public: + using ImmersedBoundaryMorseMembraneForce2::ImmersedBoundaryMorseMembraneForce; + void AddImmersedBoundaryForceContribution(::std::vector *, Node<2> *>> & rNodePairs, ::ImmersedBoundaryCellPopulation<2> & rCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryMorseMembraneForce2, + AddImmersedBoundaryForceContribution, + rNodePairs, +rCellPopulation); + } + void OutputImmersedBoundaryForceParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryMorseMembraneForce2, + OutputImmersedBoundaryForceParameters, + rParamsFile); + } + +}; +void register_ImmersedBoundaryMorseMembraneForce2_class(py::module &m){ +py::class_ , AbstractImmersedBoundaryForce<2> >(m, "ImmersedBoundaryMorseMembraneForce2") + .def(py::init< >()) + .def( + "AddImmersedBoundaryForceContribution", + (void(ImmersedBoundaryMorseMembraneForce2::*)(::std::vector *, Node<2> *>> &, ::ImmersedBoundaryCellPopulation<2> &)) &ImmersedBoundaryMorseMembraneForce2::AddImmersedBoundaryForceContribution, + " " , py::arg("rNodePairs"), py::arg("rCellPopulation") ) + .def( + "OutputImmersedBoundaryForceParameters", + (void(ImmersedBoundaryMorseMembraneForce2::*)(::out_stream &)) &ImmersedBoundaryMorseMembraneForce2::OutputImmersedBoundaryForceParameters, + " " , py::arg("rParamsFile") ) + .def( + "GetElementWellDepth", + (double(ImmersedBoundaryMorseMembraneForce2::*)() const ) &ImmersedBoundaryMorseMembraneForce2::GetElementWellDepth, + " " ) + .def( + "SetElementWellDepth", + (void(ImmersedBoundaryMorseMembraneForce2::*)(double)) &ImmersedBoundaryMorseMembraneForce2::SetElementWellDepth, + " " , py::arg("elementWellDepth") ) + .def( + "GetElementRestLength", + (double(ImmersedBoundaryMorseMembraneForce2::*)() const ) &ImmersedBoundaryMorseMembraneForce2::GetElementRestLength, + " " ) + .def( + "SetElementRestLength", + (void(ImmersedBoundaryMorseMembraneForce2::*)(double)) &ImmersedBoundaryMorseMembraneForce2::SetElementRestLength, + " " , py::arg("elementRestLength") ) + .def( + "GetLaminaWellDepth", + (double(ImmersedBoundaryMorseMembraneForce2::*)() const ) &ImmersedBoundaryMorseMembraneForce2::GetLaminaWellDepth, + " " ) + .def( + "SetLaminaWellDepth", + (void(ImmersedBoundaryMorseMembraneForce2::*)(double)) &ImmersedBoundaryMorseMembraneForce2::SetLaminaWellDepth, + " " , py::arg("laminaWellDepth") ) + .def( + "GetLaminaRestLength", + (double(ImmersedBoundaryMorseMembraneForce2::*)() const ) &ImmersedBoundaryMorseMembraneForce2::GetLaminaRestLength, + " " ) + .def( + "SetLaminaRestLength", + (void(ImmersedBoundaryMorseMembraneForce2::*)(double)) &ImmersedBoundaryMorseMembraneForce2::SetLaminaRestLength, + " " , py::arg("laminaRestLength") ) + .def( + "GetWellWidth", + (double(ImmersedBoundaryMorseMembraneForce2::*)() const ) &ImmersedBoundaryMorseMembraneForce2::GetWellWidth, + " " ) + .def( + "SetWellWidth", + (void(ImmersedBoundaryMorseMembraneForce2::*)(double)) &ImmersedBoundaryMorseMembraneForce2::SetWellWidth, + " " , py::arg("wellWidth") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryMorseMembraneForce2.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundaryMorseMembraneForce2.cppwg.hpp new file mode 100644 index 00000000..292f04dc --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryMorseMembraneForce2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryMorseMembraneForce2_hpp__pyplusplus_wrapper +#define ImmersedBoundaryMorseMembraneForce2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryMorseMembraneForce2_class(py::module &m); +#endif // ImmersedBoundaryMorseMembraneForce2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryMorseMembraneForce3.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundaryMorseMembraneForce3.cppwg.cpp new file mode 100644 index 00000000..0e279d29 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryMorseMembraneForce3.cppwg.cpp @@ -0,0 +1,89 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryMorseMembraneForce.hpp" + +#include "ImmersedBoundaryMorseMembraneForce3.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryMorseMembraneForce<3 > ImmersedBoundaryMorseMembraneForce3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryMorseMembraneForce3_Overloads : public ImmersedBoundaryMorseMembraneForce3{ + public: + using ImmersedBoundaryMorseMembraneForce3::ImmersedBoundaryMorseMembraneForce; + void AddImmersedBoundaryForceContribution(::std::vector *, Node<3> *>> & rNodePairs, ::ImmersedBoundaryCellPopulation<3> & rCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryMorseMembraneForce3, + AddImmersedBoundaryForceContribution, + rNodePairs, +rCellPopulation); + } + void OutputImmersedBoundaryForceParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryMorseMembraneForce3, + OutputImmersedBoundaryForceParameters, + rParamsFile); + } + +}; +void register_ImmersedBoundaryMorseMembraneForce3_class(py::module &m){ +py::class_ , AbstractImmersedBoundaryForce<3> >(m, "ImmersedBoundaryMorseMembraneForce3") + .def(py::init< >()) + .def( + "AddImmersedBoundaryForceContribution", + (void(ImmersedBoundaryMorseMembraneForce3::*)(::std::vector *, Node<3> *>> &, ::ImmersedBoundaryCellPopulation<3> &)) &ImmersedBoundaryMorseMembraneForce3::AddImmersedBoundaryForceContribution, + " " , py::arg("rNodePairs"), py::arg("rCellPopulation") ) + .def( + "OutputImmersedBoundaryForceParameters", + (void(ImmersedBoundaryMorseMembraneForce3::*)(::out_stream &)) &ImmersedBoundaryMorseMembraneForce3::OutputImmersedBoundaryForceParameters, + " " , py::arg("rParamsFile") ) + .def( + "GetElementWellDepth", + (double(ImmersedBoundaryMorseMembraneForce3::*)() const ) &ImmersedBoundaryMorseMembraneForce3::GetElementWellDepth, + " " ) + .def( + "SetElementWellDepth", + (void(ImmersedBoundaryMorseMembraneForce3::*)(double)) &ImmersedBoundaryMorseMembraneForce3::SetElementWellDepth, + " " , py::arg("elementWellDepth") ) + .def( + "GetElementRestLength", + (double(ImmersedBoundaryMorseMembraneForce3::*)() const ) &ImmersedBoundaryMorseMembraneForce3::GetElementRestLength, + " " ) + .def( + "SetElementRestLength", + (void(ImmersedBoundaryMorseMembraneForce3::*)(double)) &ImmersedBoundaryMorseMembraneForce3::SetElementRestLength, + " " , py::arg("elementRestLength") ) + .def( + "GetLaminaWellDepth", + (double(ImmersedBoundaryMorseMembraneForce3::*)() const ) &ImmersedBoundaryMorseMembraneForce3::GetLaminaWellDepth, + " " ) + .def( + "SetLaminaWellDepth", + (void(ImmersedBoundaryMorseMembraneForce3::*)(double)) &ImmersedBoundaryMorseMembraneForce3::SetLaminaWellDepth, + " " , py::arg("laminaWellDepth") ) + .def( + "GetLaminaRestLength", + (double(ImmersedBoundaryMorseMembraneForce3::*)() const ) &ImmersedBoundaryMorseMembraneForce3::GetLaminaRestLength, + " " ) + .def( + "SetLaminaRestLength", + (void(ImmersedBoundaryMorseMembraneForce3::*)(double)) &ImmersedBoundaryMorseMembraneForce3::SetLaminaRestLength, + " " , py::arg("laminaRestLength") ) + .def( + "GetWellWidth", + (double(ImmersedBoundaryMorseMembraneForce3::*)() const ) &ImmersedBoundaryMorseMembraneForce3::GetWellWidth, + " " ) + .def( + "SetWellWidth", + (void(ImmersedBoundaryMorseMembraneForce3::*)(double)) &ImmersedBoundaryMorseMembraneForce3::SetWellWidth, + " " , py::arg("wellWidth") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryMorseMembraneForce3.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundaryMorseMembraneForce3.cppwg.hpp new file mode 100644 index 00000000..f2f70f77 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryMorseMembraneForce3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryMorseMembraneForce3_hpp__pyplusplus_wrapper +#define ImmersedBoundaryMorseMembraneForce3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryMorseMembraneForce3_class(py::module &m); +#endif // ImmersedBoundaryMorseMembraneForce3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryNeighbourNumberWriter2_2.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundaryNeighbourNumberWriter2_2.cppwg.cpp new file mode 100644 index 00000000..7b1eab55 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryNeighbourNumberWriter2_2.cppwg.cpp @@ -0,0 +1,51 @@ +#include +#include +#include "ImmersedBoundaryCellPopulation.hpp" +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryNeighbourNumberWriter.hpp" + +#include "ImmersedBoundaryNeighbourNumberWriter2_2.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryNeighbourNumberWriter<2,2 > ImmersedBoundaryNeighbourNumberWriter2_2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryNeighbourNumberWriter2_2_Overloads : public ImmersedBoundaryNeighbourNumberWriter2_2{ + public: + using ImmersedBoundaryNeighbourNumberWriter2_2::ImmersedBoundaryNeighbourNumberWriter; + double GetCellDataForVtkOutput(::CellPtr pCell, ::AbstractCellPopulation<2> * pCellPopulation) override { + PYBIND11_OVERLOAD( + double, + ImmersedBoundaryNeighbourNumberWriter2_2, + GetCellDataForVtkOutput, + pCell, +pCellPopulation); + } + void VisitCell(::CellPtr pCell, ::AbstractCellPopulation<2> * pCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryNeighbourNumberWriter2_2, + VisitCell, + pCell, +pCellPopulation); + } + +}; +void register_ImmersedBoundaryNeighbourNumberWriter2_2_class(py::module &m){ +py::class_ , AbstractCellWriter<2, 2> >(m, "ImmersedBoundaryNeighbourNumberWriter2_2") + .def(py::init< >()) + .def( + "GetCellDataForVtkOutput", + (double(ImmersedBoundaryNeighbourNumberWriter2_2::*)(::CellPtr, ::AbstractCellPopulation<2> *)) &ImmersedBoundaryNeighbourNumberWriter2_2::GetCellDataForVtkOutput, + " " , py::arg("pCell"), py::arg("pCellPopulation") ) + .def( + "VisitCell", + (void(ImmersedBoundaryNeighbourNumberWriter2_2::*)(::CellPtr, ::AbstractCellPopulation<2> *)) &ImmersedBoundaryNeighbourNumberWriter2_2::VisitCell, + " " , py::arg("pCell"), py::arg("pCellPopulation") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryNeighbourNumberWriter2_2.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundaryNeighbourNumberWriter2_2.cppwg.hpp new file mode 100644 index 00000000..dc47c685 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryNeighbourNumberWriter2_2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryNeighbourNumberWriter2_2_hpp__pyplusplus_wrapper +#define ImmersedBoundaryNeighbourNumberWriter2_2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryNeighbourNumberWriter2_2_class(py::module &m); +#endif // ImmersedBoundaryNeighbourNumberWriter2_2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryNeighbourNumberWriter3_3.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundaryNeighbourNumberWriter3_3.cppwg.cpp new file mode 100644 index 00000000..e16c4011 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryNeighbourNumberWriter3_3.cppwg.cpp @@ -0,0 +1,51 @@ +#include +#include +#include "ImmersedBoundaryCellPopulation.hpp" +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryNeighbourNumberWriter.hpp" + +#include "ImmersedBoundaryNeighbourNumberWriter3_3.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryNeighbourNumberWriter<3,3 > ImmersedBoundaryNeighbourNumberWriter3_3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryNeighbourNumberWriter3_3_Overloads : public ImmersedBoundaryNeighbourNumberWriter3_3{ + public: + using ImmersedBoundaryNeighbourNumberWriter3_3::ImmersedBoundaryNeighbourNumberWriter; + double GetCellDataForVtkOutput(::CellPtr pCell, ::AbstractCellPopulation<3> * pCellPopulation) override { + PYBIND11_OVERLOAD( + double, + ImmersedBoundaryNeighbourNumberWriter3_3, + GetCellDataForVtkOutput, + pCell, +pCellPopulation); + } + void VisitCell(::CellPtr pCell, ::AbstractCellPopulation<3> * pCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryNeighbourNumberWriter3_3, + VisitCell, + pCell, +pCellPopulation); + } + +}; +void register_ImmersedBoundaryNeighbourNumberWriter3_3_class(py::module &m){ +py::class_ , AbstractCellWriter<3, 3> >(m, "ImmersedBoundaryNeighbourNumberWriter3_3") + .def(py::init< >()) + .def( + "GetCellDataForVtkOutput", + (double(ImmersedBoundaryNeighbourNumberWriter3_3::*)(::CellPtr, ::AbstractCellPopulation<3> *)) &ImmersedBoundaryNeighbourNumberWriter3_3::GetCellDataForVtkOutput, + " " , py::arg("pCell"), py::arg("pCellPopulation") ) + .def( + "VisitCell", + (void(ImmersedBoundaryNeighbourNumberWriter3_3::*)(::CellPtr, ::AbstractCellPopulation<3> *)) &ImmersedBoundaryNeighbourNumberWriter3_3::VisitCell, + " " , py::arg("pCell"), py::arg("pCellPopulation") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundaryNeighbourNumberWriter3_3.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundaryNeighbourNumberWriter3_3.cppwg.hpp new file mode 100644 index 00000000..66bf0516 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundaryNeighbourNumberWriter3_3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryNeighbourNumberWriter3_3_hpp__pyplusplus_wrapper +#define ImmersedBoundaryNeighbourNumberWriter3_3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryNeighbourNumberWriter3_3_class(py::module &m); +#endif // ImmersedBoundaryNeighbourNumberWriter3_3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundarySimulationModifier2.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundarySimulationModifier2.cppwg.cpp new file mode 100644 index 00000000..3579889c --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundarySimulationModifier2.cppwg.cpp @@ -0,0 +1,124 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundarySimulationModifier.hpp" + +#include "ImmersedBoundarySimulationModifier2.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundarySimulationModifier<2 > ImmersedBoundarySimulationModifier2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundarySimulationModifier2_Overloads : public ImmersedBoundarySimulationModifier2{ + public: + using ImmersedBoundarySimulationModifier2::ImmersedBoundarySimulationModifier; + void UpdateAtEndOfTimeStep(::AbstractCellPopulation<2> & rCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundarySimulationModifier2, + UpdateAtEndOfTimeStep, + rCellPopulation); + } + void SetupSolve(::AbstractCellPopulation<2> & rCellPopulation, ::std::string outputDirectory) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundarySimulationModifier2, + SetupSolve, + rCellPopulation, +outputDirectory); + } + void OutputSimulationModifierParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundarySimulationModifier2, + OutputSimulationModifierParameters, + rParamsFile); + } + +}; +void register_ImmersedBoundarySimulationModifier2_class(py::module &m){ +py::class_ , AbstractCellBasedSimulationModifier<2> >(m, "ImmersedBoundarySimulationModifier2") + .def(py::init< >()) + .def( + "UpdateAtEndOfTimeStep", + (void(ImmersedBoundarySimulationModifier2::*)(::AbstractCellPopulation<2> &)) &ImmersedBoundarySimulationModifier2::UpdateAtEndOfTimeStep, + " " , py::arg("rCellPopulation") ) + .def( + "SetupSolve", + (void(ImmersedBoundarySimulationModifier2::*)(::AbstractCellPopulation<2> &, ::std::string)) &ImmersedBoundarySimulationModifier2::SetupSolve, + " " , py::arg("rCellPopulation"), py::arg("outputDirectory") ) + .def( + "OutputSimulationModifierParameters", + (void(ImmersedBoundarySimulationModifier2::*)(::out_stream &)) &ImmersedBoundarySimulationModifier2::OutputSimulationModifierParameters, + " " , py::arg("rParamsFile") ) + .def( + "SetNodeNeighbourUpdateFrequency", + (void(ImmersedBoundarySimulationModifier2::*)(unsigned int)) &ImmersedBoundarySimulationModifier2::SetNodeNeighbourUpdateFrequency, + " " , py::arg("newFrequency") ) + .def( + "GetNodeNeighbourUpdateFrequency", + (unsigned int(ImmersedBoundarySimulationModifier2::*)()) &ImmersedBoundarySimulationModifier2::GetNodeNeighbourUpdateFrequency, + " " ) + .def( + "AddImmersedBoundaryForce", + (void(ImmersedBoundarySimulationModifier2::*)(::boost::shared_ptr>)) &ImmersedBoundarySimulationModifier2::AddImmersedBoundaryForce, + " " , py::arg("pForce") ) + .def( + "AddNormalNoise", + (void(ImmersedBoundarySimulationModifier2::*)() const ) &ImmersedBoundarySimulationModifier2::AddNormalNoise, + " " ) + .def( + "GetZeroFieldSums", + (bool(ImmersedBoundarySimulationModifier2::*)() const ) &ImmersedBoundarySimulationModifier2::GetZeroFieldSums, + " " ) + .def( + "SetZeroFieldSums", + (void(ImmersedBoundarySimulationModifier2::*)(bool)) &ImmersedBoundarySimulationModifier2::SetZeroFieldSums, + " " , py::arg("zeroFieldSums") ) + .def( + "SetReynoldsNumber", + (void(ImmersedBoundarySimulationModifier2::*)(double)) &ImmersedBoundarySimulationModifier2::SetReynoldsNumber, + " " , py::arg("reynoldsNumber") ) + .def( + "GetReynoldsNumber", + (double(ImmersedBoundarySimulationModifier2::*)()) &ImmersedBoundarySimulationModifier2::GetReynoldsNumber, + " " ) + .def( + "GetAdditiveNormalNoise", + (bool(ImmersedBoundarySimulationModifier2::*)() const ) &ImmersedBoundarySimulationModifier2::GetAdditiveNormalNoise, + " " ) + .def( + "SetAdditiveNormalNoise", + (void(ImmersedBoundarySimulationModifier2::*)(bool)) &ImmersedBoundarySimulationModifier2::SetAdditiveNormalNoise, + " " , py::arg("additiveNormalNoise") ) + .def( + "GetNoiseStrength", + (double(ImmersedBoundarySimulationModifier2::*)() const ) &ImmersedBoundarySimulationModifier2::GetNoiseStrength, + " " ) + .def( + "SetNoiseStrength", + (void(ImmersedBoundarySimulationModifier2::*)(double)) &ImmersedBoundarySimulationModifier2::SetNoiseStrength, + " " , py::arg("noiseStrength") ) + .def( + "GetNoiseSkip", + (unsigned int(ImmersedBoundarySimulationModifier2::*)() const ) &ImmersedBoundarySimulationModifier2::GetNoiseSkip, + " " ) + .def( + "SetNoiseSkip", + (void(ImmersedBoundarySimulationModifier2::*)(unsigned int)) &ImmersedBoundarySimulationModifier2::SetNoiseSkip, + " " , py::arg("noiseSkip") ) + .def( + "GetNoiseLengthScale", + (double(ImmersedBoundarySimulationModifier2::*)() const ) &ImmersedBoundarySimulationModifier2::GetNoiseLengthScale, + " " ) + .def( + "SetNoiseLengthScale", + (void(ImmersedBoundarySimulationModifier2::*)(double)) &ImmersedBoundarySimulationModifier2::SetNoiseLengthScale, + " " , py::arg("noiseLengthScale") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundarySimulationModifier2.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundarySimulationModifier2.cppwg.hpp new file mode 100644 index 00000000..ef1de78b --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundarySimulationModifier2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundarySimulationModifier2_hpp__pyplusplus_wrapper +#define ImmersedBoundarySimulationModifier2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundarySimulationModifier2_class(py::module &m); +#endif // ImmersedBoundarySimulationModifier2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundarySimulationModifier3.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundarySimulationModifier3.cppwg.cpp new file mode 100644 index 00000000..186fb245 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundarySimulationModifier3.cppwg.cpp @@ -0,0 +1,124 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundarySimulationModifier.hpp" + +#include "ImmersedBoundarySimulationModifier3.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundarySimulationModifier<3 > ImmersedBoundarySimulationModifier3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundarySimulationModifier3_Overloads : public ImmersedBoundarySimulationModifier3{ + public: + using ImmersedBoundarySimulationModifier3::ImmersedBoundarySimulationModifier; + void UpdateAtEndOfTimeStep(::AbstractCellPopulation<3> & rCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundarySimulationModifier3, + UpdateAtEndOfTimeStep, + rCellPopulation); + } + void SetupSolve(::AbstractCellPopulation<3> & rCellPopulation, ::std::string outputDirectory) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundarySimulationModifier3, + SetupSolve, + rCellPopulation, +outputDirectory); + } + void OutputSimulationModifierParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundarySimulationModifier3, + OutputSimulationModifierParameters, + rParamsFile); + } + +}; +void register_ImmersedBoundarySimulationModifier3_class(py::module &m){ +py::class_ , AbstractCellBasedSimulationModifier<3> >(m, "ImmersedBoundarySimulationModifier3") + .def(py::init< >()) + .def( + "UpdateAtEndOfTimeStep", + (void(ImmersedBoundarySimulationModifier3::*)(::AbstractCellPopulation<3> &)) &ImmersedBoundarySimulationModifier3::UpdateAtEndOfTimeStep, + " " , py::arg("rCellPopulation") ) + .def( + "SetupSolve", + (void(ImmersedBoundarySimulationModifier3::*)(::AbstractCellPopulation<3> &, ::std::string)) &ImmersedBoundarySimulationModifier3::SetupSolve, + " " , py::arg("rCellPopulation"), py::arg("outputDirectory") ) + .def( + "OutputSimulationModifierParameters", + (void(ImmersedBoundarySimulationModifier3::*)(::out_stream &)) &ImmersedBoundarySimulationModifier3::OutputSimulationModifierParameters, + " " , py::arg("rParamsFile") ) + .def( + "SetNodeNeighbourUpdateFrequency", + (void(ImmersedBoundarySimulationModifier3::*)(unsigned int)) &ImmersedBoundarySimulationModifier3::SetNodeNeighbourUpdateFrequency, + " " , py::arg("newFrequency") ) + .def( + "GetNodeNeighbourUpdateFrequency", + (unsigned int(ImmersedBoundarySimulationModifier3::*)()) &ImmersedBoundarySimulationModifier3::GetNodeNeighbourUpdateFrequency, + " " ) + .def( + "AddImmersedBoundaryForce", + (void(ImmersedBoundarySimulationModifier3::*)(::boost::shared_ptr>)) &ImmersedBoundarySimulationModifier3::AddImmersedBoundaryForce, + " " , py::arg("pForce") ) + .def( + "AddNormalNoise", + (void(ImmersedBoundarySimulationModifier3::*)() const ) &ImmersedBoundarySimulationModifier3::AddNormalNoise, + " " ) + .def( + "GetZeroFieldSums", + (bool(ImmersedBoundarySimulationModifier3::*)() const ) &ImmersedBoundarySimulationModifier3::GetZeroFieldSums, + " " ) + .def( + "SetZeroFieldSums", + (void(ImmersedBoundarySimulationModifier3::*)(bool)) &ImmersedBoundarySimulationModifier3::SetZeroFieldSums, + " " , py::arg("zeroFieldSums") ) + .def( + "SetReynoldsNumber", + (void(ImmersedBoundarySimulationModifier3::*)(double)) &ImmersedBoundarySimulationModifier3::SetReynoldsNumber, + " " , py::arg("reynoldsNumber") ) + .def( + "GetReynoldsNumber", + (double(ImmersedBoundarySimulationModifier3::*)()) &ImmersedBoundarySimulationModifier3::GetReynoldsNumber, + " " ) + .def( + "GetAdditiveNormalNoise", + (bool(ImmersedBoundarySimulationModifier3::*)() const ) &ImmersedBoundarySimulationModifier3::GetAdditiveNormalNoise, + " " ) + .def( + "SetAdditiveNormalNoise", + (void(ImmersedBoundarySimulationModifier3::*)(bool)) &ImmersedBoundarySimulationModifier3::SetAdditiveNormalNoise, + " " , py::arg("additiveNormalNoise") ) + .def( + "GetNoiseStrength", + (double(ImmersedBoundarySimulationModifier3::*)() const ) &ImmersedBoundarySimulationModifier3::GetNoiseStrength, + " " ) + .def( + "SetNoiseStrength", + (void(ImmersedBoundarySimulationModifier3::*)(double)) &ImmersedBoundarySimulationModifier3::SetNoiseStrength, + " " , py::arg("noiseStrength") ) + .def( + "GetNoiseSkip", + (unsigned int(ImmersedBoundarySimulationModifier3::*)() const ) &ImmersedBoundarySimulationModifier3::GetNoiseSkip, + " " ) + .def( + "SetNoiseSkip", + (void(ImmersedBoundarySimulationModifier3::*)(unsigned int)) &ImmersedBoundarySimulationModifier3::SetNoiseSkip, + " " , py::arg("noiseSkip") ) + .def( + "GetNoiseLengthScale", + (double(ImmersedBoundarySimulationModifier3::*)() const ) &ImmersedBoundarySimulationModifier3::GetNoiseLengthScale, + " " ) + .def( + "SetNoiseLengthScale", + (void(ImmersedBoundarySimulationModifier3::*)(double)) &ImmersedBoundarySimulationModifier3::SetNoiseLengthScale, + " " , py::arg("noiseLengthScale") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundarySimulationModifier3.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundarySimulationModifier3.cppwg.hpp new file mode 100644 index 00000000..29009ea0 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundarySimulationModifier3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundarySimulationModifier3_hpp__pyplusplus_wrapper +#define ImmersedBoundarySimulationModifier3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundarySimulationModifier3_class(py::module &m); +#endif // ImmersedBoundarySimulationModifier3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundarySvgWriter2.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundarySvgWriter2.cppwg.cpp new file mode 100644 index 00000000..5fdbf34a --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundarySvgWriter2.cppwg.cpp @@ -0,0 +1,80 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundarySvgWriter.hpp" + +#include "ImmersedBoundarySvgWriter2.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundarySvgWriter<2 > ImmersedBoundarySvgWriter2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundarySvgWriter2_Overloads : public ImmersedBoundarySvgWriter2{ + public: + using ImmersedBoundarySvgWriter2::ImmersedBoundarySvgWriter; + void UpdateAtEndOfTimeStep(::AbstractCellPopulation<2> & rCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundarySvgWriter2, + UpdateAtEndOfTimeStep, + rCellPopulation); + } + void SetupSolve(::AbstractCellPopulation<2> & rCellPopulation, ::std::string outputDirectory) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundarySvgWriter2, + SetupSolve, + rCellPopulation, +outputDirectory); + } + void OutputSimulationModifierParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundarySvgWriter2, + OutputSimulationModifierParameters, + rParamsFile); + } + +}; +void register_ImmersedBoundarySvgWriter2_class(py::module &m){ +py::class_ , AbstractCellBasedSimulationModifier<2> >(m, "ImmersedBoundarySvgWriter2") + .def(py::init< >()) + .def( + "UpdateAtEndOfTimeStep", + (void(ImmersedBoundarySvgWriter2::*)(::AbstractCellPopulation<2> &)) &ImmersedBoundarySvgWriter2::UpdateAtEndOfTimeStep, + " " , py::arg("rCellPopulation") ) + .def( + "SetupSolve", + (void(ImmersedBoundarySvgWriter2::*)(::AbstractCellPopulation<2> &, ::std::string)) &ImmersedBoundarySvgWriter2::SetupSolve, + " " , py::arg("rCellPopulation"), py::arg("outputDirectory") ) + .def( + "AddPointToSvgFile", + (void(ImmersedBoundarySvgWriter2::*)(::out_stream &, ::boost::numeric::ublas::c_vector, unsigned int, double)) &ImmersedBoundarySvgWriter2::AddPointToSvgFile, + " " , py::arg("rSvgFile"), py::arg("location"), py::arg("region"), py::arg("rad") ) + .def( + "OutputSimulationModifierParameters", + (void(ImmersedBoundarySvgWriter2::*)(::out_stream &)) &ImmersedBoundarySvgWriter2::OutputSimulationModifierParameters, + " " , py::arg("rParamsFile") ) + .def( + "GetSamplingMultiple", + (unsigned int(ImmersedBoundarySvgWriter2::*)() const ) &ImmersedBoundarySvgWriter2::GetSamplingMultiple, + " " ) + .def( + "SetSamplingMultiple", + (void(ImmersedBoundarySvgWriter2::*)(unsigned int)) &ImmersedBoundarySvgWriter2::SetSamplingMultiple, + " " , py::arg("samplingMultiple") ) + .def( + "GetSvgSize", + (double(ImmersedBoundarySvgWriter2::*)() const ) &ImmersedBoundarySvgWriter2::GetSvgSize, + " " ) + .def( + "SetSvgSize", + (void(ImmersedBoundarySvgWriter2::*)(double)) &ImmersedBoundarySvgWriter2::SetSvgSize, + " " , py::arg("svgSize") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundarySvgWriter2.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundarySvgWriter2.cppwg.hpp new file mode 100644 index 00000000..d27918ab --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundarySvgWriter2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundarySvgWriter2_hpp__pyplusplus_wrapper +#define ImmersedBoundarySvgWriter2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundarySvgWriter2_class(py::module &m); +#endif // ImmersedBoundarySvgWriter2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ImmersedBoundarySvgWriter3.cppwg.cpp b/dynamic/wrappers/cell_based/ImmersedBoundarySvgWriter3.cppwg.cpp new file mode 100644 index 00000000..524d5668 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundarySvgWriter3.cppwg.cpp @@ -0,0 +1,80 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundarySvgWriter.hpp" + +#include "ImmersedBoundarySvgWriter3.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundarySvgWriter<3 > ImmersedBoundarySvgWriter3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundarySvgWriter3_Overloads : public ImmersedBoundarySvgWriter3{ + public: + using ImmersedBoundarySvgWriter3::ImmersedBoundarySvgWriter; + void UpdateAtEndOfTimeStep(::AbstractCellPopulation<3> & rCellPopulation) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundarySvgWriter3, + UpdateAtEndOfTimeStep, + rCellPopulation); + } + void SetupSolve(::AbstractCellPopulation<3> & rCellPopulation, ::std::string outputDirectory) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundarySvgWriter3, + SetupSolve, + rCellPopulation, +outputDirectory); + } + void OutputSimulationModifierParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundarySvgWriter3, + OutputSimulationModifierParameters, + rParamsFile); + } + +}; +void register_ImmersedBoundarySvgWriter3_class(py::module &m){ +py::class_ , AbstractCellBasedSimulationModifier<3> >(m, "ImmersedBoundarySvgWriter3") + .def(py::init< >()) + .def( + "UpdateAtEndOfTimeStep", + (void(ImmersedBoundarySvgWriter3::*)(::AbstractCellPopulation<3> &)) &ImmersedBoundarySvgWriter3::UpdateAtEndOfTimeStep, + " " , py::arg("rCellPopulation") ) + .def( + "SetupSolve", + (void(ImmersedBoundarySvgWriter3::*)(::AbstractCellPopulation<3> &, ::std::string)) &ImmersedBoundarySvgWriter3::SetupSolve, + " " , py::arg("rCellPopulation"), py::arg("outputDirectory") ) + .def( + "AddPointToSvgFile", + (void(ImmersedBoundarySvgWriter3::*)(::out_stream &, ::boost::numeric::ublas::c_vector, unsigned int, double)) &ImmersedBoundarySvgWriter3::AddPointToSvgFile, + " " , py::arg("rSvgFile"), py::arg("location"), py::arg("region"), py::arg("rad") ) + .def( + "OutputSimulationModifierParameters", + (void(ImmersedBoundarySvgWriter3::*)(::out_stream &)) &ImmersedBoundarySvgWriter3::OutputSimulationModifierParameters, + " " , py::arg("rParamsFile") ) + .def( + "GetSamplingMultiple", + (unsigned int(ImmersedBoundarySvgWriter3::*)() const ) &ImmersedBoundarySvgWriter3::GetSamplingMultiple, + " " ) + .def( + "SetSamplingMultiple", + (void(ImmersedBoundarySvgWriter3::*)(unsigned int)) &ImmersedBoundarySvgWriter3::SetSamplingMultiple, + " " , py::arg("samplingMultiple") ) + .def( + "GetSvgSize", + (double(ImmersedBoundarySvgWriter3::*)() const ) &ImmersedBoundarySvgWriter3::GetSvgSize, + " " ) + .def( + "SetSvgSize", + (void(ImmersedBoundarySvgWriter3::*)(double)) &ImmersedBoundarySvgWriter3::SetSvgSize, + " " , py::arg("svgSize") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ImmersedBoundarySvgWriter3.cppwg.hpp b/dynamic/wrappers/cell_based/ImmersedBoundarySvgWriter3.cppwg.hpp new file mode 100644 index 00000000..f3497156 --- /dev/null +++ b/dynamic/wrappers/cell_based/ImmersedBoundarySvgWriter3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundarySvgWriter3_hpp__pyplusplus_wrapper +#define ImmersedBoundarySvgWriter3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundarySvgWriter3_class(py::module &m); +#endif // ImmersedBoundarySvgWriter3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/NormallyDistributedTargetAreaModifier2.cppwg.cpp b/dynamic/wrappers/cell_based/NormallyDistributedTargetAreaModifier2.cppwg.cpp new file mode 100644 index 00000000..d9d99ffa --- /dev/null +++ b/dynamic/wrappers/cell_based/NormallyDistributedTargetAreaModifier2.cppwg.cpp @@ -0,0 +1,56 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "NormallyDistributedTargetAreaModifier.hpp" + +#include "NormallyDistributedTargetAreaModifier2.cppwg.hpp" + +namespace py = pybind11; +typedef NormallyDistributedTargetAreaModifier<2 > NormallyDistributedTargetAreaModifier2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class NormallyDistributedTargetAreaModifier2_Overloads : public NormallyDistributedTargetAreaModifier2{ + public: + using NormallyDistributedTargetAreaModifier2::NormallyDistributedTargetAreaModifier; + void UpdateTargetAreaOfCell(::CellPtr const pCell) override { + PYBIND11_OVERLOAD( + void, + NormallyDistributedTargetAreaModifier2, + UpdateTargetAreaOfCell, + pCell); + } + void OutputSimulationModifierParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + NormallyDistributedTargetAreaModifier2, + OutputSimulationModifierParameters, + rParamsFile); + } + +}; +void register_NormallyDistributedTargetAreaModifier2_class(py::module &m){ +py::class_ , AbstractTargetAreaModifier<2> >(m, "NormallyDistributedTargetAreaModifier2") + .def(py::init< >()) + .def( + "UpdateTargetAreaOfCell", + (void(NormallyDistributedTargetAreaModifier2::*)(::CellPtr const)) &NormallyDistributedTargetAreaModifier2::UpdateTargetAreaOfCell, + " " , py::arg("pCell") ) + .def( + "GetGrowthDuration", + (double(NormallyDistributedTargetAreaModifier2::*)()) &NormallyDistributedTargetAreaModifier2::GetGrowthDuration, + " " ) + .def( + "SetGrowthDuration", + (void(NormallyDistributedTargetAreaModifier2::*)(double)) &NormallyDistributedTargetAreaModifier2::SetGrowthDuration, + " " , py::arg("growthDuration") ) + .def( + "OutputSimulationModifierParameters", + (void(NormallyDistributedTargetAreaModifier2::*)(::out_stream &)) &NormallyDistributedTargetAreaModifier2::OutputSimulationModifierParameters, + " " , py::arg("rParamsFile") ) + ; +} diff --git a/dynamic/wrappers/cell_based/NormallyDistributedTargetAreaModifier2.cppwg.hpp b/dynamic/wrappers/cell_based/NormallyDistributedTargetAreaModifier2.cppwg.hpp new file mode 100644 index 00000000..7b27f8b9 --- /dev/null +++ b/dynamic/wrappers/cell_based/NormallyDistributedTargetAreaModifier2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef NormallyDistributedTargetAreaModifier2_hpp__pyplusplus_wrapper +#define NormallyDistributedTargetAreaModifier2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_NormallyDistributedTargetAreaModifier2_class(py::module &m); +#endif // NormallyDistributedTargetAreaModifier2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/NormallyDistributedTargetAreaModifier3.cppwg.cpp b/dynamic/wrappers/cell_based/NormallyDistributedTargetAreaModifier3.cppwg.cpp new file mode 100644 index 00000000..8155fbc6 --- /dev/null +++ b/dynamic/wrappers/cell_based/NormallyDistributedTargetAreaModifier3.cppwg.cpp @@ -0,0 +1,56 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "NormallyDistributedTargetAreaModifier.hpp" + +#include "NormallyDistributedTargetAreaModifier3.cppwg.hpp" + +namespace py = pybind11; +typedef NormallyDistributedTargetAreaModifier<3 > NormallyDistributedTargetAreaModifier3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class NormallyDistributedTargetAreaModifier3_Overloads : public NormallyDistributedTargetAreaModifier3{ + public: + using NormallyDistributedTargetAreaModifier3::NormallyDistributedTargetAreaModifier; + void UpdateTargetAreaOfCell(::CellPtr const pCell) override { + PYBIND11_OVERLOAD( + void, + NormallyDistributedTargetAreaModifier3, + UpdateTargetAreaOfCell, + pCell); + } + void OutputSimulationModifierParameters(::out_stream & rParamsFile) override { + PYBIND11_OVERLOAD( + void, + NormallyDistributedTargetAreaModifier3, + OutputSimulationModifierParameters, + rParamsFile); + } + +}; +void register_NormallyDistributedTargetAreaModifier3_class(py::module &m){ +py::class_ , AbstractTargetAreaModifier<3> >(m, "NormallyDistributedTargetAreaModifier3") + .def(py::init< >()) + .def( + "UpdateTargetAreaOfCell", + (void(NormallyDistributedTargetAreaModifier3::*)(::CellPtr const)) &NormallyDistributedTargetAreaModifier3::UpdateTargetAreaOfCell, + " " , py::arg("pCell") ) + .def( + "GetGrowthDuration", + (double(NormallyDistributedTargetAreaModifier3::*)()) &NormallyDistributedTargetAreaModifier3::GetGrowthDuration, + " " ) + .def( + "SetGrowthDuration", + (void(NormallyDistributedTargetAreaModifier3::*)(double)) &NormallyDistributedTargetAreaModifier3::SetGrowthDuration, + " " , py::arg("growthDuration") ) + .def( + "OutputSimulationModifierParameters", + (void(NormallyDistributedTargetAreaModifier3::*)(::out_stream &)) &NormallyDistributedTargetAreaModifier3::OutputSimulationModifierParameters, + " " , py::arg("rParamsFile") ) + ; +} diff --git a/dynamic/wrappers/cell_based/NormallyDistributedTargetAreaModifier3.cppwg.hpp b/dynamic/wrappers/cell_based/NormallyDistributedTargetAreaModifier3.cppwg.hpp new file mode 100644 index 00000000..716e2bf9 --- /dev/null +++ b/dynamic/wrappers/cell_based/NormallyDistributedTargetAreaModifier3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef NormallyDistributedTargetAreaModifier3_hpp__pyplusplus_wrapper +#define NormallyDistributedTargetAreaModifier3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_NormallyDistributedTargetAreaModifier3_class(py::module &m); +#endif // NormallyDistributedTargetAreaModifier3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/RandomDirectionCentreBasedDivisionRule2_2.cppwg.cpp b/dynamic/wrappers/cell_based/RandomDirectionCentreBasedDivisionRule2_2.cppwg.cpp new file mode 100644 index 00000000..872a83f0 --- /dev/null +++ b/dynamic/wrappers/cell_based/RandomDirectionCentreBasedDivisionRule2_2.cppwg.cpp @@ -0,0 +1,39 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "RandomDirectionCentreBasedDivisionRule.hpp" + +#include "RandomDirectionCentreBasedDivisionRule2_2.cppwg.hpp" + +namespace py = pybind11; +typedef RandomDirectionCentreBasedDivisionRule<2 > RandomDirectionCentreBasedDivisionRule2_2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); +typedef ::std::pair, boost::numeric::ublas::c_vector> _std_pair_lt_boost_numeric_ublas_c_vector_lt_double_2_gt__boost_numeric_ublas_c_vector_lt_double_2_gt__gt_; + +class RandomDirectionCentreBasedDivisionRule2_2_Overloads : public RandomDirectionCentreBasedDivisionRule2_2{ + public: + using RandomDirectionCentreBasedDivisionRule2_2::RandomDirectionCentreBasedDivisionRule; + ::std::pair, boost::numeric::ublas::c_vector> CalculateCellDivisionVector(::CellPtr pParentCell, ::AbstractCentreBasedCellPopulation<2, 2> & rCellPopulation) override { + PYBIND11_OVERLOAD( + _std_pair_lt_boost_numeric_ublas_c_vector_lt_double_2_gt__boost_numeric_ublas_c_vector_lt_double_2_gt__gt_, + RandomDirectionCentreBasedDivisionRule2_2, + CalculateCellDivisionVector, + pParentCell, +rCellPopulation); + } + +}; +void register_RandomDirectionCentreBasedDivisionRule2_2_class(py::module &m){ +py::class_ , AbstractCentreBasedDivisionRule<2> >(m, "RandomDirectionCentreBasedDivisionRule2_2") + .def(py::init< >()) + .def( + "CalculateCellDivisionVector", + (::std::pair, boost::numeric::ublas::c_vector>(RandomDirectionCentreBasedDivisionRule2_2::*)(::CellPtr, ::AbstractCentreBasedCellPopulation<2, 2> &)) &RandomDirectionCentreBasedDivisionRule2_2::CalculateCellDivisionVector, + " " , py::arg("pParentCell"), py::arg("rCellPopulation") ) + ; +} diff --git a/dynamic/wrappers/cell_based/RandomDirectionCentreBasedDivisionRule2_2.cppwg.hpp b/dynamic/wrappers/cell_based/RandomDirectionCentreBasedDivisionRule2_2.cppwg.hpp new file mode 100644 index 00000000..be2dc4af --- /dev/null +++ b/dynamic/wrappers/cell_based/RandomDirectionCentreBasedDivisionRule2_2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef RandomDirectionCentreBasedDivisionRule2_2_hpp__pyplusplus_wrapper +#define RandomDirectionCentreBasedDivisionRule2_2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_RandomDirectionCentreBasedDivisionRule2_2_class(py::module &m); +#endif // RandomDirectionCentreBasedDivisionRule2_2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/RandomDirectionCentreBasedDivisionRule3_3.cppwg.cpp b/dynamic/wrappers/cell_based/RandomDirectionCentreBasedDivisionRule3_3.cppwg.cpp new file mode 100644 index 00000000..c97eb2c3 --- /dev/null +++ b/dynamic/wrappers/cell_based/RandomDirectionCentreBasedDivisionRule3_3.cppwg.cpp @@ -0,0 +1,39 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "RandomDirectionCentreBasedDivisionRule.hpp" + +#include "RandomDirectionCentreBasedDivisionRule3_3.cppwg.hpp" + +namespace py = pybind11; +typedef RandomDirectionCentreBasedDivisionRule<3 > RandomDirectionCentreBasedDivisionRule3_3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); +typedef ::std::pair, boost::numeric::ublas::c_vector> _std_pair_lt_boost_numeric_ublas_c_vector_lt_double_3_gt__boost_numeric_ublas_c_vector_lt_double_3_gt__gt_; + +class RandomDirectionCentreBasedDivisionRule3_3_Overloads : public RandomDirectionCentreBasedDivisionRule3_3{ + public: + using RandomDirectionCentreBasedDivisionRule3_3::RandomDirectionCentreBasedDivisionRule; + ::std::pair, boost::numeric::ublas::c_vector> CalculateCellDivisionVector(::CellPtr pParentCell, ::AbstractCentreBasedCellPopulation<3, 3> & rCellPopulation) override { + PYBIND11_OVERLOAD( + _std_pair_lt_boost_numeric_ublas_c_vector_lt_double_3_gt__boost_numeric_ublas_c_vector_lt_double_3_gt__gt_, + RandomDirectionCentreBasedDivisionRule3_3, + CalculateCellDivisionVector, + pParentCell, +rCellPopulation); + } + +}; +void register_RandomDirectionCentreBasedDivisionRule3_3_class(py::module &m){ +py::class_ , AbstractCentreBasedDivisionRule<3> >(m, "RandomDirectionCentreBasedDivisionRule3_3") + .def(py::init< >()) + .def( + "CalculateCellDivisionVector", + (::std::pair, boost::numeric::ublas::c_vector>(RandomDirectionCentreBasedDivisionRule3_3::*)(::CellPtr, ::AbstractCentreBasedCellPopulation<3, 3> &)) &RandomDirectionCentreBasedDivisionRule3_3::CalculateCellDivisionVector, + " " , py::arg("pParentCell"), py::arg("rCellPopulation") ) + ; +} diff --git a/dynamic/wrappers/cell_based/RandomDirectionCentreBasedDivisionRule3_3.cppwg.hpp b/dynamic/wrappers/cell_based/RandomDirectionCentreBasedDivisionRule3_3.cppwg.hpp new file mode 100644 index 00000000..65ac131b --- /dev/null +++ b/dynamic/wrappers/cell_based/RandomDirectionCentreBasedDivisionRule3_3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef RandomDirectionCentreBasedDivisionRule3_3_hpp__pyplusplus_wrapper +#define RandomDirectionCentreBasedDivisionRule3_3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_RandomDirectionCentreBasedDivisionRule3_3_class(py::module &m); +#endif // RandomDirectionCentreBasedDivisionRule3_3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ShortAxisImmersedBoundaryDivisionRule2.cppwg.cpp b/dynamic/wrappers/cell_based/ShortAxisImmersedBoundaryDivisionRule2.cppwg.cpp new file mode 100644 index 00000000..43842ea6 --- /dev/null +++ b/dynamic/wrappers/cell_based/ShortAxisImmersedBoundaryDivisionRule2.cppwg.cpp @@ -0,0 +1,39 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ShortAxisImmersedBoundaryDivisionRule.hpp" + +#include "ShortAxisImmersedBoundaryDivisionRule2.cppwg.hpp" + +namespace py = pybind11; +typedef ShortAxisImmersedBoundaryDivisionRule<2 > ShortAxisImmersedBoundaryDivisionRule2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); +typedef ::boost::numeric::ublas::c_vector _boost_numeric_ublas_c_vector_lt_double_2_gt_; + +class ShortAxisImmersedBoundaryDivisionRule2_Overloads : public ShortAxisImmersedBoundaryDivisionRule2{ + public: + using ShortAxisImmersedBoundaryDivisionRule2::ShortAxisImmersedBoundaryDivisionRule; + ::boost::numeric::ublas::c_vector CalculateCellDivisionVector(::CellPtr pParentCell, ::ImmersedBoundaryCellPopulation<2> & rCellPopulation) override { + PYBIND11_OVERLOAD( + _boost_numeric_ublas_c_vector_lt_double_2_gt_, + ShortAxisImmersedBoundaryDivisionRule2, + CalculateCellDivisionVector, + pParentCell, +rCellPopulation); + } + +}; +void register_ShortAxisImmersedBoundaryDivisionRule2_class(py::module &m){ +py::class_ , AbstractImmersedBoundaryDivisionRule<2> >(m, "ShortAxisImmersedBoundaryDivisionRule2") + .def(py::init< >()) + .def( + "CalculateCellDivisionVector", + (::boost::numeric::ublas::c_vector(ShortAxisImmersedBoundaryDivisionRule2::*)(::CellPtr, ::ImmersedBoundaryCellPopulation<2> &)) &ShortAxisImmersedBoundaryDivisionRule2::CalculateCellDivisionVector, + " " , py::arg("pParentCell"), py::arg("rCellPopulation") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ShortAxisImmersedBoundaryDivisionRule2.cppwg.hpp b/dynamic/wrappers/cell_based/ShortAxisImmersedBoundaryDivisionRule2.cppwg.hpp new file mode 100644 index 00000000..698c42e9 --- /dev/null +++ b/dynamic/wrappers/cell_based/ShortAxisImmersedBoundaryDivisionRule2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ShortAxisImmersedBoundaryDivisionRule2_hpp__pyplusplus_wrapper +#define ShortAxisImmersedBoundaryDivisionRule2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ShortAxisImmersedBoundaryDivisionRule2_class(py::module &m); +#endif // ShortAxisImmersedBoundaryDivisionRule2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/cell_based/ShortAxisImmersedBoundaryDivisionRule3.cppwg.cpp b/dynamic/wrappers/cell_based/ShortAxisImmersedBoundaryDivisionRule3.cppwg.cpp new file mode 100644 index 00000000..4e29095a --- /dev/null +++ b/dynamic/wrappers/cell_based/ShortAxisImmersedBoundaryDivisionRule3.cppwg.cpp @@ -0,0 +1,39 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ShortAxisImmersedBoundaryDivisionRule.hpp" + +#include "ShortAxisImmersedBoundaryDivisionRule3.cppwg.hpp" + +namespace py = pybind11; +typedef ShortAxisImmersedBoundaryDivisionRule<3 > ShortAxisImmersedBoundaryDivisionRule3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); +typedef ::boost::numeric::ublas::c_vector _boost_numeric_ublas_c_vector_lt_double_3_gt_; + +class ShortAxisImmersedBoundaryDivisionRule3_Overloads : public ShortAxisImmersedBoundaryDivisionRule3{ + public: + using ShortAxisImmersedBoundaryDivisionRule3::ShortAxisImmersedBoundaryDivisionRule; + ::boost::numeric::ublas::c_vector CalculateCellDivisionVector(::CellPtr pParentCell, ::ImmersedBoundaryCellPopulation<3> & rCellPopulation) override { + PYBIND11_OVERLOAD( + _boost_numeric_ublas_c_vector_lt_double_3_gt_, + ShortAxisImmersedBoundaryDivisionRule3, + CalculateCellDivisionVector, + pParentCell, +rCellPopulation); + } + +}; +void register_ShortAxisImmersedBoundaryDivisionRule3_class(py::module &m){ +py::class_ , AbstractImmersedBoundaryDivisionRule<3> >(m, "ShortAxisImmersedBoundaryDivisionRule3") + .def(py::init< >()) + .def( + "CalculateCellDivisionVector", + (::boost::numeric::ublas::c_vector(ShortAxisImmersedBoundaryDivisionRule3::*)(::CellPtr, ::ImmersedBoundaryCellPopulation<3> &)) &ShortAxisImmersedBoundaryDivisionRule3::CalculateCellDivisionVector, + " " , py::arg("pParentCell"), py::arg("rCellPopulation") ) + ; +} diff --git a/dynamic/wrappers/cell_based/ShortAxisImmersedBoundaryDivisionRule3.cppwg.hpp b/dynamic/wrappers/cell_based/ShortAxisImmersedBoundaryDivisionRule3.cppwg.hpp new file mode 100644 index 00000000..71f18d52 --- /dev/null +++ b/dynamic/wrappers/cell_based/ShortAxisImmersedBoundaryDivisionRule3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ShortAxisImmersedBoundaryDivisionRule3_hpp__pyplusplus_wrapper +#define ShortAxisImmersedBoundaryDivisionRule3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ShortAxisImmersedBoundaryDivisionRule3_class(py::module &m); +#endif // ShortAxisImmersedBoundaryDivisionRule3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/mesh/AbstractElement1_2.cppwg.cpp b/dynamic/wrappers/mesh/AbstractElement1_2.cppwg.cpp new file mode 100644 index 00000000..352d2c71 --- /dev/null +++ b/dynamic/wrappers/mesh/AbstractElement1_2.cppwg.cpp @@ -0,0 +1,133 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "AbstractElement.hpp" + +#include "AbstractElement1_2.cppwg.hpp" + +namespace py = pybind11; +typedef AbstractElement<1,2 > AbstractElement1_2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class AbstractElement1_2_Overloads : public AbstractElement1_2{ + public: + using AbstractElement1_2::AbstractElement; + void UpdateNode(unsigned int const & rIndex, ::Node<2> * pNode) override { + PYBIND11_OVERLOAD_PURE( + void, + AbstractElement1_2, + UpdateNode, + rIndex, +pNode); + } + void MarkAsDeleted() override { + PYBIND11_OVERLOAD_PURE( + void, + AbstractElement1_2, + MarkAsDeleted, + ); + } + void RegisterWithNodes() override { + PYBIND11_OVERLOAD_PURE( + void, + AbstractElement1_2, + RegisterWithNodes, + ); + } + +}; +void register_AbstractElement1_2_class(py::module &m){ +py::class_ >(m, "AbstractElement1_2") + .def(py::init *> const & >(), py::arg("index"), py::arg("rNodes")) + .def(py::init(), py::arg("index") = ::INDEX_IS_NOT_USED) + .def( + "UpdateNode", + (void(AbstractElement1_2::*)(unsigned int const &, ::Node<2> *)) &AbstractElement1_2::UpdateNode, + " " , py::arg("rIndex"), py::arg("pNode") ) + .def( + "ReplaceNode", + (void(AbstractElement1_2::*)(::Node<2> *, ::Node<2> *)) &AbstractElement1_2::ReplaceNode, + " " , py::arg("pOldNode"), py::arg("pNewNode") ) + .def( + "MarkAsDeleted", + (void(AbstractElement1_2::*)()) &AbstractElement1_2::MarkAsDeleted, + " " ) + .def( + "RegisterWithNodes", + (void(AbstractElement1_2::*)()) &AbstractElement1_2::RegisterWithNodes, + " " ) + .def( + "GetNodeLocation", + (double(AbstractElement1_2::*)(unsigned int, unsigned int) const ) &AbstractElement1_2::GetNodeLocation, + " " , py::arg("localIndex"), py::arg("dimension") ) + .def( + "GetNodeLocation", + (::boost::numeric::ublas::c_vector(AbstractElement1_2::*)(unsigned int) const ) &AbstractElement1_2::GetNodeLocation, + " " , py::arg("localIndex") ) + .def( + "GetNodeGlobalIndex", + (unsigned int(AbstractElement1_2::*)(unsigned int) const ) &AbstractElement1_2::GetNodeGlobalIndex, + " " , py::arg("localIndex") ) + .def( + "GetNode", + (::Node<2> *(AbstractElement1_2::*)(unsigned int) const ) &AbstractElement1_2::GetNode, + " " , py::arg("localIndex") , py::return_value_policy::reference) + .def( + "GetNumNodes", + (unsigned int(AbstractElement1_2::*)() const ) &AbstractElement1_2::GetNumNodes, + " " ) + .def( + "AddNode", + (void(AbstractElement1_2::*)(::Node<2> *)) &AbstractElement1_2::AddNode, + " " , py::arg("pNode") ) + .def( + "IsDeleted", + (bool(AbstractElement1_2::*)() const ) &AbstractElement1_2::IsDeleted, + " " ) + .def( + "GetIndex", + (unsigned int(AbstractElement1_2::*)() const ) &AbstractElement1_2::GetIndex, + " " ) + .def( + "SetIndex", + (void(AbstractElement1_2::*)(unsigned int)) &AbstractElement1_2::SetIndex, + " " , py::arg("index") ) + .def( + "GetOwnership", + (bool(AbstractElement1_2::*)() const ) &AbstractElement1_2::GetOwnership, + " " ) + .def( + "SetOwnership", + (void(AbstractElement1_2::*)(bool)) &AbstractElement1_2::SetOwnership, + " " , py::arg("ownership") ) + .def( + "SetAttribute", + (void(AbstractElement1_2::*)(double)) &AbstractElement1_2::SetAttribute, + " " , py::arg("attribute") ) + .def( + "GetAttribute", + (double(AbstractElement1_2::*)()) &AbstractElement1_2::GetAttribute, + " " ) + .def( + "GetUnsignedAttribute", + (unsigned int(AbstractElement1_2::*)()) &AbstractElement1_2::GetUnsignedAttribute, + " " ) + .def( + "AddElementAttribute", + (void(AbstractElement1_2::*)(double)) &AbstractElement1_2::AddElementAttribute, + " " , py::arg("attribute") ) + .def( + "rGetElementAttributes", + (::std::vector &(AbstractElement1_2::*)()) &AbstractElement1_2::rGetElementAttributes, + " " , py::return_value_policy::reference_internal) + .def( + "GetNumElementAttributes", + (unsigned int(AbstractElement1_2::*)()) &AbstractElement1_2::GetNumElementAttributes, + " " ) + ; +} diff --git a/dynamic/wrappers/mesh/AbstractElement1_2.cppwg.hpp b/dynamic/wrappers/mesh/AbstractElement1_2.cppwg.hpp new file mode 100644 index 00000000..6a1151e9 --- /dev/null +++ b/dynamic/wrappers/mesh/AbstractElement1_2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef AbstractElement1_2_hpp__pyplusplus_wrapper +#define AbstractElement1_2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_AbstractElement1_2_class(py::module &m); +#endif // AbstractElement1_2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/mesh/AbstractElement2_3.cppwg.cpp b/dynamic/wrappers/mesh/AbstractElement2_3.cppwg.cpp new file mode 100644 index 00000000..314ff3d2 --- /dev/null +++ b/dynamic/wrappers/mesh/AbstractElement2_3.cppwg.cpp @@ -0,0 +1,133 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "AbstractElement.hpp" + +#include "AbstractElement2_3.cppwg.hpp" + +namespace py = pybind11; +typedef AbstractElement<2,3 > AbstractElement2_3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class AbstractElement2_3_Overloads : public AbstractElement2_3{ + public: + using AbstractElement2_3::AbstractElement; + void UpdateNode(unsigned int const & rIndex, ::Node<3> * pNode) override { + PYBIND11_OVERLOAD_PURE( + void, + AbstractElement2_3, + UpdateNode, + rIndex, +pNode); + } + void MarkAsDeleted() override { + PYBIND11_OVERLOAD_PURE( + void, + AbstractElement2_3, + MarkAsDeleted, + ); + } + void RegisterWithNodes() override { + PYBIND11_OVERLOAD_PURE( + void, + AbstractElement2_3, + RegisterWithNodes, + ); + } + +}; +void register_AbstractElement2_3_class(py::module &m){ +py::class_ >(m, "AbstractElement2_3") + .def(py::init *> const & >(), py::arg("index"), py::arg("rNodes")) + .def(py::init(), py::arg("index") = ::INDEX_IS_NOT_USED) + .def( + "UpdateNode", + (void(AbstractElement2_3::*)(unsigned int const &, ::Node<3> *)) &AbstractElement2_3::UpdateNode, + " " , py::arg("rIndex"), py::arg("pNode") ) + .def( + "ReplaceNode", + (void(AbstractElement2_3::*)(::Node<3> *, ::Node<3> *)) &AbstractElement2_3::ReplaceNode, + " " , py::arg("pOldNode"), py::arg("pNewNode") ) + .def( + "MarkAsDeleted", + (void(AbstractElement2_3::*)()) &AbstractElement2_3::MarkAsDeleted, + " " ) + .def( + "RegisterWithNodes", + (void(AbstractElement2_3::*)()) &AbstractElement2_3::RegisterWithNodes, + " " ) + .def( + "GetNodeLocation", + (double(AbstractElement2_3::*)(unsigned int, unsigned int) const ) &AbstractElement2_3::GetNodeLocation, + " " , py::arg("localIndex"), py::arg("dimension") ) + .def( + "GetNodeLocation", + (::boost::numeric::ublas::c_vector(AbstractElement2_3::*)(unsigned int) const ) &AbstractElement2_3::GetNodeLocation, + " " , py::arg("localIndex") ) + .def( + "GetNodeGlobalIndex", + (unsigned int(AbstractElement2_3::*)(unsigned int) const ) &AbstractElement2_3::GetNodeGlobalIndex, + " " , py::arg("localIndex") ) + .def( + "GetNode", + (::Node<3> *(AbstractElement2_3::*)(unsigned int) const ) &AbstractElement2_3::GetNode, + " " , py::arg("localIndex") , py::return_value_policy::reference) + .def( + "GetNumNodes", + (unsigned int(AbstractElement2_3::*)() const ) &AbstractElement2_3::GetNumNodes, + " " ) + .def( + "AddNode", + (void(AbstractElement2_3::*)(::Node<3> *)) &AbstractElement2_3::AddNode, + " " , py::arg("pNode") ) + .def( + "IsDeleted", + (bool(AbstractElement2_3::*)() const ) &AbstractElement2_3::IsDeleted, + " " ) + .def( + "GetIndex", + (unsigned int(AbstractElement2_3::*)() const ) &AbstractElement2_3::GetIndex, + " " ) + .def( + "SetIndex", + (void(AbstractElement2_3::*)(unsigned int)) &AbstractElement2_3::SetIndex, + " " , py::arg("index") ) + .def( + "GetOwnership", + (bool(AbstractElement2_3::*)() const ) &AbstractElement2_3::GetOwnership, + " " ) + .def( + "SetOwnership", + (void(AbstractElement2_3::*)(bool)) &AbstractElement2_3::SetOwnership, + " " , py::arg("ownership") ) + .def( + "SetAttribute", + (void(AbstractElement2_3::*)(double)) &AbstractElement2_3::SetAttribute, + " " , py::arg("attribute") ) + .def( + "GetAttribute", + (double(AbstractElement2_3::*)()) &AbstractElement2_3::GetAttribute, + " " ) + .def( + "GetUnsignedAttribute", + (unsigned int(AbstractElement2_3::*)()) &AbstractElement2_3::GetUnsignedAttribute, + " " ) + .def( + "AddElementAttribute", + (void(AbstractElement2_3::*)(double)) &AbstractElement2_3::AddElementAttribute, + " " , py::arg("attribute") ) + .def( + "rGetElementAttributes", + (::std::vector &(AbstractElement2_3::*)()) &AbstractElement2_3::rGetElementAttributes, + " " , py::return_value_policy::reference_internal) + .def( + "GetNumElementAttributes", + (unsigned int(AbstractElement2_3::*)()) &AbstractElement2_3::GetNumElementAttributes, + " " ) + ; +} diff --git a/dynamic/wrappers/mesh/AbstractElement2_3.cppwg.hpp b/dynamic/wrappers/mesh/AbstractElement2_3.cppwg.hpp new file mode 100644 index 00000000..b20cb880 --- /dev/null +++ b/dynamic/wrappers/mesh/AbstractElement2_3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef AbstractElement2_3_hpp__pyplusplus_wrapper +#define AbstractElement2_3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_AbstractElement2_3_class(py::module &m); +#endif // AbstractElement2_3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/mesh/FluidSource2.cppwg.cpp b/dynamic/wrappers/mesh/FluidSource2.cppwg.cpp new file mode 100644 index 00000000..ee354d31 --- /dev/null +++ b/dynamic/wrappers/mesh/FluidSource2.cppwg.cpp @@ -0,0 +1,67 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "FluidSource.hpp" + +#include "FluidSource2.cppwg.hpp" + +namespace py = pybind11; +typedef FluidSource<2 > FluidSource2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +void register_FluidSource2_class(py::module &m){ +py::class_ >(m, "FluidSource2") + .def(py::init >(), py::arg("index"), py::arg("point")) + .def(py::init >(), py::arg("index"), py::arg("location")) + .def(py::init(), py::arg("index"), py::arg("v1") = 0., py::arg("v2") = 0., py::arg("v3") = 0.) + .def( + "GetIndex", + (unsigned int(FluidSource2::*)() const ) &FluidSource2::GetIndex, + " " ) + .def( + "SetIndex", + (void(FluidSource2::*)(unsigned int)) &FluidSource2::SetIndex, + " " , py::arg("index") ) + .def( + "GetPoint", + (::ChastePoint<2>(FluidSource2::*)() const ) &FluidSource2::GetPoint, + " " ) + .def( + "rGetLocation", + (::boost::numeric::ublas::c_vector const &(FluidSource2::*)() const ) &FluidSource2::rGetLocation, + " " , py::return_value_policy::reference_internal) + .def( + "rGetModifiableLocation", + (::boost::numeric::ublas::c_vector &(FluidSource2::*)()) &FluidSource2::rGetModifiableLocation, + " " , py::return_value_policy::reference_internal) + .def( + "GetStrength", + (double(FluidSource2::*)() const ) &FluidSource2::GetStrength, + " " ) + .def( + "SetStrength", + (void(FluidSource2::*)(double)) &FluidSource2::SetStrength, + " " , py::arg("strength") ) + .def( + "SetIfSourceIsAssociatedWithElement", + (void(FluidSource2::*)(bool)) &FluidSource2::SetIfSourceIsAssociatedWithElement, + " " , py::arg("associated") ) + .def( + "IsSourceAssociatedWithElement", + (bool(FluidSource2::*)()) &FluidSource2::IsSourceAssociatedWithElement, + " " ) + .def( + "GetAssociatedElementIndex", + (unsigned int(FluidSource2::*)() const ) &FluidSource2::GetAssociatedElementIndex, + " " ) + .def( + "SetAssociatedElementIndex", + (void(FluidSource2::*)(unsigned int)) &FluidSource2::SetAssociatedElementIndex, + " " , py::arg("associatedElementIndex") ) + ; +} diff --git a/dynamic/wrappers/mesh/FluidSource2.cppwg.hpp b/dynamic/wrappers/mesh/FluidSource2.cppwg.hpp new file mode 100644 index 00000000..ef7adf18 --- /dev/null +++ b/dynamic/wrappers/mesh/FluidSource2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef FluidSource2_hpp__pyplusplus_wrapper +#define FluidSource2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_FluidSource2_class(py::module &m); +#endif // FluidSource2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/mesh/FluidSource3.cppwg.cpp b/dynamic/wrappers/mesh/FluidSource3.cppwg.cpp new file mode 100644 index 00000000..76c13407 --- /dev/null +++ b/dynamic/wrappers/mesh/FluidSource3.cppwg.cpp @@ -0,0 +1,67 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "FluidSource.hpp" + +#include "FluidSource3.cppwg.hpp" + +namespace py = pybind11; +typedef FluidSource<3 > FluidSource3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +void register_FluidSource3_class(py::module &m){ +py::class_ >(m, "FluidSource3") + .def(py::init >(), py::arg("index"), py::arg("point")) + .def(py::init >(), py::arg("index"), py::arg("location")) + .def(py::init(), py::arg("index"), py::arg("v1") = 0., py::arg("v2") = 0., py::arg("v3") = 0.) + .def( + "GetIndex", + (unsigned int(FluidSource3::*)() const ) &FluidSource3::GetIndex, + " " ) + .def( + "SetIndex", + (void(FluidSource3::*)(unsigned int)) &FluidSource3::SetIndex, + " " , py::arg("index") ) + .def( + "GetPoint", + (::ChastePoint<3>(FluidSource3::*)() const ) &FluidSource3::GetPoint, + " " ) + .def( + "rGetLocation", + (::boost::numeric::ublas::c_vector const &(FluidSource3::*)() const ) &FluidSource3::rGetLocation, + " " , py::return_value_policy::reference_internal) + .def( + "rGetModifiableLocation", + (::boost::numeric::ublas::c_vector &(FluidSource3::*)()) &FluidSource3::rGetModifiableLocation, + " " , py::return_value_policy::reference_internal) + .def( + "GetStrength", + (double(FluidSource3::*)() const ) &FluidSource3::GetStrength, + " " ) + .def( + "SetStrength", + (void(FluidSource3::*)(double)) &FluidSource3::SetStrength, + " " , py::arg("strength") ) + .def( + "SetIfSourceIsAssociatedWithElement", + (void(FluidSource3::*)(bool)) &FluidSource3::SetIfSourceIsAssociatedWithElement, + " " , py::arg("associated") ) + .def( + "IsSourceAssociatedWithElement", + (bool(FluidSource3::*)()) &FluidSource3::IsSourceAssociatedWithElement, + " " ) + .def( + "GetAssociatedElementIndex", + (unsigned int(FluidSource3::*)() const ) &FluidSource3::GetAssociatedElementIndex, + " " ) + .def( + "SetAssociatedElementIndex", + (void(FluidSource3::*)(unsigned int)) &FluidSource3::SetAssociatedElementIndex, + " " , py::arg("associatedElementIndex") ) + ; +} diff --git a/dynamic/wrappers/mesh/FluidSource3.cppwg.hpp b/dynamic/wrappers/mesh/FluidSource3.cppwg.hpp new file mode 100644 index 00000000..62bc931d --- /dev/null +++ b/dynamic/wrappers/mesh/FluidSource3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef FluidSource3_hpp__pyplusplus_wrapper +#define FluidSource3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_FluidSource3_class(py::module &m); +#endif // FluidSource3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/mesh/ImmersedBoundaryElement1_2.cppwg.cpp b/dynamic/wrappers/mesh/ImmersedBoundaryElement1_2.cppwg.cpp new file mode 100644 index 00000000..d81d17ad --- /dev/null +++ b/dynamic/wrappers/mesh/ImmersedBoundaryElement1_2.cppwg.cpp @@ -0,0 +1,61 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryElement.hpp" + +#include "ImmersedBoundaryElement1_2.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryElement<1,2 > ImmersedBoundaryElement1_2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryElement1_2_Overloads : public ImmersedBoundaryElement1_2{ + public: + using ImmersedBoundaryElement1_2::ImmersedBoundaryElement; + bool IsElementOnBoundary() const override { + PYBIND11_OVERLOAD( + bool, + ImmersedBoundaryElement1_2, + IsElementOnBoundary, + ); + } + +}; +void register_ImmersedBoundaryElement1_2_class(py::module &m){ +py::class_ , MutableElement<1, 2> >(m, "ImmersedBoundaryElement1_2") + .def(py::init *> const & >(), py::arg("index"), py::arg("rNodes")) + .def( + "SetFluidSource", + (void(ImmersedBoundaryElement1_2::*)(::std::shared_ptr>)) &ImmersedBoundaryElement1_2::SetFluidSource, + " " , py::arg("fluidSource") ) + .def( + "GetFluidSource", + (::std::shared_ptr>(ImmersedBoundaryElement1_2::*)()) &ImmersedBoundaryElement1_2::GetFluidSource, + " " ) + .def( + "rGetCornerNodes", + (::std::vector *> &(ImmersedBoundaryElement1_2::*)()) &ImmersedBoundaryElement1_2::rGetCornerNodes, + " " , py::return_value_policy::reference_internal) + .def( + "GetAverageNodeSpacing", + (double(ImmersedBoundaryElement1_2::*)()) &ImmersedBoundaryElement1_2::GetAverageNodeSpacing, + " " ) + .def( + "SetAverageNodeSpacing", + (void(ImmersedBoundaryElement1_2::*)(double)) &ImmersedBoundaryElement1_2::SetAverageNodeSpacing, + " " , py::arg("averageNodeSpacing") ) + .def( + "IsElementOnBoundary", + (bool(ImmersedBoundaryElement1_2::*)() const ) &ImmersedBoundaryElement1_2::IsElementOnBoundary, + " " ) + .def( + "SetIsBoundaryElement", + (void(ImmersedBoundaryElement1_2::*)(bool)) &ImmersedBoundaryElement1_2::SetIsBoundaryElement, + " " , py::arg("isBoundaryElement") ) + ; +} diff --git a/dynamic/wrappers/mesh/ImmersedBoundaryElement1_2.cppwg.hpp b/dynamic/wrappers/mesh/ImmersedBoundaryElement1_2.cppwg.hpp new file mode 100644 index 00000000..4932aad6 --- /dev/null +++ b/dynamic/wrappers/mesh/ImmersedBoundaryElement1_2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryElement1_2_hpp__pyplusplus_wrapper +#define ImmersedBoundaryElement1_2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryElement1_2_class(py::module &m); +#endif // ImmersedBoundaryElement1_2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/mesh/ImmersedBoundaryElement2_2.cppwg.cpp b/dynamic/wrappers/mesh/ImmersedBoundaryElement2_2.cppwg.cpp new file mode 100644 index 00000000..8ceb9d01 --- /dev/null +++ b/dynamic/wrappers/mesh/ImmersedBoundaryElement2_2.cppwg.cpp @@ -0,0 +1,61 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryElement.hpp" + +#include "ImmersedBoundaryElement2_2.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryElement<2,2 > ImmersedBoundaryElement2_2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryElement2_2_Overloads : public ImmersedBoundaryElement2_2{ + public: + using ImmersedBoundaryElement2_2::ImmersedBoundaryElement; + bool IsElementOnBoundary() const override { + PYBIND11_OVERLOAD( + bool, + ImmersedBoundaryElement2_2, + IsElementOnBoundary, + ); + } + +}; +void register_ImmersedBoundaryElement2_2_class(py::module &m){ +py::class_ , MutableElement<2, 2> >(m, "ImmersedBoundaryElement2_2") + .def(py::init *> const & >(), py::arg("index"), py::arg("rNodes")) + .def( + "SetFluidSource", + (void(ImmersedBoundaryElement2_2::*)(::std::shared_ptr>)) &ImmersedBoundaryElement2_2::SetFluidSource, + " " , py::arg("fluidSource") ) + .def( + "GetFluidSource", + (::std::shared_ptr>(ImmersedBoundaryElement2_2::*)()) &ImmersedBoundaryElement2_2::GetFluidSource, + " " ) + .def( + "rGetCornerNodes", + (::std::vector *> &(ImmersedBoundaryElement2_2::*)()) &ImmersedBoundaryElement2_2::rGetCornerNodes, + " " , py::return_value_policy::reference_internal) + .def( + "GetAverageNodeSpacing", + (double(ImmersedBoundaryElement2_2::*)()) &ImmersedBoundaryElement2_2::GetAverageNodeSpacing, + " " ) + .def( + "SetAverageNodeSpacing", + (void(ImmersedBoundaryElement2_2::*)(double)) &ImmersedBoundaryElement2_2::SetAverageNodeSpacing, + " " , py::arg("averageNodeSpacing") ) + .def( + "IsElementOnBoundary", + (bool(ImmersedBoundaryElement2_2::*)() const ) &ImmersedBoundaryElement2_2::IsElementOnBoundary, + " " ) + .def( + "SetIsBoundaryElement", + (void(ImmersedBoundaryElement2_2::*)(bool)) &ImmersedBoundaryElement2_2::SetIsBoundaryElement, + " " , py::arg("isBoundaryElement") ) + ; +} diff --git a/dynamic/wrappers/mesh/ImmersedBoundaryElement2_2.cppwg.hpp b/dynamic/wrappers/mesh/ImmersedBoundaryElement2_2.cppwg.hpp new file mode 100644 index 00000000..58e676f6 --- /dev/null +++ b/dynamic/wrappers/mesh/ImmersedBoundaryElement2_2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryElement2_2_hpp__pyplusplus_wrapper +#define ImmersedBoundaryElement2_2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryElement2_2_class(py::module &m); +#endif // ImmersedBoundaryElement2_2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/mesh/ImmersedBoundaryElement2_3.cppwg.cpp b/dynamic/wrappers/mesh/ImmersedBoundaryElement2_3.cppwg.cpp new file mode 100644 index 00000000..eb5a536e --- /dev/null +++ b/dynamic/wrappers/mesh/ImmersedBoundaryElement2_3.cppwg.cpp @@ -0,0 +1,61 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryElement.hpp" + +#include "ImmersedBoundaryElement2_3.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryElement<2,3 > ImmersedBoundaryElement2_3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryElement2_3_Overloads : public ImmersedBoundaryElement2_3{ + public: + using ImmersedBoundaryElement2_3::ImmersedBoundaryElement; + bool IsElementOnBoundary() const override { + PYBIND11_OVERLOAD( + bool, + ImmersedBoundaryElement2_3, + IsElementOnBoundary, + ); + } + +}; +void register_ImmersedBoundaryElement2_3_class(py::module &m){ +py::class_ , MutableElement<2, 3> >(m, "ImmersedBoundaryElement2_3") + .def(py::init *> const & >(), py::arg("index"), py::arg("rNodes")) + .def( + "SetFluidSource", + (void(ImmersedBoundaryElement2_3::*)(::std::shared_ptr>)) &ImmersedBoundaryElement2_3::SetFluidSource, + " " , py::arg("fluidSource") ) + .def( + "GetFluidSource", + (::std::shared_ptr>(ImmersedBoundaryElement2_3::*)()) &ImmersedBoundaryElement2_3::GetFluidSource, + " " ) + .def( + "rGetCornerNodes", + (::std::vector *> &(ImmersedBoundaryElement2_3::*)()) &ImmersedBoundaryElement2_3::rGetCornerNodes, + " " , py::return_value_policy::reference_internal) + .def( + "GetAverageNodeSpacing", + (double(ImmersedBoundaryElement2_3::*)()) &ImmersedBoundaryElement2_3::GetAverageNodeSpacing, + " " ) + .def( + "SetAverageNodeSpacing", + (void(ImmersedBoundaryElement2_3::*)(double)) &ImmersedBoundaryElement2_3::SetAverageNodeSpacing, + " " , py::arg("averageNodeSpacing") ) + .def( + "IsElementOnBoundary", + (bool(ImmersedBoundaryElement2_3::*)() const ) &ImmersedBoundaryElement2_3::IsElementOnBoundary, + " " ) + .def( + "SetIsBoundaryElement", + (void(ImmersedBoundaryElement2_3::*)(bool)) &ImmersedBoundaryElement2_3::SetIsBoundaryElement, + " " , py::arg("isBoundaryElement") ) + ; +} diff --git a/dynamic/wrappers/mesh/ImmersedBoundaryElement2_3.cppwg.hpp b/dynamic/wrappers/mesh/ImmersedBoundaryElement2_3.cppwg.hpp new file mode 100644 index 00000000..813eac7c --- /dev/null +++ b/dynamic/wrappers/mesh/ImmersedBoundaryElement2_3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryElement2_3_hpp__pyplusplus_wrapper +#define ImmersedBoundaryElement2_3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryElement2_3_class(py::module &m); +#endif // ImmersedBoundaryElement2_3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/mesh/ImmersedBoundaryElement3_3.cppwg.cpp b/dynamic/wrappers/mesh/ImmersedBoundaryElement3_3.cppwg.cpp new file mode 100644 index 00000000..76b7617d --- /dev/null +++ b/dynamic/wrappers/mesh/ImmersedBoundaryElement3_3.cppwg.cpp @@ -0,0 +1,61 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryElement.hpp" + +#include "ImmersedBoundaryElement3_3.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryElement<3,3 > ImmersedBoundaryElement3_3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class ImmersedBoundaryElement3_3_Overloads : public ImmersedBoundaryElement3_3{ + public: + using ImmersedBoundaryElement3_3::ImmersedBoundaryElement; + bool IsElementOnBoundary() const override { + PYBIND11_OVERLOAD( + bool, + ImmersedBoundaryElement3_3, + IsElementOnBoundary, + ); + } + +}; +void register_ImmersedBoundaryElement3_3_class(py::module &m){ +py::class_ , MutableElement<3, 3> >(m, "ImmersedBoundaryElement3_3") + .def(py::init *> const & >(), py::arg("index"), py::arg("rNodes")) + .def( + "SetFluidSource", + (void(ImmersedBoundaryElement3_3::*)(::std::shared_ptr>)) &ImmersedBoundaryElement3_3::SetFluidSource, + " " , py::arg("fluidSource") ) + .def( + "GetFluidSource", + (::std::shared_ptr>(ImmersedBoundaryElement3_3::*)()) &ImmersedBoundaryElement3_3::GetFluidSource, + " " ) + .def( + "rGetCornerNodes", + (::std::vector *> &(ImmersedBoundaryElement3_3::*)()) &ImmersedBoundaryElement3_3::rGetCornerNodes, + " " , py::return_value_policy::reference_internal) + .def( + "GetAverageNodeSpacing", + (double(ImmersedBoundaryElement3_3::*)()) &ImmersedBoundaryElement3_3::GetAverageNodeSpacing, + " " ) + .def( + "SetAverageNodeSpacing", + (void(ImmersedBoundaryElement3_3::*)(double)) &ImmersedBoundaryElement3_3::SetAverageNodeSpacing, + " " , py::arg("averageNodeSpacing") ) + .def( + "IsElementOnBoundary", + (bool(ImmersedBoundaryElement3_3::*)() const ) &ImmersedBoundaryElement3_3::IsElementOnBoundary, + " " ) + .def( + "SetIsBoundaryElement", + (void(ImmersedBoundaryElement3_3::*)(bool)) &ImmersedBoundaryElement3_3::SetIsBoundaryElement, + " " , py::arg("isBoundaryElement") ) + ; +} diff --git a/dynamic/wrappers/mesh/ImmersedBoundaryElement3_3.cppwg.hpp b/dynamic/wrappers/mesh/ImmersedBoundaryElement3_3.cppwg.hpp new file mode 100644 index 00000000..fa4fa138 --- /dev/null +++ b/dynamic/wrappers/mesh/ImmersedBoundaryElement3_3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryElement3_3_hpp__pyplusplus_wrapper +#define ImmersedBoundaryElement3_3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryElement3_3_class(py::module &m); +#endif // ImmersedBoundaryElement3_3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/mesh/ImmersedBoundaryHoneycombMeshGenerator.cppwg.cpp b/dynamic/wrappers/mesh/ImmersedBoundaryHoneycombMeshGenerator.cppwg.cpp new file mode 100644 index 00000000..f5ec8ade --- /dev/null +++ b/dynamic/wrappers/mesh/ImmersedBoundaryHoneycombMeshGenerator.cppwg.cpp @@ -0,0 +1,30 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryHoneycombMeshGenerator.hpp" + +#include "ImmersedBoundaryHoneycombMeshGenerator.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryHoneycombMeshGenerator ImmersedBoundaryHoneycombMeshGenerator; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +void register_ImmersedBoundaryHoneycombMeshGenerator_class(py::module &m){ +py::class_ >(m, "ImmersedBoundaryHoneycombMeshGenerator") + .def(py::init(), py::arg("numElementsX"), py::arg("numElementsY"), py::arg("numNodesPerEdge"), py::arg("proportionalGap"), py::arg("padding")) + .def(py::init< >()) + .def( + "GetMesh", + (::ImmersedBoundaryMesh<2, 2> *(ImmersedBoundaryHoneycombMeshGenerator::*)()) &ImmersedBoundaryHoneycombMeshGenerator::GetMesh, + " " , py::return_value_policy::reference) + .def( + "GetUnitHexagon", + (::std::vector>(ImmersedBoundaryHoneycombMeshGenerator::*)(unsigned int)) &ImmersedBoundaryHoneycombMeshGenerator::GetUnitHexagon, + " " , py::arg("numPtsPerSide") ) + ; +} diff --git a/dynamic/wrappers/mesh/ImmersedBoundaryHoneycombMeshGenerator.cppwg.hpp b/dynamic/wrappers/mesh/ImmersedBoundaryHoneycombMeshGenerator.cppwg.hpp new file mode 100644 index 00000000..cff18946 --- /dev/null +++ b/dynamic/wrappers/mesh/ImmersedBoundaryHoneycombMeshGenerator.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryHoneycombMeshGenerator_hpp__pyplusplus_wrapper +#define ImmersedBoundaryHoneycombMeshGenerator_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryHoneycombMeshGenerator_class(py::module &m); +#endif // ImmersedBoundaryHoneycombMeshGenerator_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/mesh/ImmersedBoundaryMesh2_2.cppwg.cpp b/dynamic/wrappers/mesh/ImmersedBoundaryMesh2_2.cppwg.cpp new file mode 100644 index 00000000..3dee6ee4 --- /dev/null +++ b/dynamic/wrappers/mesh/ImmersedBoundaryMesh2_2.cppwg.cpp @@ -0,0 +1,357 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryMesh.hpp" + +#include "ImmersedBoundaryMesh2_2.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryMesh<2,2 > ImmersedBoundaryMesh2_2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); +typedef unsigned int unsignedint; +typedef unsigned int unsignedint; +typedef ::boost::numeric::ublas::c_vector _boost_numeric_ublas_c_vector_lt_double_2_gt_; +typedef ::boost::numeric::ublas::c_vector _boost_numeric_ublas_c_vector_lt_double_2_gt_; +typedef ::boost::numeric::ublas::c_vector _boost_numeric_ublas_c_vector_lt_double_3_gt_; +typedef unsigned int unsignedint; + +class ImmersedBoundaryMesh2_2_Overloads : public ImmersedBoundaryMesh2_2{ + public: + using ImmersedBoundaryMesh2_2::ImmersedBoundaryMesh; + unsigned int GetNumNodes() const override { + PYBIND11_OVERLOAD( + unsignedint, + ImmersedBoundaryMesh2_2, + GetNumNodes, + ); + } + unsigned int GetNumElements() const override { + PYBIND11_OVERLOAD( + unsignedint, + ImmersedBoundaryMesh2_2, + GetNumElements, + ); + } + ::boost::numeric::ublas::c_vector GetVectorFromAtoB(::boost::numeric::ublas::c_vector const & rLocation1, ::boost::numeric::ublas::c_vector const & rLocation2) override { + PYBIND11_OVERLOAD( + _boost_numeric_ublas_c_vector_lt_double_2_gt_, + ImmersedBoundaryMesh2_2, + GetVectorFromAtoB, + rLocation1, +rLocation2); + } + ::boost::numeric::ublas::c_vector GetCentroidOfElement(unsigned int index) override { + PYBIND11_OVERLOAD( + _boost_numeric_ublas_c_vector_lt_double_2_gt_, + ImmersedBoundaryMesh2_2, + GetCentroidOfElement, + index); + } + void Clear() override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryMesh2_2, + Clear, + ); + } + double GetVolumeOfElement(unsigned int index) override { + PYBIND11_OVERLOAD( + double, + ImmersedBoundaryMesh2_2, + GetVolumeOfElement, + index); + } + double GetSurfaceAreaOfElement(unsigned int index) override { + PYBIND11_OVERLOAD( + double, + ImmersedBoundaryMesh2_2, + GetSurfaceAreaOfElement, + index); + } + ::boost::numeric::ublas::c_vector CalculateMomentsOfElement(unsigned int index) override { + PYBIND11_OVERLOAD( + _boost_numeric_ublas_c_vector_lt_double_3_gt_, + ImmersedBoundaryMesh2_2, + CalculateMomentsOfElement, + index); + } + unsigned int SolveNodeMapping(unsigned int index) const override { + PYBIND11_OVERLOAD( + unsignedint, + ImmersedBoundaryMesh2_2, + SolveNodeMapping, + index); + } + +}; +void register_ImmersedBoundaryMesh2_2_class(py::module &m){ +py::class_ , AbstractMesh<2, 2> >(m, "ImmersedBoundaryMesh2_2") + .def(py::init<::std::vector *>, ::std::vector *>, ::std::vector *>, unsigned int, unsigned int >(), py::arg("nodes"), py::arg("elements"), py::arg("laminas") = std::vector *>{}, py::arg("numGridPtsX") = 128U, py::arg("numGridPtsY") = 128U) + .def(py::init< >()) + .def( + "rGetNodes", + (::std::vector *> const &(ImmersedBoundaryMesh2_2::*)() const ) &ImmersedBoundaryMesh2_2::rGetNodes, + " " , py::return_value_policy::reference_internal) + .def( + "GetElementIteratorBegin", + (::ImmersedBoundaryMesh<2, 2>::ImmersedBoundaryElementIterator(ImmersedBoundaryMesh2_2::*)(bool)) &ImmersedBoundaryMesh2_2::GetElementIteratorBegin, + " " , py::arg("skipDeletedElements") = true ) + .def( + "GetElementIteratorEnd", + (::ImmersedBoundaryMesh<2, 2>::ImmersedBoundaryElementIterator(ImmersedBoundaryMesh2_2::*)()) &ImmersedBoundaryMesh2_2::GetElementIteratorEnd, + " " ) + .def( + "GetLaminaIteratorBegin", + (::ImmersedBoundaryMesh<2, 2>::ImmersedBoundaryLaminaIterator(ImmersedBoundaryMesh2_2::*)(bool)) &ImmersedBoundaryMesh2_2::GetLaminaIteratorBegin, + " " , py::arg("skipDeletedLaminas") = true ) + .def( + "GetLaminaIteratorEnd", + (::ImmersedBoundaryMesh<2, 2>::ImmersedBoundaryLaminaIterator(ImmersedBoundaryMesh2_2::*)()) &ImmersedBoundaryMesh2_2::GetLaminaIteratorEnd, + " " ) + .def( + "GetNumNodes", + (unsigned int(ImmersedBoundaryMesh2_2::*)() const ) &ImmersedBoundaryMesh2_2::GetNumNodes, + " " ) + .def( + "GetNumElements", + (unsigned int(ImmersedBoundaryMesh2_2::*)() const ) &ImmersedBoundaryMesh2_2::GetNumElements, + " " ) + .def( + "GetNumAllElements", + (unsigned int(ImmersedBoundaryMesh2_2::*)() const ) &ImmersedBoundaryMesh2_2::GetNumAllElements, + " " ) + .def( + "GetNumLaminas", + (unsigned int(ImmersedBoundaryMesh2_2::*)() const ) &ImmersedBoundaryMesh2_2::GetNumLaminas, + " " ) + .def( + "GetNumGridPtsX", + (unsigned int(ImmersedBoundaryMesh2_2::*)() const ) &ImmersedBoundaryMesh2_2::GetNumGridPtsX, + " " ) + .def( + "GetNumGridPtsY", + (unsigned int(ImmersedBoundaryMesh2_2::*)() const ) &ImmersedBoundaryMesh2_2::GetNumGridPtsY, + " " ) + .def( + "GetCharacteristicNodeSpacing", + (double(ImmersedBoundaryMesh2_2::*)() const ) &ImmersedBoundaryMesh2_2::GetCharacteristicNodeSpacing, + " " ) + .def( + "GetSpacingRatio", + (double(ImmersedBoundaryMesh2_2::*)() const ) &ImmersedBoundaryMesh2_2::GetSpacingRatio, + " " ) + .def( + "GetMaxNodeIndex", + (unsigned int(ImmersedBoundaryMesh2_2::*)() const ) &ImmersedBoundaryMesh2_2::GetMaxNodeIndex, + " " ) + .def( + "GetMaxElementIndex", + (unsigned int(ImmersedBoundaryMesh2_2::*)() const ) &ImmersedBoundaryMesh2_2::GetMaxElementIndex, + " " ) + .def( + "GetMaxLaminaIndex", + (unsigned int(ImmersedBoundaryMesh2_2::*)() const ) &ImmersedBoundaryMesh2_2::GetMaxLaminaIndex, + " " ) + .def( + "GetVectorFromAtoB", + (::boost::numeric::ublas::c_vector(ImmersedBoundaryMesh2_2::*)(::boost::numeric::ublas::c_vector const &, ::boost::numeric::ublas::c_vector const &)) &ImmersedBoundaryMesh2_2::GetVectorFromAtoB, + " " , py::arg("rLocation1"), py::arg("rLocation2") ) + .def( + "SetNode", + (void(ImmersedBoundaryMesh2_2::*)(unsigned int, ::ChastePoint<2>)) &ImmersedBoundaryMesh2_2::SetNode, + " " , py::arg("nodeIndex"), py::arg("point") ) + .def( + "ConformToGeometry", + (void(ImmersedBoundaryMesh2_2::*)(::boost::numeric::ublas::c_vector &)) &ImmersedBoundaryMesh2_2::ConformToGeometry, + " " , py::arg("rLocation") ) + .def( + "rGet2dVelocityGrids", + (::boost::multi_array const &(ImmersedBoundaryMesh2_2::*)() const ) &ImmersedBoundaryMesh2_2::rGet2dVelocityGrids, + " " , py::return_value_policy::reference_internal) + .def( + "rGetModifiable2dVelocityGrids", + (::boost::multi_array &(ImmersedBoundaryMesh2_2::*)()) &ImmersedBoundaryMesh2_2::rGetModifiable2dVelocityGrids, + " " , py::return_value_policy::reference_internal) + .def( + "SetNumGridPtsX", + (void(ImmersedBoundaryMesh2_2::*)(unsigned int)) &ImmersedBoundaryMesh2_2::SetNumGridPtsX, + " " , py::arg("meshPointsX") ) + .def( + "SetNumGridPtsY", + (void(ImmersedBoundaryMesh2_2::*)(unsigned int)) &ImmersedBoundaryMesh2_2::SetNumGridPtsY, + " " , py::arg("meshPointsY") ) + .def( + "SetNumGridPtsXAndY", + (void(ImmersedBoundaryMesh2_2::*)(unsigned int)) &ImmersedBoundaryMesh2_2::SetNumGridPtsXAndY, + " " , py::arg("numGridPts") ) + .def( + "SetCharacteristicNodeSpacing", + (void(ImmersedBoundaryMesh2_2::*)(double)) &ImmersedBoundaryMesh2_2::SetCharacteristicNodeSpacing, + " " , py::arg("nodeSpacing") ) + .def( + "AddNode", + (unsigned int(ImmersedBoundaryMesh2_2::*)(::Node<2> *)) &ImmersedBoundaryMesh2_2::AddNode, + " " , py::arg("pNewNode") ) + .def( + "rGetElementFluidSources", + (::std::vector>> &(ImmersedBoundaryMesh2_2::*)()) &ImmersedBoundaryMesh2_2::rGetElementFluidSources, + " " , py::return_value_policy::reference_internal) + .def( + "rGetBalancingFluidSources", + (::std::vector>> &(ImmersedBoundaryMesh2_2::*)()) &ImmersedBoundaryMesh2_2::rGetBalancingFluidSources, + " " , py::return_value_policy::reference_internal) + .def( + "GetNeighbouringNodeIndices", + (::std::set(ImmersedBoundaryMesh2_2::*)(unsigned int)) &ImmersedBoundaryMesh2_2::GetNeighbouringNodeIndices, + " " , py::arg("nodeIndex") ) + .def( + "GetElement", + (::ImmersedBoundaryElement<2, 2> *(ImmersedBoundaryMesh2_2::*)(unsigned int) const ) &ImmersedBoundaryMesh2_2::GetElement, + " " , py::arg("index") , py::return_value_policy::reference) + .def( + "GetLamina", + (::ImmersedBoundaryElement<1, 2> *(ImmersedBoundaryMesh2_2::*)(unsigned int) const ) &ImmersedBoundaryMesh2_2::GetLamina, + " " , py::arg("index") , py::return_value_policy::reference) + .def( + "GetCentroidOfElement", + (::boost::numeric::ublas::c_vector(ImmersedBoundaryMesh2_2::*)(unsigned int)) &ImmersedBoundaryMesh2_2::GetCentroidOfElement, + " " , py::arg("index") ) + .def( + "ConstructFromMeshReader", + (void(ImmersedBoundaryMesh2_2::*)(::AbstractMeshReader<2, 2> &)) &ImmersedBoundaryMesh2_2::ConstructFromMeshReader, + " " , py::arg("rMeshReader") ) + .def( + "Clear", + (void(ImmersedBoundaryMesh2_2::*)()) &ImmersedBoundaryMesh2_2::Clear, + " " ) + .def( + "GetVolumeOfElement", + (double(ImmersedBoundaryMesh2_2::*)(unsigned int)) &ImmersedBoundaryMesh2_2::GetVolumeOfElement, + " " , py::arg("index") ) + .def( + "GetSurfaceAreaOfElement", + (double(ImmersedBoundaryMesh2_2::*)(unsigned int)) &ImmersedBoundaryMesh2_2::GetSurfaceAreaOfElement, + " " , py::arg("index") ) + .def( + "GetVoronoiSurfaceAreaOfElement", + (double(ImmersedBoundaryMesh2_2::*)(unsigned int)) &ImmersedBoundaryMesh2_2::GetVoronoiSurfaceAreaOfElement, + " " , py::arg("elemIdx") ) + .def( + "GetAverageNodeSpacingOfElement", + (double(ImmersedBoundaryMesh2_2::*)(unsigned int, bool)) &ImmersedBoundaryMesh2_2::GetAverageNodeSpacingOfElement, + " " , py::arg("index"), py::arg("recalculate") = true ) + .def( + "GetAverageNodeSpacingOfLamina", + (double(ImmersedBoundaryMesh2_2::*)(unsigned int, bool)) &ImmersedBoundaryMesh2_2::GetAverageNodeSpacingOfLamina, + " " , py::arg("index"), py::arg("recalculate") = true ) + .def( + "CalculateMomentsOfElement", + (::boost::numeric::ublas::c_vector(ImmersedBoundaryMesh2_2::*)(unsigned int)) &ImmersedBoundaryMesh2_2::CalculateMomentsOfElement, + " " , py::arg("index") ) + .def( + "GetElongationShapeFactorOfElement", + (double(ImmersedBoundaryMesh2_2::*)(unsigned int)) &ImmersedBoundaryMesh2_2::GetElongationShapeFactorOfElement, + " " , py::arg("elementIndex") ) + .def( + "GetTortuosityOfMesh", + (double(ImmersedBoundaryMesh2_2::*)()) &ImmersedBoundaryMesh2_2::GetTortuosityOfMesh, + " " ) + .def( + "GetSkewnessOfElementMassDistributionAboutAxis", + (double(ImmersedBoundaryMesh2_2::*)(unsigned int, ::boost::numeric::ublas::c_vector)) &ImmersedBoundaryMesh2_2::GetSkewnessOfElementMassDistributionAboutAxis, + " " , py::arg("elemIndex"), py::arg("axis") ) + .def( + "CalculateBoundingBoxOfElement", + (::ChasteCuboid<2>(ImmersedBoundaryMesh2_2::*)(unsigned int)) &ImmersedBoundaryMesh2_2::CalculateBoundingBoxOfElement, + " " , py::arg("index") ) + .def( + "GetShortAxisOfElement", + (::boost::numeric::ublas::c_vector(ImmersedBoundaryMesh2_2::*)(unsigned int)) &ImmersedBoundaryMesh2_2::GetShortAxisOfElement, + " " , py::arg("index") ) + .def( + "DivideElementAlongGivenAxis", + (unsigned int(ImmersedBoundaryMesh2_2::*)(::ImmersedBoundaryElement<2, 2> *, ::boost::numeric::ublas::c_vector, bool)) &ImmersedBoundaryMesh2_2::DivideElementAlongGivenAxis, + " " , py::arg("pElement"), py::arg("axisOfDivision"), py::arg("placeOriginalElementBelow") = false ) + .def( + "DivideElementAlongShortAxis", + (unsigned int(ImmersedBoundaryMesh2_2::*)(::ImmersedBoundaryElement<2, 2> *, bool)) &ImmersedBoundaryMesh2_2::DivideElementAlongShortAxis, + " " , py::arg("pElement"), py::arg("placeOriginalElementBelow") = false ) + .def( + "GetElementDivisionSpacing", + (double(ImmersedBoundaryMesh2_2::*)()) &ImmersedBoundaryMesh2_2::GetElementDivisionSpacing, + " " ) + .def( + "SetElementDivisionSpacing", + (void(ImmersedBoundaryMesh2_2::*)(double)) &ImmersedBoundaryMesh2_2::SetElementDivisionSpacing, + " " , py::arg("elementDivisionSpacing") ) + .def( + "GetNeighbourDist", + (double(ImmersedBoundaryMesh2_2::*)() const ) &ImmersedBoundaryMesh2_2::GetNeighbourDist, + " " ) + .def( + "SetCellRearrangementThreshold", + (void(ImmersedBoundaryMesh2_2::*)(double)) &ImmersedBoundaryMesh2_2::SetCellRearrangementThreshold, + " " , py::arg("cellRearrangementThreshold") ) + .def( + "GetCellRearrangementThreshold", + (double(ImmersedBoundaryMesh2_2::*)()) &ImmersedBoundaryMesh2_2::GetCellRearrangementThreshold, + " " ) + .def( + "SetNeighbourDist", + (void(ImmersedBoundaryMesh2_2::*)(double)) &ImmersedBoundaryMesh2_2::SetNeighbourDist, + " " , py::arg("neighbourDist") ) + .def( + "UpdateNodeLocationsVoronoiDiagramIfOutOfDate", + (void(ImmersedBoundaryMesh2_2::*)()) &ImmersedBoundaryMesh2_2::UpdateNodeLocationsVoronoiDiagramIfOutOfDate, + " " ) + .def( + "ReMesh", + (void(ImmersedBoundaryMesh2_2::*)(bool)) &ImmersedBoundaryMesh2_2::ReMesh, + " " , py::arg("randomOrder") = false ) + .def( + "ReMeshElement", + (void(ImmersedBoundaryMesh2_2::*)(::ImmersedBoundaryElement<2, 2> *, bool)) &ImmersedBoundaryMesh2_2::ReMeshElement, + " " , py::arg("pElement"), py::arg("randomOrder") ) + .def( + "ReMeshLamina", + (void(ImmersedBoundaryMesh2_2::*)(::ImmersedBoundaryElement<1, 2> *, bool)) &ImmersedBoundaryMesh2_2::ReMeshLamina, + " " , py::arg("pLamina"), py::arg("randomOrder") ) + .def( + "NodesInDifferentElementOrLamina", + (bool(ImmersedBoundaryMesh2_2::*)(::Node<2> *, ::Node<2> *)) &ImmersedBoundaryMesh2_2::NodesInDifferentElementOrLamina, + " " , py::arg("pNodeA"), py::arg("pNodeB") ) + .def( + "GetNeighbouringElementIndices", + (::std::set(ImmersedBoundaryMesh2_2::*)(unsigned int)) &ImmersedBoundaryMesh2_2::GetNeighbouringElementIndices, + " " , py::arg("elemIdx") ) + .def( + "CalculateLengthOfVoronoiEdge", + (double(ImmersedBoundaryMesh2_2::*)(::boost::polygon::voronoi_diagram::edge_type const &)) &ImmersedBoundaryMesh2_2::CalculateLengthOfVoronoiEdge, + " " , py::arg("rEdge") ) + .def( + "GetPolygonDistribution", + (::std::array(ImmersedBoundaryMesh2_2::*)()) &ImmersedBoundaryMesh2_2::GetPolygonDistribution, + " " ) + .def( + "rGetNodeLocationsVoronoiDiagram", + (::boost::polygon::voronoi_diagram const &(ImmersedBoundaryMesh2_2::*)(bool)) &ImmersedBoundaryMesh2_2::rGetNodeLocationsVoronoiDiagram, + " " , py::arg("update") = true , py::return_value_policy::reference_internal) + .def( + "GetVoronoiCellIdsIndexedByNodeIndex", + (::std::vector const &(ImmersedBoundaryMesh2_2::*)() const ) &ImmersedBoundaryMesh2_2::GetVoronoiCellIdsIndexedByNodeIndex, + " " , py::return_value_policy::reference_internal) + .def( + "ScaleUpToVoronoiCoordinate", + (int(ImmersedBoundaryMesh2_2::*)(double) const ) &ImmersedBoundaryMesh2_2::ScaleUpToVoronoiCoordinate, + " " , py::arg("location") ) + .def( + "ScaleDistanceDownFromVoronoi", + (double(ImmersedBoundaryMesh2_2::*)(double const) const ) &ImmersedBoundaryMesh2_2::ScaleDistanceDownFromVoronoi, + " " , py::arg("distance") ) + ; +} diff --git a/dynamic/wrappers/mesh/ImmersedBoundaryMesh2_2.cppwg.hpp b/dynamic/wrappers/mesh/ImmersedBoundaryMesh2_2.cppwg.hpp new file mode 100644 index 00000000..e74537e5 --- /dev/null +++ b/dynamic/wrappers/mesh/ImmersedBoundaryMesh2_2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryMesh2_2_hpp__pyplusplus_wrapper +#define ImmersedBoundaryMesh2_2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryMesh2_2_class(py::module &m); +#endif // ImmersedBoundaryMesh2_2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/mesh/ImmersedBoundaryMesh3_3.cppwg.cpp b/dynamic/wrappers/mesh/ImmersedBoundaryMesh3_3.cppwg.cpp new file mode 100644 index 00000000..205263a6 --- /dev/null +++ b/dynamic/wrappers/mesh/ImmersedBoundaryMesh3_3.cppwg.cpp @@ -0,0 +1,357 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryMesh.hpp" + +#include "ImmersedBoundaryMesh3_3.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryMesh<3,3 > ImmersedBoundaryMesh3_3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); +typedef unsigned int unsignedint; +typedef unsigned int unsignedint; +typedef ::boost::numeric::ublas::c_vector _boost_numeric_ublas_c_vector_lt_double_3_gt_; +typedef ::boost::numeric::ublas::c_vector _boost_numeric_ublas_c_vector_lt_double_3_gt_; +typedef ::boost::numeric::ublas::c_vector _boost_numeric_ublas_c_vector_lt_double_3_gt_; +typedef unsigned int unsignedint; + +class ImmersedBoundaryMesh3_3_Overloads : public ImmersedBoundaryMesh3_3{ + public: + using ImmersedBoundaryMesh3_3::ImmersedBoundaryMesh; + unsigned int GetNumNodes() const override { + PYBIND11_OVERLOAD( + unsignedint, + ImmersedBoundaryMesh3_3, + GetNumNodes, + ); + } + unsigned int GetNumElements() const override { + PYBIND11_OVERLOAD( + unsignedint, + ImmersedBoundaryMesh3_3, + GetNumElements, + ); + } + ::boost::numeric::ublas::c_vector GetVectorFromAtoB(::boost::numeric::ublas::c_vector const & rLocation1, ::boost::numeric::ublas::c_vector const & rLocation2) override { + PYBIND11_OVERLOAD( + _boost_numeric_ublas_c_vector_lt_double_3_gt_, + ImmersedBoundaryMesh3_3, + GetVectorFromAtoB, + rLocation1, +rLocation2); + } + ::boost::numeric::ublas::c_vector GetCentroidOfElement(unsigned int index) override { + PYBIND11_OVERLOAD( + _boost_numeric_ublas_c_vector_lt_double_3_gt_, + ImmersedBoundaryMesh3_3, + GetCentroidOfElement, + index); + } + void Clear() override { + PYBIND11_OVERLOAD( + void, + ImmersedBoundaryMesh3_3, + Clear, + ); + } + double GetVolumeOfElement(unsigned int index) override { + PYBIND11_OVERLOAD( + double, + ImmersedBoundaryMesh3_3, + GetVolumeOfElement, + index); + } + double GetSurfaceAreaOfElement(unsigned int index) override { + PYBIND11_OVERLOAD( + double, + ImmersedBoundaryMesh3_3, + GetSurfaceAreaOfElement, + index); + } + ::boost::numeric::ublas::c_vector CalculateMomentsOfElement(unsigned int index) override { + PYBIND11_OVERLOAD( + _boost_numeric_ublas_c_vector_lt_double_3_gt_, + ImmersedBoundaryMesh3_3, + CalculateMomentsOfElement, + index); + } + unsigned int SolveNodeMapping(unsigned int index) const override { + PYBIND11_OVERLOAD( + unsignedint, + ImmersedBoundaryMesh3_3, + SolveNodeMapping, + index); + } + +}; +void register_ImmersedBoundaryMesh3_3_class(py::module &m){ +py::class_ , AbstractMesh<3, 3> >(m, "ImmersedBoundaryMesh3_3") + .def(py::init<::std::vector *>, ::std::vector *>, ::std::vector *>, unsigned int, unsigned int >(), py::arg("nodes"), py::arg("elements"), py::arg("laminas") = std::vector *>{}, py::arg("numGridPtsX") = 128U, py::arg("numGridPtsY") = 128U) + .def(py::init< >()) + .def( + "rGetNodes", + (::std::vector *> const &(ImmersedBoundaryMesh3_3::*)() const ) &ImmersedBoundaryMesh3_3::rGetNodes, + " " , py::return_value_policy::reference_internal) + .def( + "GetElementIteratorBegin", + (::ImmersedBoundaryMesh<3, 3>::ImmersedBoundaryElementIterator(ImmersedBoundaryMesh3_3::*)(bool)) &ImmersedBoundaryMesh3_3::GetElementIteratorBegin, + " " , py::arg("skipDeletedElements") = true ) + .def( + "GetElementIteratorEnd", + (::ImmersedBoundaryMesh<3, 3>::ImmersedBoundaryElementIterator(ImmersedBoundaryMesh3_3::*)()) &ImmersedBoundaryMesh3_3::GetElementIteratorEnd, + " " ) + .def( + "GetLaminaIteratorBegin", + (::ImmersedBoundaryMesh<3, 3>::ImmersedBoundaryLaminaIterator(ImmersedBoundaryMesh3_3::*)(bool)) &ImmersedBoundaryMesh3_3::GetLaminaIteratorBegin, + " " , py::arg("skipDeletedLaminas") = true ) + .def( + "GetLaminaIteratorEnd", + (::ImmersedBoundaryMesh<3, 3>::ImmersedBoundaryLaminaIterator(ImmersedBoundaryMesh3_3::*)()) &ImmersedBoundaryMesh3_3::GetLaminaIteratorEnd, + " " ) + .def( + "GetNumNodes", + (unsigned int(ImmersedBoundaryMesh3_3::*)() const ) &ImmersedBoundaryMesh3_3::GetNumNodes, + " " ) + .def( + "GetNumElements", + (unsigned int(ImmersedBoundaryMesh3_3::*)() const ) &ImmersedBoundaryMesh3_3::GetNumElements, + " " ) + .def( + "GetNumAllElements", + (unsigned int(ImmersedBoundaryMesh3_3::*)() const ) &ImmersedBoundaryMesh3_3::GetNumAllElements, + " " ) + .def( + "GetNumLaminas", + (unsigned int(ImmersedBoundaryMesh3_3::*)() const ) &ImmersedBoundaryMesh3_3::GetNumLaminas, + " " ) + .def( + "GetNumGridPtsX", + (unsigned int(ImmersedBoundaryMesh3_3::*)() const ) &ImmersedBoundaryMesh3_3::GetNumGridPtsX, + " " ) + .def( + "GetNumGridPtsY", + (unsigned int(ImmersedBoundaryMesh3_3::*)() const ) &ImmersedBoundaryMesh3_3::GetNumGridPtsY, + " " ) + .def( + "GetCharacteristicNodeSpacing", + (double(ImmersedBoundaryMesh3_3::*)() const ) &ImmersedBoundaryMesh3_3::GetCharacteristicNodeSpacing, + " " ) + .def( + "GetSpacingRatio", + (double(ImmersedBoundaryMesh3_3::*)() const ) &ImmersedBoundaryMesh3_3::GetSpacingRatio, + " " ) + .def( + "GetMaxNodeIndex", + (unsigned int(ImmersedBoundaryMesh3_3::*)() const ) &ImmersedBoundaryMesh3_3::GetMaxNodeIndex, + " " ) + .def( + "GetMaxElementIndex", + (unsigned int(ImmersedBoundaryMesh3_3::*)() const ) &ImmersedBoundaryMesh3_3::GetMaxElementIndex, + " " ) + .def( + "GetMaxLaminaIndex", + (unsigned int(ImmersedBoundaryMesh3_3::*)() const ) &ImmersedBoundaryMesh3_3::GetMaxLaminaIndex, + " " ) + .def( + "GetVectorFromAtoB", + (::boost::numeric::ublas::c_vector(ImmersedBoundaryMesh3_3::*)(::boost::numeric::ublas::c_vector const &, ::boost::numeric::ublas::c_vector const &)) &ImmersedBoundaryMesh3_3::GetVectorFromAtoB, + " " , py::arg("rLocation1"), py::arg("rLocation2") ) + .def( + "SetNode", + (void(ImmersedBoundaryMesh3_3::*)(unsigned int, ::ChastePoint<3>)) &ImmersedBoundaryMesh3_3::SetNode, + " " , py::arg("nodeIndex"), py::arg("point") ) + .def( + "ConformToGeometry", + (void(ImmersedBoundaryMesh3_3::*)(::boost::numeric::ublas::c_vector &)) &ImmersedBoundaryMesh3_3::ConformToGeometry, + " " , py::arg("rLocation") ) + .def( + "rGet2dVelocityGrids", + (::boost::multi_array const &(ImmersedBoundaryMesh3_3::*)() const ) &ImmersedBoundaryMesh3_3::rGet2dVelocityGrids, + " " , py::return_value_policy::reference_internal) + .def( + "rGetModifiable2dVelocityGrids", + (::boost::multi_array &(ImmersedBoundaryMesh3_3::*)()) &ImmersedBoundaryMesh3_3::rGetModifiable2dVelocityGrids, + " " , py::return_value_policy::reference_internal) + .def( + "SetNumGridPtsX", + (void(ImmersedBoundaryMesh3_3::*)(unsigned int)) &ImmersedBoundaryMesh3_3::SetNumGridPtsX, + " " , py::arg("meshPointsX") ) + .def( + "SetNumGridPtsY", + (void(ImmersedBoundaryMesh3_3::*)(unsigned int)) &ImmersedBoundaryMesh3_3::SetNumGridPtsY, + " " , py::arg("meshPointsY") ) + .def( + "SetNumGridPtsXAndY", + (void(ImmersedBoundaryMesh3_3::*)(unsigned int)) &ImmersedBoundaryMesh3_3::SetNumGridPtsXAndY, + " " , py::arg("numGridPts") ) + .def( + "SetCharacteristicNodeSpacing", + (void(ImmersedBoundaryMesh3_3::*)(double)) &ImmersedBoundaryMesh3_3::SetCharacteristicNodeSpacing, + " " , py::arg("nodeSpacing") ) + .def( + "AddNode", + (unsigned int(ImmersedBoundaryMesh3_3::*)(::Node<3> *)) &ImmersedBoundaryMesh3_3::AddNode, + " " , py::arg("pNewNode") ) + .def( + "rGetElementFluidSources", + (::std::vector>> &(ImmersedBoundaryMesh3_3::*)()) &ImmersedBoundaryMesh3_3::rGetElementFluidSources, + " " , py::return_value_policy::reference_internal) + .def( + "rGetBalancingFluidSources", + (::std::vector>> &(ImmersedBoundaryMesh3_3::*)()) &ImmersedBoundaryMesh3_3::rGetBalancingFluidSources, + " " , py::return_value_policy::reference_internal) + .def( + "GetNeighbouringNodeIndices", + (::std::set(ImmersedBoundaryMesh3_3::*)(unsigned int)) &ImmersedBoundaryMesh3_3::GetNeighbouringNodeIndices, + " " , py::arg("nodeIndex") ) + .def( + "GetElement", + (::ImmersedBoundaryElement<3, 3> *(ImmersedBoundaryMesh3_3::*)(unsigned int) const ) &ImmersedBoundaryMesh3_3::GetElement, + " " , py::arg("index") , py::return_value_policy::reference) + .def( + "GetLamina", + (::ImmersedBoundaryElement<2, 3> *(ImmersedBoundaryMesh3_3::*)(unsigned int) const ) &ImmersedBoundaryMesh3_3::GetLamina, + " " , py::arg("index") , py::return_value_policy::reference) + .def( + "GetCentroidOfElement", + (::boost::numeric::ublas::c_vector(ImmersedBoundaryMesh3_3::*)(unsigned int)) &ImmersedBoundaryMesh3_3::GetCentroidOfElement, + " " , py::arg("index") ) + .def( + "ConstructFromMeshReader", + (void(ImmersedBoundaryMesh3_3::*)(::AbstractMeshReader<3, 3> &)) &ImmersedBoundaryMesh3_3::ConstructFromMeshReader, + " " , py::arg("rMeshReader") ) + .def( + "Clear", + (void(ImmersedBoundaryMesh3_3::*)()) &ImmersedBoundaryMesh3_3::Clear, + " " ) + .def( + "GetVolumeOfElement", + (double(ImmersedBoundaryMesh3_3::*)(unsigned int)) &ImmersedBoundaryMesh3_3::GetVolumeOfElement, + " " , py::arg("index") ) + .def( + "GetSurfaceAreaOfElement", + (double(ImmersedBoundaryMesh3_3::*)(unsigned int)) &ImmersedBoundaryMesh3_3::GetSurfaceAreaOfElement, + " " , py::arg("index") ) + .def( + "GetVoronoiSurfaceAreaOfElement", + (double(ImmersedBoundaryMesh3_3::*)(unsigned int)) &ImmersedBoundaryMesh3_3::GetVoronoiSurfaceAreaOfElement, + " " , py::arg("elemIdx") ) + .def( + "GetAverageNodeSpacingOfElement", + (double(ImmersedBoundaryMesh3_3::*)(unsigned int, bool)) &ImmersedBoundaryMesh3_3::GetAverageNodeSpacingOfElement, + " " , py::arg("index"), py::arg("recalculate") = true ) + .def( + "GetAverageNodeSpacingOfLamina", + (double(ImmersedBoundaryMesh3_3::*)(unsigned int, bool)) &ImmersedBoundaryMesh3_3::GetAverageNodeSpacingOfLamina, + " " , py::arg("index"), py::arg("recalculate") = true ) + .def( + "CalculateMomentsOfElement", + (::boost::numeric::ublas::c_vector(ImmersedBoundaryMesh3_3::*)(unsigned int)) &ImmersedBoundaryMesh3_3::CalculateMomentsOfElement, + " " , py::arg("index") ) + .def( + "GetElongationShapeFactorOfElement", + (double(ImmersedBoundaryMesh3_3::*)(unsigned int)) &ImmersedBoundaryMesh3_3::GetElongationShapeFactorOfElement, + " " , py::arg("elementIndex") ) + .def( + "GetTortuosityOfMesh", + (double(ImmersedBoundaryMesh3_3::*)()) &ImmersedBoundaryMesh3_3::GetTortuosityOfMesh, + " " ) + .def( + "GetSkewnessOfElementMassDistributionAboutAxis", + (double(ImmersedBoundaryMesh3_3::*)(unsigned int, ::boost::numeric::ublas::c_vector)) &ImmersedBoundaryMesh3_3::GetSkewnessOfElementMassDistributionAboutAxis, + " " , py::arg("elemIndex"), py::arg("axis") ) + .def( + "CalculateBoundingBoxOfElement", + (::ChasteCuboid<3>(ImmersedBoundaryMesh3_3::*)(unsigned int)) &ImmersedBoundaryMesh3_3::CalculateBoundingBoxOfElement, + " " , py::arg("index") ) + .def( + "GetShortAxisOfElement", + (::boost::numeric::ublas::c_vector(ImmersedBoundaryMesh3_3::*)(unsigned int)) &ImmersedBoundaryMesh3_3::GetShortAxisOfElement, + " " , py::arg("index") ) + .def( + "DivideElementAlongGivenAxis", + (unsigned int(ImmersedBoundaryMesh3_3::*)(::ImmersedBoundaryElement<3, 3> *, ::boost::numeric::ublas::c_vector, bool)) &ImmersedBoundaryMesh3_3::DivideElementAlongGivenAxis, + " " , py::arg("pElement"), py::arg("axisOfDivision"), py::arg("placeOriginalElementBelow") = false ) + .def( + "DivideElementAlongShortAxis", + (unsigned int(ImmersedBoundaryMesh3_3::*)(::ImmersedBoundaryElement<3, 3> *, bool)) &ImmersedBoundaryMesh3_3::DivideElementAlongShortAxis, + " " , py::arg("pElement"), py::arg("placeOriginalElementBelow") = false ) + .def( + "GetElementDivisionSpacing", + (double(ImmersedBoundaryMesh3_3::*)()) &ImmersedBoundaryMesh3_3::GetElementDivisionSpacing, + " " ) + .def( + "SetElementDivisionSpacing", + (void(ImmersedBoundaryMesh3_3::*)(double)) &ImmersedBoundaryMesh3_3::SetElementDivisionSpacing, + " " , py::arg("elementDivisionSpacing") ) + .def( + "GetNeighbourDist", + (double(ImmersedBoundaryMesh3_3::*)() const ) &ImmersedBoundaryMesh3_3::GetNeighbourDist, + " " ) + .def( + "SetCellRearrangementThreshold", + (void(ImmersedBoundaryMesh3_3::*)(double)) &ImmersedBoundaryMesh3_3::SetCellRearrangementThreshold, + " " , py::arg("cellRearrangementThreshold") ) + .def( + "GetCellRearrangementThreshold", + (double(ImmersedBoundaryMesh3_3::*)()) &ImmersedBoundaryMesh3_3::GetCellRearrangementThreshold, + " " ) + .def( + "SetNeighbourDist", + (void(ImmersedBoundaryMesh3_3::*)(double)) &ImmersedBoundaryMesh3_3::SetNeighbourDist, + " " , py::arg("neighbourDist") ) + .def( + "UpdateNodeLocationsVoronoiDiagramIfOutOfDate", + (void(ImmersedBoundaryMesh3_3::*)()) &ImmersedBoundaryMesh3_3::UpdateNodeLocationsVoronoiDiagramIfOutOfDate, + " " ) + .def( + "ReMesh", + (void(ImmersedBoundaryMesh3_3::*)(bool)) &ImmersedBoundaryMesh3_3::ReMesh, + " " , py::arg("randomOrder") = false ) + .def( + "ReMeshElement", + (void(ImmersedBoundaryMesh3_3::*)(::ImmersedBoundaryElement<3, 3> *, bool)) &ImmersedBoundaryMesh3_3::ReMeshElement, + " " , py::arg("pElement"), py::arg("randomOrder") ) + .def( + "ReMeshLamina", + (void(ImmersedBoundaryMesh3_3::*)(::ImmersedBoundaryElement<2, 3> *, bool)) &ImmersedBoundaryMesh3_3::ReMeshLamina, + " " , py::arg("pLamina"), py::arg("randomOrder") ) + .def( + "NodesInDifferentElementOrLamina", + (bool(ImmersedBoundaryMesh3_3::*)(::Node<3> *, ::Node<3> *)) &ImmersedBoundaryMesh3_3::NodesInDifferentElementOrLamina, + " " , py::arg("pNodeA"), py::arg("pNodeB") ) + .def( + "GetNeighbouringElementIndices", + (::std::set(ImmersedBoundaryMesh3_3::*)(unsigned int)) &ImmersedBoundaryMesh3_3::GetNeighbouringElementIndices, + " " , py::arg("elemIdx") ) + .def( + "CalculateLengthOfVoronoiEdge", + (double(ImmersedBoundaryMesh3_3::*)(::boost::polygon::voronoi_diagram::edge_type const &)) &ImmersedBoundaryMesh3_3::CalculateLengthOfVoronoiEdge, + " " , py::arg("rEdge") ) + .def( + "GetPolygonDistribution", + (::std::array(ImmersedBoundaryMesh3_3::*)()) &ImmersedBoundaryMesh3_3::GetPolygonDistribution, + " " ) + .def( + "rGetNodeLocationsVoronoiDiagram", + (::boost::polygon::voronoi_diagram const &(ImmersedBoundaryMesh3_3::*)(bool)) &ImmersedBoundaryMesh3_3::rGetNodeLocationsVoronoiDiagram, + " " , py::arg("update") = true , py::return_value_policy::reference_internal) + .def( + "GetVoronoiCellIdsIndexedByNodeIndex", + (::std::vector const &(ImmersedBoundaryMesh3_3::*)() const ) &ImmersedBoundaryMesh3_3::GetVoronoiCellIdsIndexedByNodeIndex, + " " , py::return_value_policy::reference_internal) + .def( + "ScaleUpToVoronoiCoordinate", + (int(ImmersedBoundaryMesh3_3::*)(double) const ) &ImmersedBoundaryMesh3_3::ScaleUpToVoronoiCoordinate, + " " , py::arg("location") ) + .def( + "ScaleDistanceDownFromVoronoi", + (double(ImmersedBoundaryMesh3_3::*)(double const) const ) &ImmersedBoundaryMesh3_3::ScaleDistanceDownFromVoronoi, + " " , py::arg("distance") ) + ; +} diff --git a/dynamic/wrappers/mesh/ImmersedBoundaryMesh3_3.cppwg.hpp b/dynamic/wrappers/mesh/ImmersedBoundaryMesh3_3.cppwg.hpp new file mode 100644 index 00000000..8f63d5f1 --- /dev/null +++ b/dynamic/wrappers/mesh/ImmersedBoundaryMesh3_3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryMesh3_3_hpp__pyplusplus_wrapper +#define ImmersedBoundaryMesh3_3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryMesh3_3_class(py::module &m); +#endif // ImmersedBoundaryMesh3_3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/mesh/ImmersedBoundaryPalisadeMeshGenerator.cppwg.cpp b/dynamic/wrappers/mesh/ImmersedBoundaryPalisadeMeshGenerator.cppwg.cpp new file mode 100644 index 00000000..a8ba433b --- /dev/null +++ b/dynamic/wrappers/mesh/ImmersedBoundaryPalisadeMeshGenerator.cppwg.cpp @@ -0,0 +1,26 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "ImmersedBoundaryPalisadeMeshGenerator.hpp" + +#include "ImmersedBoundaryPalisadeMeshGenerator.cppwg.hpp" + +namespace py = pybind11; +typedef ImmersedBoundaryPalisadeMeshGenerator ImmersedBoundaryPalisadeMeshGenerator; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +void register_ImmersedBoundaryPalisadeMeshGenerator_class(py::module &m){ +py::class_ >(m, "ImmersedBoundaryPalisadeMeshGenerator") + .def(py::init(), py::arg("numCellsWide"), py::arg("numNodesPerCell") = 100, py::arg("ellipseExponent") = 0.20000000000000001, py::arg("cellAspectRatio") = 2., py::arg("randomYMult") = 0., py::arg("basalLamina") = false, py::arg("apicalLamina") = false, py::arg("leakyLaminas") = false, py::arg("numFluidMeshPoints") = (2147483647 * 2U + 1U), py::arg("absoluteGap") = DOUBLE_UNSET) + .def(py::init< >()) + .def( + "GetMesh", + (::ImmersedBoundaryMesh<2, 2> *(ImmersedBoundaryPalisadeMeshGenerator::*)()) &ImmersedBoundaryPalisadeMeshGenerator::GetMesh, + " " , py::return_value_policy::reference) + ; +} diff --git a/dynamic/wrappers/mesh/ImmersedBoundaryPalisadeMeshGenerator.cppwg.hpp b/dynamic/wrappers/mesh/ImmersedBoundaryPalisadeMeshGenerator.cppwg.hpp new file mode 100644 index 00000000..425709d5 --- /dev/null +++ b/dynamic/wrappers/mesh/ImmersedBoundaryPalisadeMeshGenerator.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef ImmersedBoundaryPalisadeMeshGenerator_hpp__pyplusplus_wrapper +#define ImmersedBoundaryPalisadeMeshGenerator_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_ImmersedBoundaryPalisadeMeshGenerator_class(py::module &m); +#endif // ImmersedBoundaryPalisadeMeshGenerator_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/mesh/MutableElement1_2.cppwg.cpp b/dynamic/wrappers/mesh/MutableElement1_2.cppwg.cpp new file mode 100644 index 00000000..b2dac80a --- /dev/null +++ b/dynamic/wrappers/mesh/MutableElement1_2.cppwg.cpp @@ -0,0 +1,132 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "MutableElement.hpp" + +#include "MutableElement1_2.cppwg.hpp" + +namespace py = pybind11; +typedef MutableElement<1,2 > MutableElement1_2; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class MutableElement1_2_Overloads : public MutableElement1_2{ + public: + using MutableElement1_2::MutableElement; + void RegisterWithNodes() override { + PYBIND11_OVERLOAD( + void, + MutableElement1_2, + RegisterWithNodes, + ); + } + void MarkAsDeleted() override { + PYBIND11_OVERLOAD( + void, + MutableElement1_2, + MarkAsDeleted, + ); + } + void UpdateNode(unsigned int const & rIndex, ::Node<2> * pNode) override { + PYBIND11_OVERLOAD( + void, + MutableElement1_2, + UpdateNode, + rIndex, +pNode); + } + bool IsElementOnBoundary() const override { + PYBIND11_OVERLOAD( + bool, + MutableElement1_2, + IsElementOnBoundary, + ); + } + +}; +void register_MutableElement1_2_class(py::module &m){ +py::class_ , AbstractElement<1, 2> >(m, "MutableElement1_2") + .def(py::init(), py::arg("index")) + .def(py::init *> const & >(), py::arg("index"), py::arg("rNodes")) + .def( + "RegisterWithNodes", + (void(MutableElement1_2::*)()) &MutableElement1_2::RegisterWithNodes, + " " ) + .def( + "MarkAsDeleted", + (void(MutableElement1_2::*)()) &MutableElement1_2::MarkAsDeleted, + " " ) + .def( + "ResetIndex", + (void(MutableElement1_2::*)(unsigned int)) &MutableElement1_2::ResetIndex, + " " , py::arg("index") ) + .def( + "UpdateNode", + (void(MutableElement1_2::*)(unsigned int const &, ::Node<2> *)) &MutableElement1_2::UpdateNode, + " " , py::arg("rIndex"), py::arg("pNode") ) + .def( + "DeleteNode", + (void(MutableElement1_2::*)(unsigned int const &)) &MutableElement1_2::DeleteNode, + " " , py::arg("rIndex") ) + .def( + "AddNode", + (void(MutableElement1_2::*)(::Node<2> *, unsigned int const &)) &MutableElement1_2::AddNode, + " " , py::arg("pNode"), py::arg("rIndex") ) + .def( + "GetNodeLocalIndex", + (unsigned int(MutableElement1_2::*)(unsigned int) const ) &MutableElement1_2::GetNodeLocalIndex, + " " , py::arg("globalIndex") ) + .def( + "RegisterWithEdges", + (void(MutableElement1_2::*)()) &MutableElement1_2::RegisterWithEdges, + " " ) + .def( + "RebuildEdges", + (void(MutableElement1_2::*)()) &MutableElement1_2::RebuildEdges, + " " ) + .def( + "IsElementOnBoundary", + (bool(MutableElement1_2::*)() const ) &MutableElement1_2::IsElementOnBoundary, + " " ) + .def( + "SetEdgeHelper", + (void(MutableElement1_2::*)(::EdgeHelper<2> *)) &MutableElement1_2::SetEdgeHelper, + " " , py::arg("pEdgeHelper") ) + .def( + "ClearEdges", + (void(MutableElement1_2::*)()) &MutableElement1_2::ClearEdges, + " " ) + .def( + "BuildEdges", + (void(MutableElement1_2::*)()) &MutableElement1_2::BuildEdges, + " " ) + .def( + "GetEdgeGlobalIndex", + (unsigned int(MutableElement1_2::*)(unsigned int) const ) &MutableElement1_2::GetEdgeGlobalIndex, + " " , py::arg("localIndex") ) + .def( + "GetEdge", + (::Edge<2> *(MutableElement1_2::*)(unsigned int) const ) &MutableElement1_2::GetEdge, + " " , py::arg("localIndex") , py::return_value_policy::reference) + .def( + "GetNumEdges", + (unsigned int(MutableElement1_2::*)() const ) &MutableElement1_2::GetNumEdges, + " " ) + .def( + "GetNeighbouringElementAtEdgeIndex", + (::std::set(MutableElement1_2::*)(unsigned int)) &MutableElement1_2::GetNeighbouringElementAtEdgeIndex, + " " , py::arg("localIndex") ) + .def( + "ContainsEdge", + (bool(MutableElement1_2::*)(::Edge<2> const *) const ) &MutableElement1_2::ContainsEdge, + " " , py::arg("pEdge") ) + .def( + "GetLocalEdgeIndex", + (long int(MutableElement1_2::*)(::Edge<2> const *) const ) &MutableElement1_2::GetLocalEdgeIndex, + " " , py::arg("pEdge") ) + ; +} diff --git a/dynamic/wrappers/mesh/MutableElement1_2.cppwg.hpp b/dynamic/wrappers/mesh/MutableElement1_2.cppwg.hpp new file mode 100644 index 00000000..9736fd4a --- /dev/null +++ b/dynamic/wrappers/mesh/MutableElement1_2.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef MutableElement1_2_hpp__pyplusplus_wrapper +#define MutableElement1_2_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_MutableElement1_2_class(py::module &m); +#endif // MutableElement1_2_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/mesh/MutableElement2_3.cppwg.cpp b/dynamic/wrappers/mesh/MutableElement2_3.cppwg.cpp new file mode 100644 index 00000000..6f3b2eed --- /dev/null +++ b/dynamic/wrappers/mesh/MutableElement2_3.cppwg.cpp @@ -0,0 +1,132 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "MutableElement.hpp" + +#include "MutableElement2_3.cppwg.hpp" + +namespace py = pybind11; +typedef MutableElement<2,3 > MutableElement2_3; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class MutableElement2_3_Overloads : public MutableElement2_3{ + public: + using MutableElement2_3::MutableElement; + void RegisterWithNodes() override { + PYBIND11_OVERLOAD( + void, + MutableElement2_3, + RegisterWithNodes, + ); + } + void MarkAsDeleted() override { + PYBIND11_OVERLOAD( + void, + MutableElement2_3, + MarkAsDeleted, + ); + } + void UpdateNode(unsigned int const & rIndex, ::Node<3> * pNode) override { + PYBIND11_OVERLOAD( + void, + MutableElement2_3, + UpdateNode, + rIndex, +pNode); + } + bool IsElementOnBoundary() const override { + PYBIND11_OVERLOAD( + bool, + MutableElement2_3, + IsElementOnBoundary, + ); + } + +}; +void register_MutableElement2_3_class(py::module &m){ +py::class_ , AbstractElement<2, 3> >(m, "MutableElement2_3") + .def(py::init(), py::arg("index")) + .def(py::init *> const & >(), py::arg("index"), py::arg("rNodes")) + .def( + "RegisterWithNodes", + (void(MutableElement2_3::*)()) &MutableElement2_3::RegisterWithNodes, + " " ) + .def( + "MarkAsDeleted", + (void(MutableElement2_3::*)()) &MutableElement2_3::MarkAsDeleted, + " " ) + .def( + "ResetIndex", + (void(MutableElement2_3::*)(unsigned int)) &MutableElement2_3::ResetIndex, + " " , py::arg("index") ) + .def( + "UpdateNode", + (void(MutableElement2_3::*)(unsigned int const &, ::Node<3> *)) &MutableElement2_3::UpdateNode, + " " , py::arg("rIndex"), py::arg("pNode") ) + .def( + "DeleteNode", + (void(MutableElement2_3::*)(unsigned int const &)) &MutableElement2_3::DeleteNode, + " " , py::arg("rIndex") ) + .def( + "AddNode", + (void(MutableElement2_3::*)(::Node<3> *, unsigned int const &)) &MutableElement2_3::AddNode, + " " , py::arg("pNode"), py::arg("rIndex") ) + .def( + "GetNodeLocalIndex", + (unsigned int(MutableElement2_3::*)(unsigned int) const ) &MutableElement2_3::GetNodeLocalIndex, + " " , py::arg("globalIndex") ) + .def( + "RegisterWithEdges", + (void(MutableElement2_3::*)()) &MutableElement2_3::RegisterWithEdges, + " " ) + .def( + "RebuildEdges", + (void(MutableElement2_3::*)()) &MutableElement2_3::RebuildEdges, + " " ) + .def( + "IsElementOnBoundary", + (bool(MutableElement2_3::*)() const ) &MutableElement2_3::IsElementOnBoundary, + " " ) + .def( + "SetEdgeHelper", + (void(MutableElement2_3::*)(::EdgeHelper<3> *)) &MutableElement2_3::SetEdgeHelper, + " " , py::arg("pEdgeHelper") ) + .def( + "ClearEdges", + (void(MutableElement2_3::*)()) &MutableElement2_3::ClearEdges, + " " ) + .def( + "BuildEdges", + (void(MutableElement2_3::*)()) &MutableElement2_3::BuildEdges, + " " ) + .def( + "GetEdgeGlobalIndex", + (unsigned int(MutableElement2_3::*)(unsigned int) const ) &MutableElement2_3::GetEdgeGlobalIndex, + " " , py::arg("localIndex") ) + .def( + "GetEdge", + (::Edge<3> *(MutableElement2_3::*)(unsigned int) const ) &MutableElement2_3::GetEdge, + " " , py::arg("localIndex") , py::return_value_policy::reference) + .def( + "GetNumEdges", + (unsigned int(MutableElement2_3::*)() const ) &MutableElement2_3::GetNumEdges, + " " ) + .def( + "GetNeighbouringElementAtEdgeIndex", + (::std::set(MutableElement2_3::*)(unsigned int)) &MutableElement2_3::GetNeighbouringElementAtEdgeIndex, + " " , py::arg("localIndex") ) + .def( + "ContainsEdge", + (bool(MutableElement2_3::*)(::Edge<3> const *) const ) &MutableElement2_3::ContainsEdge, + " " , py::arg("pEdge") ) + .def( + "GetLocalEdgeIndex", + (long int(MutableElement2_3::*)(::Edge<3> const *) const ) &MutableElement2_3::GetLocalEdgeIndex, + " " , py::arg("pEdge") ) + ; +} diff --git a/dynamic/wrappers/mesh/MutableElement2_3.cppwg.hpp b/dynamic/wrappers/mesh/MutableElement2_3.cppwg.hpp new file mode 100644 index 00000000..32a874a4 --- /dev/null +++ b/dynamic/wrappers/mesh/MutableElement2_3.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef MutableElement2_3_hpp__pyplusplus_wrapper +#define MutableElement2_3_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_MutableElement2_3_class(py::module &m); +#endif // MutableElement2_3_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/pde/AbstractCellCycleModelOdeSolver.cppwg.cpp b/dynamic/wrappers/pde/AbstractCellCycleModelOdeSolver.cppwg.cpp new file mode 100644 index 00000000..5fef9fdb --- /dev/null +++ b/dynamic/wrappers/pde/AbstractCellCycleModelOdeSolver.cppwg.cpp @@ -0,0 +1,102 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "AbstractCellCycleModelOdeSolver.hpp" + +#include "AbstractCellCycleModelOdeSolver.cppwg.hpp" + +namespace py = pybind11; +typedef AbstractCellCycleModelOdeSolver AbstractCellCycleModelOdeSolver; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); + +class AbstractCellCycleModelOdeSolver_Overloads : public AbstractCellCycleModelOdeSolver{ + public: + using AbstractCellCycleModelOdeSolver::AbstractCellCycleModelOdeSolver; + bool IsSetUp() override { + PYBIND11_OVERLOAD_PURE( + bool, + AbstractCellCycleModelOdeSolver, + IsSetUp, + ); + } + void Reset() override { + PYBIND11_OVERLOAD_PURE( + void, + AbstractCellCycleModelOdeSolver, + Reset, + ); + } + void Initialise() override { + PYBIND11_OVERLOAD_PURE( + void, + AbstractCellCycleModelOdeSolver, + Initialise, + ); + } + bool IsAdaptive() override { + PYBIND11_OVERLOAD( + bool, + AbstractCellCycleModelOdeSolver, + IsAdaptive, + ); + } + +}; +void register_AbstractCellCycleModelOdeSolver_class(py::module &m){ +py::class_ >(m, "AbstractCellCycleModelOdeSolver") + .def(py::init< >()) + .def( + "IsSetUp", + (bool(AbstractCellCycleModelOdeSolver::*)()) &AbstractCellCycleModelOdeSolver::IsSetUp, + " " ) + .def( + "Reset", + (void(AbstractCellCycleModelOdeSolver::*)()) &AbstractCellCycleModelOdeSolver::Reset, + " " ) + .def( + "SolveAndUpdateStateVariable", + (void(AbstractCellCycleModelOdeSolver::*)(::AbstractOdeSystem *, double, double, double)) &AbstractCellCycleModelOdeSolver::SolveAndUpdateStateVariable, + " " , py::arg("pAbstractOdeSystem"), py::arg("startTime"), py::arg("endTime"), py::arg("timeStep") ) + .def( + "Initialise", + (void(AbstractCellCycleModelOdeSolver::*)()) &AbstractCellCycleModelOdeSolver::Initialise, + " " ) + .def( + "StoppingEventOccurred", + (bool(AbstractCellCycleModelOdeSolver::*)()) &AbstractCellCycleModelOdeSolver::StoppingEventOccurred, + " " ) + .def( + "GetStoppingTime", + (double(AbstractCellCycleModelOdeSolver::*)()) &AbstractCellCycleModelOdeSolver::GetStoppingTime, + " " ) + .def( + "SetSizeOfOdeSystem", + (void(AbstractCellCycleModelOdeSolver::*)(unsigned int)) &AbstractCellCycleModelOdeSolver::SetSizeOfOdeSystem, + " " , py::arg("sizeOfOdeSystem") ) + .def( + "GetSizeOfOdeSystem", + (unsigned int(AbstractCellCycleModelOdeSolver::*)()) &AbstractCellCycleModelOdeSolver::GetSizeOfOdeSystem, + " " ) + .def( + "CheckForStoppingEvents", + (void(AbstractCellCycleModelOdeSolver::*)()) &AbstractCellCycleModelOdeSolver::CheckForStoppingEvents, + " " ) + .def( + "SetMaxSteps", + (void(AbstractCellCycleModelOdeSolver::*)(long int)) &AbstractCellCycleModelOdeSolver::SetMaxSteps, + " " , py::arg("numSteps") ) + .def( + "SetTolerances", + (void(AbstractCellCycleModelOdeSolver::*)(double, double)) &AbstractCellCycleModelOdeSolver::SetTolerances, + " " , py::arg("relTol") = 1.0E-4, py::arg("absTol") = 9.9999999999999995E-7 ) + .def( + "IsAdaptive", + (bool(AbstractCellCycleModelOdeSolver::*)()) &AbstractCellCycleModelOdeSolver::IsAdaptive, + " " ) + ; +} diff --git a/dynamic/wrappers/pde/AbstractCellCycleModelOdeSolver.cppwg.hpp b/dynamic/wrappers/pde/AbstractCellCycleModelOdeSolver.cppwg.hpp new file mode 100644 index 00000000..e3168416 --- /dev/null +++ b/dynamic/wrappers/pde/AbstractCellCycleModelOdeSolver.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef AbstractCellCycleModelOdeSolver_hpp__pyplusplus_wrapper +#define AbstractCellCycleModelOdeSolver_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_AbstractCellCycleModelOdeSolver_class(py::module &m); +#endif // AbstractCellCycleModelOdeSolver_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/pde/AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1.cppwg.cpp b/dynamic/wrappers/pde/AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1.cppwg.cpp new file mode 100644 index 00000000..f3b402c2 --- /dev/null +++ b/dynamic/wrappers/pde/AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1.cppwg.cpp @@ -0,0 +1,80 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "AbstractLinearParabolicPdeSystemForCoupledOdeSystem.hpp" + +#include "AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1.cppwg.hpp" + +namespace py = pybind11; +typedef AbstractLinearParabolicPdeSystemForCoupledOdeSystem<2,2,1 > AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); +typedef ::boost::numeric::ublas::c_matrix _boost_numeric_ublas_c_matrix_lt_double_2_2_gt_; + +class AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1_Overloads : public AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1{ + public: + using AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1::AbstractLinearParabolicPdeSystemForCoupledOdeSystem; + double ComputeDuDtCoefficientFunction(::ChastePoint<2> const & rX, unsigned int pdeIndex) override { + PYBIND11_OVERLOAD_PURE( + double, + AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1, + ComputeDuDtCoefficientFunction, + rX, +pdeIndex); + } + double ComputeSourceTerm(::ChastePoint<2> const & rX, ::boost::numeric::ublas::c_vector & rU, ::std::vector & rOdeSolution, unsigned int pdeIndex) override { + PYBIND11_OVERLOAD_PURE( + double, + AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1, + ComputeSourceTerm, + rX, +rU, +rOdeSolution, +pdeIndex); + } + double ComputeSourceTermAtNode(::Node<2> const & rNode, ::boost::numeric::ublas::c_vector & rU, ::std::vector & rOdeSolution, unsigned int pdeIndex) override { + PYBIND11_OVERLOAD( + double, + AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1, + ComputeSourceTermAtNode, + rNode, +rU, +rOdeSolution, +pdeIndex); + } + ::boost::numeric::ublas::c_matrix ComputeDiffusionTerm(::ChastePoint<2> const & rX, unsigned int pdeIndex, ::Element<2, 2> * pElement) override { + PYBIND11_OVERLOAD_PURE( + _boost_numeric_ublas_c_matrix_lt_double_2_2_gt_, + AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1, + ComputeDiffusionTerm, + rX, +pdeIndex, +pElement); + } + +}; +void register_AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1_class(py::module &m){ +py::class_ >(m, "AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1") + .def(py::init< >()) + .def( + "ComputeDuDtCoefficientFunction", + (double(AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1::*)(::ChastePoint<2> const &, unsigned int)) &AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1::ComputeDuDtCoefficientFunction, + " " , py::arg("rX"), py::arg("pdeIndex") ) + .def( + "ComputeSourceTerm", + (double(AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1::*)(::ChastePoint<2> const &, ::boost::numeric::ublas::c_vector &, ::std::vector &, unsigned int)) &AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1::ComputeSourceTerm, + " " , py::arg("rX"), py::arg("rU"), py::arg("rOdeSolution"), py::arg("pdeIndex") ) + .def( + "ComputeSourceTermAtNode", + (double(AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1::*)(::Node<2> const &, ::boost::numeric::ublas::c_vector &, ::std::vector &, unsigned int)) &AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1::ComputeSourceTermAtNode, + " " , py::arg("rNode"), py::arg("rU"), py::arg("rOdeSolution"), py::arg("pdeIndex") ) + .def( + "ComputeDiffusionTerm", + (::boost::numeric::ublas::c_matrix(AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1::*)(::ChastePoint<2> const &, unsigned int, ::Element<2, 2> *)) &AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1::ComputeDiffusionTerm, + " " , py::arg("rX"), py::arg("pdeIndex"), py::arg("pElement") = __null ) + ; +} diff --git a/dynamic/wrappers/pde/AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1.cppwg.hpp b/dynamic/wrappers/pde/AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1.cppwg.hpp new file mode 100644 index 00000000..0d460d11 --- /dev/null +++ b/dynamic/wrappers/pde/AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1_hpp__pyplusplus_wrapper +#define AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1_class(py::module &m); +#endif // AbstractLinearParabolicPdeSystemForCoupledOdeSystem2_2_1_hpp__pyplusplus_wrapper diff --git a/dynamic/wrappers/pde/AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1.cppwg.cpp b/dynamic/wrappers/pde/AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1.cppwg.cpp new file mode 100644 index 00000000..e3ac614f --- /dev/null +++ b/dynamic/wrappers/pde/AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1.cppwg.cpp @@ -0,0 +1,80 @@ +#include +#include +#include +#include +#include +#include +#include "SmartPointers.hpp" +#include "UblasIncludes.hpp" +#include "AbstractLinearParabolicPdeSystemForCoupledOdeSystem.hpp" + +#include "AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1.cppwg.hpp" + +namespace py = pybind11; +typedef AbstractLinearParabolicPdeSystemForCoupledOdeSystem<3,3,1 > AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1; +PYBIND11_DECLARE_HOLDER_TYPE(T, boost::shared_ptr); +typedef ::boost::numeric::ublas::c_matrix _boost_numeric_ublas_c_matrix_lt_double_3_3_gt_; + +class AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1_Overloads : public AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1{ + public: + using AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1::AbstractLinearParabolicPdeSystemForCoupledOdeSystem; + double ComputeDuDtCoefficientFunction(::ChastePoint<3> const & rX, unsigned int pdeIndex) override { + PYBIND11_OVERLOAD_PURE( + double, + AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1, + ComputeDuDtCoefficientFunction, + rX, +pdeIndex); + } + double ComputeSourceTerm(::ChastePoint<3> const & rX, ::boost::numeric::ublas::c_vector & rU, ::std::vector & rOdeSolution, unsigned int pdeIndex) override { + PYBIND11_OVERLOAD_PURE( + double, + AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1, + ComputeSourceTerm, + rX, +rU, +rOdeSolution, +pdeIndex); + } + double ComputeSourceTermAtNode(::Node<3> const & rNode, ::boost::numeric::ublas::c_vector & rU, ::std::vector & rOdeSolution, unsigned int pdeIndex) override { + PYBIND11_OVERLOAD( + double, + AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1, + ComputeSourceTermAtNode, + rNode, +rU, +rOdeSolution, +pdeIndex); + } + ::boost::numeric::ublas::c_matrix ComputeDiffusionTerm(::ChastePoint<3> const & rX, unsigned int pdeIndex, ::Element<3, 3> * pElement) override { + PYBIND11_OVERLOAD_PURE( + _boost_numeric_ublas_c_matrix_lt_double_3_3_gt_, + AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1, + ComputeDiffusionTerm, + rX, +pdeIndex, +pElement); + } + +}; +void register_AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1_class(py::module &m){ +py::class_ >(m, "AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1") + .def(py::init< >()) + .def( + "ComputeDuDtCoefficientFunction", + (double(AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1::*)(::ChastePoint<3> const &, unsigned int)) &AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1::ComputeDuDtCoefficientFunction, + " " , py::arg("rX"), py::arg("pdeIndex") ) + .def( + "ComputeSourceTerm", + (double(AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1::*)(::ChastePoint<3> const &, ::boost::numeric::ublas::c_vector &, ::std::vector &, unsigned int)) &AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1::ComputeSourceTerm, + " " , py::arg("rX"), py::arg("rU"), py::arg("rOdeSolution"), py::arg("pdeIndex") ) + .def( + "ComputeSourceTermAtNode", + (double(AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1::*)(::Node<3> const &, ::boost::numeric::ublas::c_vector &, ::std::vector &, unsigned int)) &AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1::ComputeSourceTermAtNode, + " " , py::arg("rNode"), py::arg("rU"), py::arg("rOdeSolution"), py::arg("pdeIndex") ) + .def( + "ComputeDiffusionTerm", + (::boost::numeric::ublas::c_matrix(AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1::*)(::ChastePoint<3> const &, unsigned int, ::Element<3, 3> *)) &AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1::ComputeDiffusionTerm, + " " , py::arg("rX"), py::arg("pdeIndex"), py::arg("pElement") = __null ) + ; +} diff --git a/dynamic/wrappers/pde/AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1.cppwg.hpp b/dynamic/wrappers/pde/AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1.cppwg.hpp new file mode 100644 index 00000000..71634219 --- /dev/null +++ b/dynamic/wrappers/pde/AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1.cppwg.hpp @@ -0,0 +1,6 @@ +#ifndef AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1_hpp__pyplusplus_wrapper +#define AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1_hpp__pyplusplus_wrapper + +namespace py = pybind11; +void register_AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1_class(py::module &m); +#endif // AbstractLinearParabolicPdeSystemForCoupledOdeSystem3_3_1_hpp__pyplusplus_wrapper