Merge branch 'master' into master

pybind11/Finfo.cpp

@@ -182,6 +182,27 @@ py::cpp_function __Finfo__::getDestFinfoSetterFunc2(const ObjId& oid,
             return func;
         }
     }
+
+
+    if(ftype1 == "Id") {
+        if(ftype2 == "Id") {
+            std::function<bool(Id, Id)> func = [oid, fname](Id a, Id b) {
+                return SetGet2<Id, Id>::set(oid, fname, a, b);
+            };
+            return func;
+        }
+    }
+
+    if(ftype1 == "ObjId") {
+        if(ftype2 == "ObjId") {
+            std::function<bool(ObjId, ObjId)> func = [oid, fname](ObjId a,
+                                                                  ObjId b) {
+                return SetGet2<ObjId, ObjId>::set(oid, fname, a, b);
+            };
+            return func;
+        }
+    }
+
     throw runtime_error("getFieldPropertyDestFinfo2::NotImplemented " + fname +
                         " for rttType " + finfo->rttiType() + " for oid " +
                         oid.path());

pybind11/PyRun.cpp

@@ -143,7 +143,6 @@ PyRun::PyRun()
 PyRun::~PyRun()
 {
     Py_XDECREF(globals_);
-    Py_XDECREF(locals_);
 }
 
 void PyRun::setRunString(string statement)

pybind11/pymoose.cpp

@@ -281,11 +281,19 @@ PYBIND11_MODULE(_moose, m)
         .def_property_readonly("id", [](ObjId &oid) -> Id { return oid.id; })
         .def_property_readonly("dataIndex",
                                [](ObjId &oid) { return oid.dataIndex; })
+        .def("getDataIndex", [](const ObjId &oid) { return oid.dataIndex; })
+
         .def_property_readonly("fieldIndex",
                                [](ObjId &oid) { return oid.fieldIndex; })
+
+        .def("getFieldIndex", [](const ObjId &oid) { return oid.fieldIndex; })
+
         .def_property_readonly(
             "type", [](ObjId &oid) { return oid.element()->cinfo()->name(); })
 
+        .def("getType",
+             [](ObjId &oid) { return oid.element()->cinfo()->name(); })
+
         .def_property_readonly("path",
                                [](const ObjId &oid) { return oid.id.path(); })
 
@@ -335,14 +343,15 @@ PYBIND11_MODULE(_moose, m)
         .def("__ne__", [](const MooseVec &a,
                           const MooseVec &b) { return a.obj() != b.obj(); })
         .def("__len__", &MooseVec::len)
-        .def("__iter__",
-             [](MooseVec &v) {
-                 // Generate an iterator which is a vector<ObjId>. And then
-                 // pass the reference to the objects.
-                 v.generateIterator();
-                 return py::make_iterator(v.objref().begin(), v.objref().end());
-             },
-             py::keep_alive<0, 1>())
+        .def(
+            "__iter__",
+            [](MooseVec &v) {
+                // Generate an iterator which is a vector<ObjId>. And then
+                // pass the reference to the objects.
+                v.generateIterator();
+                return py::make_iterator(v.objref().begin(), v.objref().end());
+            },
+            py::keep_alive<0, 1>())
         .def("__getitem__", &MooseVec::getItem)
         .def("__getitem__", &MooseVec::getItemRange)
 
@@ -357,8 +366,9 @@ PYBIND11_MODULE(_moose, m)
              })
         // This is to provide old API support. Some scripts use .vec even on a
         // vec to get a vec. So silly or so Zen?!
-        .def_property_readonly("vec", [](const MooseVec &vec) { return &vec; },
-                               py::return_value_policy::reference_internal)
+        .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"; })
         .def("connect", &MooseVec::connectToSingle)
@@ -377,8 +387,9 @@ PYBIND11_MODULE(_moose, m)
      */
 
     m.def("seed", [](py::object &a) { moose::mtseed(a.cast<int>()); });
-    m.def("rand", [](double a, double b) { return moose::mtrand(a, b); },
-          "a"_a = 0, "b"_a = 1);
+    m.def(
+        "rand", [](double a, double b) { return moose::mtrand(a, b); },
+        "a"_a = 0, "b"_a = 1);
     // This is a wrapper to Shell::wildcardFind. The python interface must
     // override it.
     m.def("wildcardFind", &wildcardFind2);

python/moose/__init__.py

@@ -78,6 +78,7 @@ def version():
     """Reutrns moose version string."""
     return _moose.__version__
 
+__version__ = lambda: version()
 
 def version_info():
     """Return detailed version information.

python/rdesigneur/rdesigneur.py

@@ -687,56 +687,6 @@ def _parseComptField( self, comptList, plotSpec, knownFields ):
         else:
             return comptList, kf[1]
 
-    # Returns vector of source objects, and the field to use. 
-    # Specifically for _buildMoogli() as there the coordinates of the compartments are needed.
-    # plotSpec is of the form
-    #   [ region_wildcard, region_expr, path, field, title]
-    def _MoogparseComptField( self, comptList, plotSpec, knownFields ):
-        # Put in stuff to go through fields if the target is a chem object
-        field = plotSpec.field
-        if not field in knownFields:
-            print("Warning: Rdesigneur::_parseComptField: Unknown field '{}'".format( field ) )
-            return (), ""
-
-        kf = knownFields[field] # Find the field to decide type.
-        # if kf[0] in ['CaConcBase', 'ChanBase', 'NMDAChan', 'VClamp']:
-        #     objList = self._collapseElistToPathAndClass( comptList, plotSpec.relpath, kf[0] )
-        #     return objList, kf[1]
-        if field in [ 'n', 'conc', 'volume']:
-            path = plotSpec.relpath
-            pos = path.find( '/' )
-            if pos == -1:   # Assume it is in the dend compartment.
-                path  = 'dend/' + path
-            pos = path.find( '/' )
-            chemCompt = path[:pos]
-            if chemCompt[-5:] == "_endo":
-                chemCompt = chemCompt[0:-5]
-            cc = moose.element( self.modelPath + '/chem/' + chemCompt)
-            voxelVec = []
-            temp = [ self._makeUniqueNameStr( i ) for i in comptList ]
-            #print( temp )
-            #print( "#####################" )
-            comptSet = set( temp )
-            #em = [ moose.element(i) for i in cc.elecComptMap ]
-            em = sorted( [ self._makeUniqueNameStr(i[0]) for i in cc.elecComptMap ] )
-            #print( em )
-            #print( "=================================================" )
-
-            voxelVec = [i for i in range(len( em ) ) if em[i] in comptSet ]
-            # Here we collapse the voxelVec into objects to plot.
-            allObj = moose.vec( self.modelPath + '/chem/' + plotSpec.relpath )
-            #print "####### allObj=", self.modelPath + '/chem/' + plotSpec[2]
-            if len( allObj ) >= len( voxelVec ):
-                objList = [ allObj[int(j)] for j in voxelVec]
-            else:
-                objList = []
-                print( "Warning: Rdesigneur::_parseComptField: unknown Object: '", plotSpec.relpath, "'" )
-            #print "############", chemCompt, len(objList), kf[1]
-            return objList, kf[1]
-
-        else:
-            return comptList, kf[1]
-
 
     def _buildPlots( self ):
         knownFields = {