#62 add immersed boundary wrappers

dynamic/wrappers/cell_based/AbstractCentreBasedDivisionRule2_2.cppwg.cpp

@@ -0,0 +1,50 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <set>
+#include <vector>
+#include <string>
+#include <map>
+#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<T>);
+typedef ::std::pair<boost::numeric::ublas::c_vector<double, 2>, boost::numeric::ublas::c_vector<double, 2>> _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<double, 2>, boost::numeric::ublas::c_vector<double, 2>> 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_<AbstractCentreBasedDivisionRule2_2 , AbstractCentreBasedDivisionRule2_2_Overloads , boost::shared_ptr<AbstractCentreBasedDivisionRule2_2 > >(m, "AbstractCentreBasedDivisionRule2_2")
+ .def(py::init< >())
+ .def(
+ "CalculateCellDivisionVector", 
+ (::std::pair<boost::numeric::ublas::c_vector<double, 2>, boost::numeric::ublas::c_vector<double, 2>>(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") )
+ ;
+}

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

dynamic/wrappers/cell_based/AbstractCentreBasedDivisionRule3_3.cppwg.cpp

@@ -0,0 +1,50 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <set>
+#include <vector>
+#include <string>
+#include <map>
+#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<T>);
+typedef ::std::pair<boost::numeric::ublas::c_vector<double, 3>, boost::numeric::ublas::c_vector<double, 3>> _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<double, 3>, boost::numeric::ublas::c_vector<double, 3>> 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_<AbstractCentreBasedDivisionRule3_3 , AbstractCentreBasedDivisionRule3_3_Overloads , boost::shared_ptr<AbstractCentreBasedDivisionRule3_3 > >(m, "AbstractCentreBasedDivisionRule3_3")
+ .def(py::init< >())
+ .def(
+ "CalculateCellDivisionVector", 
+ (::std::pair<boost::numeric::ublas::c_vector<double, 3>, boost::numeric::ublas::c_vector<double, 3>>(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") )
+ ;
+}

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

dynamic/wrappers/cell_based/AbstractImmersedBoundaryDivisionRule2.cppwg.cpp

@@ -0,0 +1,50 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <set>
+#include <vector>
+#include <string>
+#include <map>
+#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<T>);
+typedef ::boost::numeric::ublas::c_vector<double, 2> _boost_numeric_ublas_c_vector_lt_double_2_gt_;
+
+class AbstractImmersedBoundaryDivisionRule2_Overloads : public AbstractImmersedBoundaryDivisionRule2{
+ public:
+ using AbstractImmersedBoundaryDivisionRule2::AbstractImmersedBoundaryDivisionRule;
+ ::boost::numeric::ublas::c_vector<double, 2> 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_<AbstractImmersedBoundaryDivisionRule2 , AbstractImmersedBoundaryDivisionRule2_Overloads , boost::shared_ptr<AbstractImmersedBoundaryDivisionRule2 > >(m, "AbstractImmersedBoundaryDivisionRule2")
+ .def(py::init< >())
+ .def(
+ "CalculateCellDivisionVector", 
+ (::boost::numeric::ublas::c_vector<double, 2>(AbstractImmersedBoundaryDivisionRule2::*)(::CellPtr, ::ImmersedBoundaryCellPopulation<2> &)) &AbstractImmersedBoundaryDivisionRule2::CalculateCellDivisionVector, 
+ " " , py::arg("pParentCell"), py::arg("rCellPopulation") )
+ .def(
+ "OutputCellImmersedBoundaryDivisionRuleInfo", 
+ (void(AbstractImmersedBoundaryDivisionRule2::*)(::out_stream &)) &AbstractImmersedBoundaryDivisionRule2::OutputCellImmersedBoundaryDivisionRuleInfo, 
+ " " , py::arg("rParamsFile") )
+ ;
+}

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

dynamic/wrappers/cell_based/AbstractImmersedBoundaryDivisionRule3.cppwg.cpp

@@ -0,0 +1,50 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <set>
+#include <vector>
+#include <string>
+#include <map>
+#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<T>);
+typedef ::boost::numeric::ublas::c_vector<double, 3> _boost_numeric_ublas_c_vector_lt_double_3_gt_;
+
+class AbstractImmersedBoundaryDivisionRule3_Overloads : public AbstractImmersedBoundaryDivisionRule3{
+ public:
+ using AbstractImmersedBoundaryDivisionRule3::AbstractImmersedBoundaryDivisionRule;
+ ::boost::numeric::ublas::c_vector<double, 3> 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_<AbstractImmersedBoundaryDivisionRule3 , AbstractImmersedBoundaryDivisionRule3_Overloads , boost::shared_ptr<AbstractImmersedBoundaryDivisionRule3 > >(m, "AbstractImmersedBoundaryDivisionRule3")
+ .def(py::init< >())
+ .def(
+ "CalculateCellDivisionVector", 
+ (::boost::numeric::ublas::c_vector<double, 3>(AbstractImmersedBoundaryDivisionRule3::*)(::CellPtr, ::ImmersedBoundaryCellPopulation<3> &)) &AbstractImmersedBoundaryDivisionRule3::CalculateCellDivisionVector, 
+ " " , py::arg("pParentCell"), py::arg("rCellPopulation") )
+ .def(
+ "OutputCellImmersedBoundaryDivisionRuleInfo", 
+ (void(AbstractImmersedBoundaryDivisionRule3::*)(::out_stream &)) &AbstractImmersedBoundaryDivisionRule3::OutputCellImmersedBoundaryDivisionRuleInfo, 
+ " " , py::arg("rParamsFile") )
+ ;
+}

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

dynamic/wrappers/cell_based/AbstractImmersedBoundaryForce2.cppwg.cpp

@@ -0,0 +1,73 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <set>
+#include <vector>
+#include <string>
+#include <map>
+#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<T>);
+
+class AbstractImmersedBoundaryForce2_Overloads : public AbstractImmersedBoundaryForce2{
+ public:
+ using AbstractImmersedBoundaryForce2::AbstractImmersedBoundaryForce;
+ void AddImmersedBoundaryForceContribution(::std::vector<std::pair<Node<2> *, 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_<AbstractImmersedBoundaryForce2 , AbstractImmersedBoundaryForce2_Overloads , boost::shared_ptr<AbstractImmersedBoundaryForce2 > >(m, "AbstractImmersedBoundaryForce2")
+ .def(py::init< >())
+ .def(
+ "AddImmersedBoundaryForceContribution", 
+ (void(AbstractImmersedBoundaryForce2::*)(::std::vector<std::pair<Node<2> *, 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") )
+ ;
+}

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

dynamic/wrappers/cell_based/AbstractImmersedBoundaryForce3.cppwg.cpp

@@ -0,0 +1,73 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <set>
+#include <vector>
+#include <string>
+#include <map>
+#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<T>);
+
+class AbstractImmersedBoundaryForce3_Overloads : public AbstractImmersedBoundaryForce3{
+ public:
+ using AbstractImmersedBoundaryForce3::AbstractImmersedBoundaryForce;
+ void AddImmersedBoundaryForceContribution(::std::vector<std::pair<Node<3> *, 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_<AbstractImmersedBoundaryForce3 , AbstractImmersedBoundaryForce3_Overloads , boost::shared_ptr<AbstractImmersedBoundaryForce3 > >(m, "AbstractImmersedBoundaryForce3")
+ .def(py::init< >())
+ .def(
+ "AddImmersedBoundaryForceContribution", 
+ (void(AbstractImmersedBoundaryForce3::*)(::std::vector<std::pair<Node<3> *, 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") )
+ ;
+}

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