name, path, and parent of moose.vec are not vectorised.

Author: Dilawar Singh

pybind11/MooseVec.cpp

@@ -57,6 +57,11 @@ const string MooseVec::path() const
     return path_;
 }
 
+ObjId MooseVec::parent() const
+{
+    return Neutral::parent(oid_);
+}
+
 unsigned int MooseVec::len()
 {
     return (unsigned int)size();
@@ -79,24 +84,6 @@ ObjId MooseVec::getFieldItem(const size_t i) const
     return ObjId(oid_.path(), oid_.dataIndex, i);
 }
 
-void MooseVec::setAttrOneToAll(const string& name, const py::object& val)
-{
-    for (size_t i = 0; i < size(); i++) setFieldGeneric(getItem(i), name, val);
-}
-
-void MooseVec::setAttrOneToOne(const string& name, const py::sequence& val)
-{
-    if (py::len(val) != size())
-        throw runtime_error(
-            "Length of sequence on the right hand side "
-            "does not match size of vector. "
-            "Expected " +
-            to_string(size()) + ", got " + to_string(py::len(val)));
-
-    for (size_t i = 0; i < size(); i++)
-        setFieldGeneric(getItem(i), name, val[i]);
-}
-
 vector<py::object> MooseVec::getAttribute(const string& name)
 {
     vector<py::object> res(size());

pybind11/MooseVec.h

@@ -30,6 +30,8 @@ class MooseVec
 
     const string name() const;
 
+    ObjId parent() const;
+
     unsigned int len();
 
     const ObjId& getItemRef(const size_t i) const;
@@ -40,16 +42,44 @@ class MooseVec
     ObjId getFieldItem(const size_t i) const;
 
     // Set attribute to vector.
-    void setAttrOneToAll(const string& name, const py::object& val);
+    // void setAttrOneToAll(const string& name, const py::object& val);
+    // void setAttrOneToOne(const string& name, const py::sequence& val);
+
+    template<typename T>
+    bool setAttrOneToAll(const string& name, const T& val)
+    {
+        bool res = true;
+        for (size_t i = 0; i < size(); i++) 
+            res &= Field<T>::set(getItem(i), name, val);
+        return res;
+    }
+
+
+    template<typename T=double>
+    bool setAttrOneToOne(const string& name, const vector<T>& val)
+    {
+        if (val.size() != size())
+            throw runtime_error(
+                    "Length of sequence on the right hand side "
+                    "does not match size of vector. "
+                    "Expected " +
+                    to_string(size()) + ", got " + to_string(val.size()));
+
+        bool res = true;
+        for (size_t i = 0; i < size(); i++)
+            res &= Field<T>::set(getItem(i), name, val[i]);
+
+        return res;
+    }
 
-    void setAttrOneToOne(const string& name, const py::sequence& val);
 
     // Get attributes.
     vector<py::object> getAttribute(const string& name);
     py::array_t<double> getAttributeNumpy(const string& name);
 
     vector<ObjId> objs() const;
 
+
     ObjId connectToSingle(const string& srcfield, const ObjId& tgt, const string& tgtfield, const string& msgtype);
 
     ObjId connectToVec(const string& srcfield, const MooseVec& tgt, const string& tgtfield, const string& msgtype);

pybind11/pymoose.cpp

@@ -260,19 +260,8 @@ PYBIND11_MODULE(_moose, m)
         //---------------------------------------------------------------------
         //  Connect
         //---------------------------------------------------------------------
-        // This would be so much easier with c++17.
         .def("connect", &shellConnect, "srcfield"_a, "dest"_a
                 , "destfield"_a, "msgtype"_a="Single")
-        // .def("connect",
-        //      [](const ObjId &src, const string &srcfield, const ObjId &tgt,
-        //         const string &tgtfield, const string &type) {
-        //      return shellConnect(src, srcfield, tgt, tgtfield, type);
-        //  }, "src"_a, "srcfield"_a, "dest"_a, "destfield"_a, "msgtype"_a = "Single")
-        // .def("connect", [](const ObjId &src, const string &srcfield,
-        //                    const MooseVec &tgtvec, const string &tgtfield,
-        //                    const string &type) {
-        //      return shellConnect(src, srcfield, tgtvec.obj(), tgtfield, type);
-        //  }, "src"_a, "srcfield"_a, "dest"_a, "destfield"_a, "msgtype"_a="Single")
         //---------------------------------------------------------------------
         //  Extra
         //---------------------------------------------------------------------
@@ -301,10 +290,8 @@ PYBIND11_MODULE(_moose, m)
         .def(py::init<const string &, unsigned int, const string &>(), "path"_a,
              "n"_a = 1, "dtype"_a = "Neutral")  // Default
         .def(py::init<const ObjId &>())
-        .def("connect", &MooseVec::connectToSingle)
-        .def("connect", &MooseVec::connectToVec)
-        .def_property_readonly("name", &MooseVec::name)
-        .def_property_readonly("path", &MooseVec::path)
+        .def("__eq__", [](const MooseVec &a, const MooseVec &b) { return a.obj() == b.obj(); })
+        .def("__ne__", [](const MooseVec &a, const MooseVec &b) { return a.obj() != b.obj(); })
         .def("__len__", &MooseVec::len)
         .def("__iter__",
              [](MooseVec &v) {
@@ -315,8 +302,12 @@ PYBIND11_MODULE(_moose, m)
              },
              py::keep_alive<0, 1>())
         .def("__getitem__", &MooseVec::getItem)
-        .def("__setattr__", &MooseVec::setAttrOneToAll)
-        .def("__setattr__", &MooseVec::setAttrOneToOne)
+        .def("__setattr__", &MooseVec::setAttrOneToOne<double>)
+        .def("__setattr__", &MooseVec::setAttrOneToOne<string>)
+        .def("__setattr__", &MooseVec::setAttrOneToOne<bool>)
+        .def("__setattr__", &MooseVec::setAttrOneToAll<double>)
+        .def("__setattr__", &MooseVec::setAttrOneToAll<string>)
+        .def("__setattr__", &MooseVec::setAttrOneToAll<bool>)
         .def("__getattr__", &MooseVec::getAttribute)
         .def("__repr__", [](const MooseVec & v)->string {
              return "<moose.vec class=" + v.dtype() + " path=" + v.path() +
@@ -328,7 +319,15 @@ PYBIND11_MODULE(_moose, m)
         .def_property_readonly("vec", [](const MooseVec &vec) { return &vec; },
                                py::return_value_policy::reference_internal)
         .def_property_readonly("type",
-                               [](const MooseVec &v) { return "moose.vec"; });
+                               [](const MooseVec &v) { return "moose.vec"; })
+        .def("connect", &MooseVec::connectToSingle)
+        .def("connect", &MooseVec::connectToVec)
+
+        // Thi properties are not vectorised. 
+        .def_property_readonly("parent", &MooseVec::parent)
+        .def_property_readonly("name", &MooseVec::name)
+        .def_property_readonly("path", &MooseVec::path)
+        ;
 
     // Module functions.
     m.def("getShell",

tests/py_moose/test_api.py

@@ -43,7 +43,8 @@ def test_vec():
     assert v[0] == v.vec[0], (v[0], v.vec[0])
     x = [random.random() for i in range(100)]
     v.conc = x
-    assert np.equal(v.conc, x).all()
+    assert sum(v.conc) == sum(x)
+    assert np.allclose(v.conc, x), (v.conc, x)
 
 def test_finfos():
     s = moose.SimpleSynHandler('synh')
@@ -132,7 +133,12 @@ def test_access():
         raise RuntimeError("Should have failed.")
     a2 = moose.element(a1)
     a3 = moose.element(a1.path)
-    assert a2 == a3
+    assert a2 == a3, (a2, a3)
+
+def test_element():
+    a = moose.Pool('xxxx', 2)
+    ae = moose.element(a)
+    assert ae.parent == a.parent, (ae.parent, a.parent)
 
 
 def main():
@@ -144,6 +150,7 @@ def main():
     test_inheritance()
     test_access()
     test_vec()
+    test_element()
 
 if __name__ == '__main__':
     main()