Finfo is also vectorised.

Author: Dilawar Singh

pybind11/Finfo.cpp

@@ -25,7 +25,7 @@ namespace py = pybind11;
 #include "Finfo.h"
 
 __Finfo__::__Finfo__(const ObjId& oid, const Finfo* f, const string& finfoType)
-    : oid_(oid), f_(f), finfoType_(finfoType)
+    : oid_(oid), f_(f), finfoType_(finfoType), pVec_(nullptr)
 {
     if(finfoType == "DestFinfo")
         func_ = [oid, f](const py::object& key) {
@@ -127,7 +127,7 @@ py::object __Finfo__::getItem(const py::object& key)
 
 py::object __Finfo__::operator()(const py::object& key)
 {
-    return func_(key);
+    return getItem(key);
 }
 
 py::cpp_function __Finfo__::getDestFinfoSetterFunc(const ObjId& oid,
@@ -311,3 +311,17 @@ ObjId __Finfo__::getObjId() const
 {
     return ObjId(oid_.path() + '/' + f_->name());
 }
+
+// Return by copy.
+MooseVec __Finfo__::getMooseVec()
+{
+    return MooseVec(getObjId());
+}
+
+MooseVec* __Finfo__::getMooseVecPtr()
+{
+    if(! pVec_)
+        pVec_.reset(new MooseVec(getObjId()));
+    return pVec_.get();
+}
+

pybind11/Finfo.h

@@ -10,6 +10,8 @@
 #ifndef FINFO_H
 #define FINFO_H
 
+class MooseVec;
+
 class __Finfo__ {
 public:
     __Finfo__(const ObjId& oid, const Finfo* f, const string& finfoType);
@@ -105,6 +107,12 @@ class __Finfo__ {
 
     string type() const;
 
+    // Return a MooseVec element (copy).
+    MooseVec getMooseVec();
+
+    // Retun by pointer.
+    MooseVec* getMooseVecPtr();
+
     // Finfo Id.
     static ObjId getObjIdStatic(const ObjId& oid, const Finfo* f);
     ObjId getObjId() const;
@@ -114,6 +122,9 @@ class __Finfo__ {
     const Finfo* f_;
     const std::string finfoType_;
     std::function<py::object(const py::object& key)> func_;
+
+    // __Finfo__ needs to be copiable.
+    shared_ptr<MooseVec> pVec_;
 };
 
 #endif /* end of include guard: FINFO_H */

pybind11/MooseVec.cpp

@@ -87,6 +87,28 @@ ObjId MooseVec::getItem(const int index) const
     return getDataItem(i);
 }
 
+vector<ObjId> MooseVec::getItemRange(const py::slice& slice) const
+{
+    vector<ObjId> res;
+    int start=0, step=1, stop = size();
+
+    py::object pstart = slice.attr("start");
+    if(! pstart.is(py::none()))
+        start = pstart.cast<int>();
+
+    py::object pstop = slice.attr("stop");
+    if(! pstop.is(py::none()))
+        stop = pstop.cast<int>();
+
+    py::object pstep = slice.attr("step");
+    if(! pstep.is(py::none()))
+        step = pstep.cast<int>();
+
+    for (int i = start; i < stop; i += step)
+        res.push_back(getItem(i));
+    return res;
+}
+
 ObjId MooseVec::getDataItem(const size_t i) const
 {
     return ObjId(oid_.path(), i, oid_.fieldIndex);

pybind11/MooseVec.h

@@ -45,6 +45,7 @@ class MooseVec
     // Get vector element. Vector element could be `dataIndex` or `fieldIndex`.
     // Allows negative indexing.
     ObjId getItem(const int i) const;
+    vector<ObjId> getItemRange(const py::slice& slice) const;
 
     ObjId getDataItem(const size_t i) const;
     ObjId getFieldItem(const size_t i) const;
@@ -140,6 +141,7 @@ class MooseVec
 
     // Get attributes.
     py::object getAttribute(const string& key);
+    bool setAttribute(const string& name, const py::object& val);
 
     vector<ObjId> objs() const;
 

pybind11/pymoose.cpp

@@ -135,19 +135,20 @@ py::object getFieldGeneric(const ObjId &oid, const string &fieldName)
 
     string finfoType = cinfo->getFinfoType(finfo);
 
-    // Either return a simple value (ValueFinfo), list, dict or DestFinfo
-    // setter.
-    // The DestFinfo setter is a function.
-
+    // Things are very compilcated here. There return object from this function
+    // can be of different types: a simple value (ValueFinfo), list, dict or 
+    // DestFinfo setter which is a function.
     if(finfoType == "ValueFinfo")
         return __Finfo__::getFieldValue(oid, finfo);
     else if(finfoType == "FieldElementFinfo") {
+        // This is a Finfo
         return py::cast(__Finfo__(oid, finfo, "FieldElementFinfo"));
     } else if(finfoType == "LookupValueFinfo") {
-        // Return function.
+        // This is a function.
         return py::cast(__Finfo__(oid, finfo, "LookupValueFinfo"));
     } else if(finfoType == "DestFinfo") {
-        // Return a setter function. It can be used to set field on DestFinfo.
+        // Return a setter function. 
+        // It can be used to set field on DestFinfo.
         return __Finfo__::getDestFinfoSetterFunc(oid, finfo);
     }
 
@@ -157,7 +158,6 @@ py::object getFieldGeneric(const ObjId &oid, const string &fieldName)
     return pybind11::none();
 }
 
-
 /* --------------------------------------------------------------------------*/
 /**
  * @Synopsis  MOOSE extension module _moose.so.
@@ -174,20 +174,14 @@ PYBIND11_MODULE(_moose, m)
 
     initModule(m);
 
-    py::object melement;
-
-    // A thin wrapper around Id from ../basecode/Id.h . Usually this is shows
-    // at moose.vec.
-    py::class_<Id>(m, "mid")
+    // A thin wrapper around Id from ../basecode/Id.h .
+    py::class_<Id>(m, "__id__")
         .def(py::init<>())
         .def(py::init<unsigned int>())
         .def(py::init<const string &>())
         .def(py::init<const ObjId &>())
         // properties
         .def_property_readonly("numIds", &Id::numIds)
-        // FIXME/NB: Don't expose path. Note that Stoich as `path` attribute
-        // which
-        // will not work if this is exposed.
         .def_property_readonly("path", &Id::path)
         .def_property_readonly(
              "name", [](const Id &id) { return id.element()->getName(); })
@@ -208,6 +202,8 @@ PYBIND11_MODULE(_moose, m)
         .def("__eq__", [](const Id &a, const Id &b) { return a == b; })
         .def("__ne__", [](const Id &a, const Id &b) { return a != b; })
         .def("__hash__", &Id::value)
+
+        // Id attributes are same as ObjItem attributes. 
         .def("__getattr__", [](const Id &id, const string &key) {
              return getFieldGeneric(ObjId(id), key);
          })
@@ -216,32 +212,32 @@ PYBIND11_MODULE(_moose, m)
              return setFieldGeneric(ObjId(id), key, val);
          });
 
-
     // This is a wrapper around Field::get  and LookupField::get which may
     // return simple values or vector. Python scripts expect LookupField to
     // return either list of dict which can be queried by key and index. This
     // class bind both __getitem__ to the getter function call.
     // Note that both a.isA["Compartment"] and a.isA("Compartment") are valid
     // now.
-    py::class_<__Finfo__>(m, "Field", py::dynamic_attr())
+    py::class_<__Finfo__>(m, "__Field__", py::dynamic_attr())
         .def(py::init<const ObjId &, const Finfo *, const char *>())
         .def_property_readonly("type", &__Finfo__::type)
-        .def_property_readonly("vec", [](const __Finfo__ &finfo) {
-             return MooseVec(finfo.getObjId());
-         })
-        .def_property("num", &__Finfo__::getNumField,
-                      &__Finfo__::setNumField)  // Only for FieldElementFinfos
-        .def("__call__", &__Finfo__::operator())
+        .def_property("num", &__Finfo__::getNumField, &__Finfo__::setNumField)
+        .def_property_readonly(
+             "vec", [](__Finfo__ &finfo) { return finfo.getMooseVecPtr(); },
+             py::return_value_policy::reference_internal)
+
+        // Only for FieldElementFinfos
+        .def("__len__", &__Finfo__::getNumField)
         .def("__call__", &__Finfo__::operator())
         .def("__getitem__", &__Finfo__::getItem)
         .def("__setitem__", &__Finfo__::setItem)
-        .def("__len__", &__Finfo__::getNumField);
+        ;
 
     /**
      * @name ObjId. It is a base of all other moose objects.
      * @{ */
     /**  @} */
-    py::class_<ObjId>(m, "ObjId", py::metaclass(melement))
+    py::class_<ObjId>(m, "melement")
         .def(py::init<>())
         .def(py::init<Id>())
         .def(py::init<Id, unsigned int>())
@@ -311,14 +307,15 @@ PYBIND11_MODULE(_moose, m)
     py::class_<Variable>(m, "_Variable").def(py::init<>());
 
     // Cinfo.
-    py::class_<Cinfo>(m, "_Cinfo")
+    py::class_<Cinfo>(m, "__Cinfo__")
         .def(py::init<>())
         .def_property_readonly("name", &Cinfo::name)
         .def_property_readonly("finfoMap", &Cinfo::finfoMap,
-                               py::return_value_policy::reference)
+                               py::return_value_policy::reference_internal)
         // .def("findFinfo", &Cinfo::findFinfoWrapper)
-        .def("baseCinfo", &Cinfo::baseCinfo, py::return_value_policy::reference)
-        .def("isA", &Cinfo::isA);
+        .def("baseCinfo", &Cinfo::baseCinfo,
+             py::return_value_policy::reference_internal)
+        .def("isA", &Cinfo::isA, py::return_value_policy::reference_internal);
 
     // Vec class.
     py::class_<MooseVec>(m, "vec")
@@ -338,9 +335,10 @@ PYBIND11_MODULE(_moose, m)
                  return py::make_iterator(v.objref().begin(), v.objref().end());
              },
              py::keep_alive<0, 1>())
+
         .def("__getitem__", &MooseVec::getItem)
-        // Beware of pybind11 overload resolution order:
-        // https://pybind11.readthedocs.io/en/stable/advanced/functions.html#overload-resolution-order
+        .def("__getitem__", &MooseVec::getItemRange)
+
         // Templated function won't work here. The first one is always called.
         .def("__getattr__", &MooseVec::getAttribute)
         .def("__setattr__", &MooseVec::setAttrOneToOne<double>)

python/moose/moose.py

@@ -19,7 +19,7 @@
 # etc.
 __class_types__ = {}
 
-class PyObjId(_moose.ObjId):
+class PyObjId(_moose.melement):
 
     __class__ = 'Unknown'
 

tests/py_moose/test_api.py

@@ -29,6 +29,7 @@ def test_children():
     assert ax1 == a11
     assert a11.isA['Neutral'], a11.isA
     assert ax1.isA['Neutral'], a11.isA
+    print("test_children is done")
 
 
 def test_other():
@@ -66,8 +67,7 @@ def test_finfos():
     assert s.numSynapses == 10
 
     syns = s.synapse.vec
-
-    print(s.synapse)
+    print(s.synapse, '111')
     s8a = s.synapse[8]
     s8b = s.synapse[-2]
     assert s8a == s8b, (s8a, s8b)

tests/py_moose/test_function_change_expr.py

@@ -0,0 +1,99 @@
+# -*- coding: utf-8 -*-
+#########################################################################
+## This program is part of 'MOOSE', the
+## Messaging Object Oriented Simulation Environment.
+##           Copyright (C) 2013 Upinder S. Bhalla. and NCBS
+## It is made available under the terms of the
+## GNU Lesser General Public License version 2.1
+## See the file COPYING.LIB for the full notice.
+#########################################################################
+
+import numpy
+import moose
+
+useY = False
+
+def makeModel():
+    # create container for model
+    moose.Neutral( 'model' )
+    compartment = moose.CubeMesh( '/model/compartment' )
+    compartment.volume = 1e-15
+    # the mesh is created automatically by the compartment
+    moose.element( '/model/compartment/mesh' ) 
+
+    # create molecules and reactions
+    # a <----> b
+    # b + 10c ---func---> d
+    a = moose.Pool( '/model/compartment/a' )
+    b = moose.Pool( '/model/compartment/b' )
+    c = moose.Pool( '/model/compartment/c' )
+    d = moose.BufPool( '/model/compartment/d' )
+    reac = moose.Reac( '/model/compartment/reac' )
+    func = moose.Function( '/model/compartment/d/func' )
+    func.numVars = 2
+    #func.x.num = 2
+
+    # connect them up for reactions
+
+    moose.connect( reac, 'sub', a, 'reac' )
+    moose.connect( reac, 'prd', b, 'reac' )
+    if useY:
+        moose.connect( func, 'requestOut', b, 'getN' )
+        moose.connect( func, 'requestOut', c, 'getN' )
+    else:
+        moose.connect( b, 'nOut', func.x[0], 'input' )
+        moose.connect( c, 'nOut', func.x[1], 'input' )
+
+    moose.connect( func, 'valueOut', d, 'setN' )
+    if useY:
+        func.expr = "y0 + 10*y1"
+    else:
+        func.expr = "x0 + 10*x1"
+
+    # connect them up to the compartment for volumes
+    #for x in ( a, b, c, cplx1, cplx2 ):
+    #                        moose.connect( x, 'mesh', mesh, 'mesh' )
+
+    # Assign parameters
+    a.concInit = 1
+    b.concInit = 0.5
+    c.concInit = 0.1
+    reac.Kf = 0.001
+    reac.Kb = 0.01
+
+    # Create the output tables
+    moose.Neutral( '/model/graphs' )
+    outputA = moose.Table2 ( '/model/graphs/concA' )
+    outputB = moose.Table2 ( '/model/graphs/concB' )
+    outputC = moose.Table2 ( '/model/graphs/concC' )
+    outputD = moose.Table2 ( '/model/graphs/concD' )
+
+    # connect up the tables
+    moose.connect( outputA, 'requestOut', a, 'getConc' );
+    moose.connect( outputB, 'requestOut', b, 'getConc' );
+    moose.connect( outputC, 'requestOut', c, 'getConc' );
+    moose.connect( outputD, 'requestOut', d, 'getConc' );
+
+def test_func_change_expr():
+    makeModel()
+    ksolve = moose.Ksolve( '/model/compartment/ksolve' )
+    stoich = moose.Stoich( '/model/compartment/stoich' )
+    stoich.compartment = moose.element( '/model/compartment' )
+    stoich.ksolve = ksolve
+    stoich.path = "/model/compartment/##"
+    moose.reinit()
+    moose.start( 100.0 )
+    func = moose.element( '/model/compartment/d/func' )
+    if useY:
+        func.expr = "-y0 + 10*y1"
+    else:
+        func.expr = "-x0 + 10*x1"
+    moose.start( 100.0 ) 
+    b = moose.element('/model/compartment/b')
+    assert int(b.n) == int(106384558.57472235), b.n
+    xs = func.x.vec
+    assert len(xs.value) == 2, (len(xs.value), xs.value)
+    assert (xs.value == [0, 0]).all(), xs.value
+
+if __name__ == '__main__':
+    test_func_change_expr()