vec values are returned as numpy array.

Author: Dilawar Singh

pybind11/MooseVec.cpp

@@ -22,12 +22,9 @@ namespace py = pybind11;
 
 MooseVec::MooseVec(const string& path, unsigned int n = 0,
                    const string& dtype = "Neutral")
-    : path_(path), useDataIndex_(false)
+    : path_(path)
 {
-    if (! mooseExists(path))
-        oid_ = mooseCreateFromPath(dtype, path, n);
-    else
-        oid_ = ObjId(path);
+    oid_ = ObjId(path);
 }
 
 MooseVec::MooseVec(const ObjId& oid) : oid_(oid), path_(oid.path())
@@ -100,14 +97,44 @@ void MooseVec::setAttrOneToOne(const string& name, const py::sequence& val)
         setFieldGeneric(getItem(i), name, val[i]);
 }
 
-vector<py::object> MooseVec::getAttr(const string& name)
+vector<py::object> MooseVec::getAttribute(const string& name)
 {
     vector<py::object> res(size());
     for (unsigned int i = 0; i < size(); i++)
         res[i] = getFieldGeneric(getItem(i), name);
     return res;
 }
 
+// FIXME: Only double is supported here. Not sure if this is enough.
+py::array_t<double> MooseVec::getAttributeNumpy(const string &name)
+{
+    auto cinfo = oid_.element()->cinfo();
+    auto finfo = cinfo->findFinfo(name);
+
+    if (!finfo) {
+        throw py::key_error(name + " is not found on '" + oid_.path() + "'.");
+    }
+
+    string finfoType = cinfo->getFinfoType(finfo);
+
+    // Either return a simple value (ValueFinfo), list, dict or DestFinfo
+    // setter.
+    // The DestFinfo setter is a function.
+
+    vector<double> res(size());
+    if (finfoType == "ValueFinfo") {
+        for (unsigned int i = 0; i < size(); i++)
+            res[i] = getField<double>(getItem(i), name);
+        return py::array_t<double>(res.size(), res.data());
+    }
+
+    throw runtime_error("getAttributeNumpy::NotImplemented : " + name +
+                        " with rttType " + finfo->rttiType() + " and type: '" +
+                        finfoType + "'");
+    return py::array_t<double>();
+}
+
+
 ObjId MooseVec::connectToSingle(const string& srcfield, const ObjId& tgt,
                                 const string& tgtfield, const string& msgtype)
 {
@@ -144,11 +171,11 @@ size_t MooseVec::id() const
 
 void MooseVec::generateIterator()
 {
-    iterator_.resize(size());
-    for (size_t i = 0; i < size(); i++) iterator_[i] = getItem(i);
+    objs_.resize(size());
+    for (size_t i = 0; i < size(); i++) objs_[i] = getItem(i);
 }
 
 const vector<ObjId>& MooseVec::objref() const
 {
-    return iterator_;
+    return objs_;
 }

pybind11/MooseVec.h

@@ -43,7 +43,8 @@ class MooseVec
 
     void setAttrOneToOne(const string& name, const py::sequence& val);
 
-    vector<py::object> getAttr(const string& name);
+    vector<py::object> getAttribute(const string& name);
+    py::array_t<double> getAttributeNumpy(const string& name);
 
     vector<ObjId> objs() const;
 
@@ -67,8 +68,7 @@ class MooseVec
     // >>> av = moose.vec(a)
     // will use dataIndex for indexing.
     // For FieldElementInfo, create objects.
-    vector<ObjId> iterator_;
-    bool useDataIndex_;
+    vector<ObjId> objs_;
 };
 
 #endif /* end of include guard: MOOSE_VEC_H */

pybind11/helper.h

@@ -42,7 +42,7 @@ bool mooseExists(const string& path);
 void mooseMoveId(const Id& a, const ObjId& b);
 void mooseMoveObjId(const ObjId& a, const ObjId& b);
 
-inline ObjId mooseObjIdPath(const string& p)
+inline MooseVec mooseObjIdPath(const string& p)
 {
     // handle relative path.
     string path(p);
@@ -51,19 +51,18 @@ inline ObjId mooseObjIdPath(const string& p)
     ObjId oid(path);
     if (oid.bad()) {
         cerr << "moose_element: " << path << " does not exist!" << endl;
-        return ObjId(Id());
     }
-    return oid;
+    return MooseVec(oid);
 }
 
-inline ObjId mooseObjIdObj(const ObjId& obj)
+inline MooseVec mooseObjIdObj(const ObjId& obj)
 {
-    return ObjId(obj.id, obj.dataIndex, obj.fieldIndex);
+    return MooseVec(obj);
 }
 
-inline ObjId mooseObjIdId(const Id& id)
+inline MooseVec mooseObjIdId(const Id& id)
 {
-    return ObjId(id);
+    return MooseVec(id);
 }
 
 inline ObjId mooseCreateFromPath(const string type, const string& p, unsigned int numdata)

pybind11/pymoose.cpp

@@ -145,6 +145,7 @@ py::object getFieldGeneric(const ObjId &oid, const string &fieldName)
     return pybind11::none();
 }
 
+
 /* --------------------------------------------------------------------------*/
 /**
  * @Synopsis  MOOSE extension module _moose.so.
@@ -316,7 +317,7 @@ PYBIND11_MODULE(_moose, m)
         .def("__getitem__", &MooseVec::getItem)
         .def("__setattr__", &MooseVec::setAttrOneToOne)
         .def("__setattr__", &MooseVec::setAttrOneToAll)
-        .def("__getattr__", &MooseVec::getAttr)
+        .def("__getattr__", &MooseVec::getAttributeNumpy)
         .def("__repr__", [](const MooseVec & v)->string {
              return "<moose.vec class=" + v.dtype() + " path=" + v.path() +
                     " id=" + std::to_string(v.id()) + " size=" +

pybind11/pymoose.h

@@ -21,23 +21,23 @@
 #include "MooseVec.h"
 
 template <typename T>
-void setField(const ObjId& id, const string& fname, T val)
+inline void setField(const ObjId& id, const string& fname, T val)
 {
     // cout << "Setting " << fname << " to value " << val << typeid(T).name() <<
     // endl;
     Field<T>::set(id, fname, val);
 }
 
 template <typename T>
-T getField(const ObjId& id, const string& fname)
+inline T getField(const ObjId& id, const string& fname)
 {
     return Field<T>::get(id, fname);
 }
 
 // FIXME: Is it most efficient?
 // See discussion here: https://github.com/pybind/pybind11/issues/1042
 template <typename T = double>
-py::array_t<T> getFieldNumpy(const ObjId& id, const string& fname)
+inline py::array_t<T> getFieldNumpy(const ObjId& id, const string& fname)
 {
     auto v = Field<vector<T>>::get(id, fname);
     return py::array_t<T>(v.size(), v.data());

shell/Shell.cpp

@@ -235,7 +235,7 @@ Id Shell::doCreate(string type, ObjId parent, string name, unsigned int numData,
     return Id();
 }
 
-ObjId Shell::doCreate2(string type, ObjId parent, string name,
+Id Shell::doCreate2(string type, ObjId parent, string name,
                        unsigned int numData)
 {
     // if (parent.bad()) {

shell/Shell.h

@@ -86,8 +86,9 @@ class Shell
                  NodePolicy nodePolicy = MooseBlockBalance,
                  unsigned int preferredNode = 1 );
 
-    // Python bindings.
-    ObjId doCreate2( string type, ObjId parent, string name, unsigned int numData);
+    // Same as before but with default nodePolicy and preferredNode. We are
+    // hidning them away from the python bindings.
+    Id doCreate2( string type, ObjId parent, string name, unsigned int numData);
 
     /**
      * Delete specified Element and all its children and all

tests/py_moose/test_api.py

@@ -3,7 +3,9 @@
 __maintainer__ = "Dilawar Singh"
 __email__      = "[email protected]"
 
+
 import moose
+import random
 import numpy as np
 
 
@@ -39,7 +41,9 @@ def test_vec():
     assert len(v) == 100, len(v)
     assert v == v.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()
 
 def test_finfos():
     s = moose.SimpleSynHandler('synh')
@@ -48,14 +52,11 @@ def test_finfos():
     assert s.numSynapses == 10
 
     syns = s.synapse.vec
-    print(syns)
     assert len(syns) == 10
     for i, s in enumerate(syns):
-        print(s, type(s))
         s.weight = 9.0
     for s in syns:
         assert s.weight == 9.0
-    print(syns.weight)
 
     # this is a shorthand for above for loop.
     syns.weight = 11.121
@@ -138,12 +139,11 @@ def main():
     test_children()
     test_finfos()
     test_other()
-    test_vec()
     test_delete()
     test_wrapper()
     test_inheritance()
     test_access()
-
+    test_vec()
 
 if __name__ == '__main__':
     main()