mfield.cpp File Reference

#include <Python.h>
#include <structmember.h>
#include <iostream>
#include <typeinfo>
#include <cstring>
#include <map>
#include <ctime>
#include "../basecode/header.h"
#include "../basecode/Id.h"
#include "../basecode/ObjId.h"
#include "../utility/utility.h"
#include "../shell/Shell.h"
#include "moosemodule.h"

Include dependency graph for mfield.cpp:

Go to the source code of this file.

Functions
PyObject *	moose_DestField_call (PyObject *self, PyObject *args, PyObject *kw)
PyObject *	moose_ElementField_getattro (_Field *self, PyObject *attr)
PyObject *	moose_ElementField_getDataId (_Field *self, void *closure)
PyObject *	moose_ElementField_getId (_Field *self, void *closure)
PyObject *	moose_ElementField_getItem (_Field *self, Py_ssize_t index)
Py_ssize_t	moose_ElementField_getLen (_Field *self, void *closure)
PyObject *	moose_ElementField_getName (_Field *self, void *closure)
PyObject *	moose_ElementField_getNum (_Field *self, void *closure)
PyObject *	moose_ElementField_getOwner (_Field *self, void *closure)
PyObject *	moose_ElementField_getPath (_Field *self, void *closure)
PyObject *	moose_ElementField_getSlice (_Field *self, Py_ssize_t start, Py_ssize_t end)
int	moose_ElementField_init (_Field *self, PyObject *args, PyObject *kwargs)
int	moose_ElementField_setattro (_Field *self, PyObject *attr, PyObject *value)
int	moose_ElementField_setNum (_Field *self, PyObject *args, void *closure)
void	moose_Field_dealloc (_Field *self)
long	moose_Field_hash (_Field *self)
	Return the hash of the string {objectpath}.{fieldName} More...
int	moose_Field_init (_Field *self, PyObject *args, PyObject *kwargs)
PyObject *	moose_Field_repr (_Field *self)
	String representation of fields is {objectpath}.{fieldName} More...
PyObject *	moose_LookupField_getItem (_Field *self, PyObject *key)
int	moose_LookupField_setItem (_Field *self, PyObject *key, PyObject *value)
	PyDoc_STRVAR (moose_Field_documentation,"Base class for MOOSE fields.\n""\n""Instances contain the field name and a pointer to the owner\n""object. Note on hash: the Field class is hashable but the hash is\n""constructed from the path of the container element and the field\n""name. Hence changing the name of the container element will cause the\n""hash to change. This is rather unusual in a moose script, but if you\n""are putting fields as dictionary keys, you should do that after names\n""of all elements have been finalized.\n""\n")
	PyDoc_STRVAR (moose_LookupField_documentation,"LookupField is dictionary-like fields that map keys to values.\n""The keys need not be fixed, as in case of interpolation tables,\n""keys can be any number and the corresponding value is dynamically\n""computed by the method of interpolation.\n""Use moose.doc('classname.fieldname') to display builtin\n""documentation for `field` in class `classname`.\n""\n")
	PyDoc_STRVAR (moose_DestField_documentation,"DestField is a method field, i.e. it can be called like a function.\n""Use moose.doc('classname.fieldname') to display builtin\n""documentation for `field` in class `classname`.\n")
	PyDoc_STRVAR (moose_ElementField_documentation,"ElementField represents fields that are themselves elements. For\n""example, synapse in an IntFire neuron. Element fields can be traversed\n""like a sequence. Additionally, you can set the number of entries by\n""setting the `num` attribute to a desired value.\n")
	PyDoc_STRVAR (moose_ElementField_num_documentation,"Number of entries in the field.")
	PyDoc_STRVAR (moose_ElementField_path_documentation,"Path of the field element.")
	PyDoc_STRVAR (moose_ElementField_name_documentation,"Name of the field element.")
	PyDoc_STRVAR (moose_ElementField_owner_documentation,"Reference to owner element of the field element.")
	PyDoc_STRVAR (moose_ElementField_id_documentation,"Id of the field element.")
	PyDoc_STRVAR (moose_ElementField_dataId_documentation,"dataIndex of the field element")

Variables
static char	dataIndex [] = "dataIndex"
static PyGetSetDef	ElementFieldGetSetters []
static PySequenceMethods	ElementFieldSequenceMethods
char	emptyString [] = ""
static char	id [] = "vec"
PyTypeObject	IdType
static PyMappingMethods	LookupFieldMappingMethods
PyTypeObject	moose_DestField
PyTypeObject	moose_ElementField
static PyTypeObject	moose_Field
PyTypeObject	moose_LookupField
static char	name [] = "name"
static char	numfield [] = "num"
PyTypeObject	ObjIdType
static char	owner [] = "owner"
static char	path [] = "path"

Function Documentation

PyObject* moose_DestField_call	(	PyObject *	self,
		PyObject *	args,
		PyObject *	kw
	)

Definition at line 296 of file mfield.cpp.

References moose_ObjId_setDestField(), name, and owner.

{
    // copy the name as the first argument into a new argument tuple.
    PyObject * newargs = PyTuple_New(PyTuple_Size(args)+1); // one extra for the field name
    PyObject * name = PyString_FromString(((_Field*)self)->name);
    if (name == NULL)
    {
        Py_DECREF(newargs);
        return NULL;
    }
    if (PyTuple_SetItem(newargs, 0, name) != 0)
    {
        Py_DECREF(newargs);
        // Py_DECREF(name);
        return NULL;
    }
    // copy the arguments in `args` into the new argument tuple
    Py_ssize_t argc =  PyTuple_Size(args);
    for (Py_ssize_t ii = 0; ii < argc; ++ii)
    {
        PyObject * arg = PyTuple_GetItem(args, ii);
        Py_INCREF(arg);
        PyTuple_SetItem(newargs, ii+1, arg);
        //Py_DECREF(arg);
    }
    // Call ObjId._setDestField with the new arguments
    PyObject * ret = moose_ObjId_setDestField(((_Field*)self)->owner, newargs);
    return ret;
}

Here is the call graph for this function:

PyObject* moose_ElementField_getattro	(	_Field *	self,
		PyObject *	attr
	)

Definition at line 685 of file mfield.cpp.

References Field< A >::get(), get_field_alias(), getFieldType(), Field< A >::getVec(), RAISE_INVALID_ID, shortType(), and to_pytuple().

{
    int new_attr = 0;
    PyObject * ret = NULL;
    if (self->owner->oid_.bad())
    {
        RAISE_INVALID_ID(NULL, "moose_ElementField_getSlice");
    }
    char * field = PyString_AsString(attr);
    string className = Field<string>::get(self->myoid, "className");
    string type = getFieldType(className, field);
    if (type.empty())
    {
        // Check if this field name is aliased and update fieldname and type if so.
        map<string, string>::const_iterator it = get_field_alias().find(string(field));
        if (it != get_field_alias().end())
        {
            field = const_cast<char*>((it->second).c_str());
            type = getFieldType(Field<string>::get(self->myoid, "className"), it->second);
            // Update attr for next level (PyObject_GenericGetAttr) in case.
            new_attr = 1;
            attr = PyString_FromString(field);
        }
    }
    if (type.empty())
    {
        ret = PyObject_GenericGetAttr((PyObject*)self, attr);
        if (new_attr)
        {
            Py_DECREF(attr);
            return ret;
        }
    }
    char ftype = shortType(type);
    switch (ftype)
    {
    case 'd':
    {
        vector < double > val;
        Field< double >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 's':
    {
        vector < string > val;
        Field< string >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'l':
    {
        vector < long > val;
        Field< long >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'x':
    {
        vector < Id > val;
        Field< Id >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'y':
    {
        vector < ObjId > val;
        Field< ObjId >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'i':
    {
        vector < int > val;
        Field< int >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'I':
    {
        vector < unsigned int > val;
        Field< unsigned int >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'k':
    {
        vector < unsigned long > val;
        Field< unsigned long >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'f':
    {
        vector < float > val;
        Field< float >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'b':
    {
        vector<bool> val;
        Field< bool >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'c':
    {
        vector < char > val;
        Field< char >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'h':
    {
        vector < short > val;
        Field< short >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'z':
    {
        PyErr_SetString(PyExc_NotImplementedError, "DataId handling not implemented yet.");
        break;
    }
    case 0:
    {
        ret = PyObject_GenericGetAttr((PyObject*)self, attr);
        break;
    }
    default:
        PyErr_SetString(PyExc_ValueError, "unhandled field type.");
        break;
    }
    if (new_attr)
    {
        Py_DECREF(attr);
    }
    return ret;
}

Here is the call graph for this function:

PyObject* moose_ElementField_getDataId	(	_Field *	self,
		void *	closure
	)

Definition at line 602 of file mfield.cpp.

References RAISE_INVALID_ID.

{
    if (self->owner->oid_.bad())
    {
        RAISE_INVALID_ID(NULL, "moose_ElementField_getItem");
    }
    return Py_BuildValue("I", self->owner->oid_.dataIndex);
}

PyObject* moose_ElementField_getId	(	_Field *	self,
		void *	closure
	)

Definition at line 581 of file mfield.cpp.

References IdType, and RAISE_INVALID_ID.

Referenced by moose_element().

{
    if (self->owner->oid_.bad())
    {
        RAISE_INVALID_ID(NULL, "moose_ElementField_setNum");
    }
    Id myId(self->owner->oid_.path() + "/" + string(self->name));
    _Id * new_id = PyObject_New(_Id, &IdType);
    new_id->id_ = myId;
    return (PyObject*)new_id;
}

Here is the caller graph for this function:

PyObject* moose_ElementField_getItem	(	_Field *	self,
		Py_ssize_t	index
	)

Definition at line 611 of file mfield.cpp.

References Field< A >::get(), oid_to_element(), and RAISE_INVALID_ID.

{
    if (self->owner->oid_.bad())
    {
        RAISE_INVALID_ID(NULL, "moose_ElementField_getItem");
    }
    int len = Field<unsigned int>::get(self->myoid, "numField");
    assert(len >= 0);
    if (index >= len)
    {
        PyErr_SetString(PyExc_IndexError, "moose.ElementField.getItem: index out of bounds.");
        return NULL;
    }
    if (index < 0)
    {
        index += len;
    }
    if (index < 0)
    {
        PyErr_SetString(PyExc_IndexError, "moose.ElementField.getItem: invalid index.");
        return NULL;
    }
    // _ObjId * oid = PyObject_New(_ObjId, &ObjIdType);
    // cout << "Element field: " << self->name << ", owner: " << self->owner->oid_.path() << endl;
    // stringstream path;
    // path << self->owner->oid_.path() << "/" << self->name << "[" << index << "]";
    // cout << "moose_ElementField_getItem:: path=" << path.str();
    // oid->oid_ = ObjId(self->myoid.id, self->myoid.dataIndex, index);
    // return (PyObject*)oid;
    ObjId oid(self->myoid.id, self->myoid.dataIndex, index);
    return oid_to_element(oid);
}

Here is the call graph for this function:

Py_ssize_t moose_ElementField_getLen	(	_Field *	self,
		void *	closure
	)

Definition at line 561 of file mfield.cpp.

References Field< A >::get(), and RAISE_INVALID_ID.

Referenced by moose_ElementField_setattro().

{
    if (self->owner->oid_.bad())
    {
        RAISE_INVALID_ID(-1, "moose_ElementField_getLen");
    }
    unsigned int num = Field<unsigned int>::get(self->myoid, "numField");
    return Py_ssize_t(num);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* moose_ElementField_getName	(	_Field *	self,
		void *	closure
	)

Definition at line 593 of file mfield.cpp.

{
    return Py_BuildValue("s", self->name);
}

PyObject* moose_ElementField_getNum	(	_Field *	self,
		void *	closure
	)

Definition at line 528 of file mfield.cpp.

References Field< A >::get(), and RAISE_INVALID_ID.

{
    if (self->owner->oid_.bad())
    {
        RAISE_INVALID_ID(NULL, "moose_ElementField_getNum");
    }
    string name = self->name;
    name[0] = std::toupper( name[0] );
    unsigned int num = Field<unsigned int>::get(self->myoid, "numField");
    return Py_BuildValue("I", num);
}

Here is the call graph for this function:

PyObject* moose_ElementField_getOwner	(	_Field *	self,
		void *	closure
	)

Definition at line 597 of file mfield.cpp.

{
    Py_INCREF(self->owner);
    return (PyObject*)self->owner;
}

PyObject* moose_ElementField_getPath	(	_Field *	self,
		void *	closure
	)

Definition at line 571 of file mfield.cpp.

References Id::isValid(), path, and RAISE_INVALID_ID.

{
    if (!Id::isValid(self->owner->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_ElementField_setNum");
    }
    string path = Id(self->owner->oid_.path() + "/" + string(self->name)).path();
    return Py_BuildValue("s", path.c_str());
}

Here is the call graph for this function:

PyObject* moose_ElementField_getSlice	(	_Field *	self,
		Py_ssize_t	start,
		Py_ssize_t	end
	)

Definition at line 644 of file mfield.cpp.

References Field< A >::get(), oid_to_element(), RAISE_INVALID_ID, and value.

{
    assert(start >= 0);
    assert(end >= 0);

    if (self->owner->oid_.bad())
    {
        RAISE_INVALID_ID(NULL, "moose_ElementField_getSlice");
    }
    Py_ssize_t len = Field<unsigned int>::get(self->myoid, "numField");
    while (start < 0)
    {
        start += len;
    }
    while (end < 0)
    {
        end += len;
    }
    if (start > end)
    {
        // PyErr_SetString(PyExc_IndexError, "Start index must be less than end.");
        // return NULL;
        // Python itself returns empty tuple in such cases, follow that
        return PyTuple_New(0);
    }
    PyObject * ret = PyTuple_New((Py_ssize_t)(end - start));
    for ( int ii = start; ii < end; ++ii)
    {
        ObjId oid(self->myoid.id, self->myoid.dataIndex, ii);
        PyObject * value = oid_to_element(oid);
        if (PyTuple_SetItem(ret, (Py_ssize_t)(ii-start), value))
        {
            Py_XDECREF(ret);
            // Py_XDECREF(value);
            PyErr_SetString(PyExc_RuntimeError, "Could not assign tuple entry.");
            return NULL;
        }
    }
    return ret;
}

Here is the call graph for this function:

int moose_ElementField_init	(	_Field *	self,
		PyObject *	args,
		PyObject *	kwargs
	)

Initialize field with ObjId and fieldName.

Definition at line 519 of file mfield.cpp.

References moose_Field_init().

{
    moose_Field_init(self, args, kwargs);
    string path = self->owner->oid_.path()+"/";
    path += string(self->name);
    self->myoid = ObjId(path);
    return 0;
}

Here is the call graph for this function:

int moose_ElementField_setattro	(	_Field *	self,
		PyObject *	attr,
		PyObject *	value
	)

Definition at line 826 of file mfield.cpp.

References Field< A >::get(), getFieldType(), Id::isValid(), moose_ElementField_getLen(), RAISE_INVALID_ID, Field< A >::setVec(), shortType(), and value.

{
    if (!Id::isValid(self->myoid))
    {
        RAISE_INVALID_ID(-1, "moose_ElementField_setattro");
    }
    int ret = -1;
    string field;
    if (PyString_Check(attr))
    {
        field = string(PyString_AsString(attr));
    }
    else
    {
        PyErr_SetString(PyExc_TypeError, "Attribute name must be a string");
        return -1;
    }
    string moose_class = Field<string>::get(self->myoid, "className");
    string fieldtype = getFieldType(moose_class, field);
    if (fieldtype.length() == 0)
    {
        if (field == "num")
        {
            return PyObject_GenericSetAttr((PyObject*)self, attr, value);
        }
        PyErr_SetString(PyExc_AttributeError, "cannot add new field to ElementField objects");
        return -1;
    }
    char ftype = shortType(fieldtype);
    Py_ssize_t length = moose_ElementField_getLen(self, NULL);
    bool is_seq = true;
    if (!PySequence_Check(value))
    {
        is_seq = false;
    }
    else if (length != PySequence_Length(value))
    {
        PyErr_SetString(PyExc_IndexError, "Length of the sequence on the right hand side does not match Id size.");
        return -1;
    }

    assert(length >= 0);
    switch(ftype)
    {
    case 'd':  //SET_VECFIELD(double, d)
    {
        vector<double> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                double v = PyFloat_AsDouble(PySequence_GetItem(value, ii));
                _value.push_back(v);
            }
        }
        else
        {
            double v = PyFloat_AsDouble(value);
            _value.assign(length, v);
        }
        ret = Field<double>::setVec(self->myoid, field, _value);
        break;
    }
    case 's':
    {
        vector<string> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                char * v = PyString_AsString(PySequence_GetItem(value, ii));
                _value.push_back(string(v));
            }
        }
        else
        {
            char * v = PyString_AsString(value);
            _value.assign(length, string(v));
        }
        ret = Field<string>::setVec(self->myoid, field, _value);
        break;
    }
    case 'i':
    {
        vector<int> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                int v = PyInt_AsLong(PySequence_GetItem(value, ii));
                _value.push_back(v);
            }
        }
        else
        {
            int v = PyInt_AsLong(value);
            _value.assign(length, v);
        }
        ret = Field< int >::setVec(self->myoid, field, _value);
        break;
    }
    case 'I':  //SET_VECFIELD(unsigned int, I)
    {
        vector<unsigned int> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                unsigned int v = PyInt_AsUnsignedLongMask(PySequence_GetItem(value, ii));
                _value.push_back(v);
            }
        }
        else
        {
            unsigned int v = PyInt_AsUnsignedLongMask(value);
            _value.assign(length, v);
        }
        ret = Field< unsigned int >::setVec(self->myoid, field, _value);
        break;
    }
    case 'l':  //SET_VECFIELD(long, l)
    {
        vector<long> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                long v = PyInt_AsLong(PySequence_GetItem(value, ii));
                _value.push_back(v);
            }
        }
        else
        {
            long v = PyInt_AsLong(value);
            _value.assign(length, v);
        }
        ret = Field<long>::setVec(self->myoid, field, _value);
        break;
    }
    case 'k':  //SET_VECFIELD(unsigned long, k)
    {
        vector<unsigned long> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                unsigned long v = PyInt_AsUnsignedLongMask(PySequence_GetItem(value, ii));
                _value.push_back(v);
            }
        }
        else
        {
            unsigned long v = PyInt_AsUnsignedLongMask(value);
            _value.assign(length, v);
        }
        ret = Field< unsigned long >::setVec(self->myoid, field, _value);
        break;
    }
    case 'b':
    {
        vector<bool> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * _v = PySequence_GetItem(value, ii);
                bool v = (Py_True ==_v) || (PyInt_AsLong(_v) != 0);
                _value.push_back(v);
            }
        }
        else
        {
            bool v = (Py_True ==value) || (PyInt_AsLong(value) != 0);
            _value.assign(length, v);
        }
        ret = Field< bool >::setVec(self->myoid, field, _value);
        break;
    }
    case 'c':
    {
        vector<char> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * _v = PySequence_GetItem(value, ii);
                char * v = PyString_AsString(_v);
                if (v && v[0])
                {
                    _value.push_back(v[0]);
                }
                else
                {
                    ostringstream err;
                    err << ii << "-th element is NUL";
                    PyErr_SetString(PyExc_ValueError, err.str().c_str());
                    return -1;
                }
            }
        }
        else
        {
            char * v = PyString_AsString(value);
            if (v && v[0])
            {
                _value.assign(length, v[0]);
            }
            else
            {
                PyErr_SetString(PyExc_ValueError,  "value is an empty string");
                return -1;
            }
        }
        ret = Field< char >::setVec(self->myoid, field, _value);
        break;
    }
    case 'h':
    {
        vector<short> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                short v = PyInt_AsLong(PySequence_GetItem(value, ii));
                _value.push_back(v);
            }
        }
        else
        {
            short v = PyInt_AsLong(value);
            _value.assign(length, v);
        }
        ret = Field< short >::setVec(self->myoid, field, _value);
        break;
    }
    case 'f':  //SET_VECFIELD(float, f)
    {
        vector<float> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                float v = PyFloat_AsDouble(PySequence_GetItem(value, ii));
                _value.push_back(v);
            }
        }
        else
        {
            float v = PyFloat_AsDouble(value);
            _value.assign(length, v);
        }
        ret = Field<float>::setVec(self->myoid, field, _value);
        break;
    }
    default:
        break;
    }
    // MOOSE Field::set returns 1 for success 0 for
    // failure. Python treats return value 0 from setters as
    // success, anything else failure.
    if (ret && (PyErr_Occurred() == NULL))
    {
        return 0;
    }
    else
    {
        return -1;
    }

}

Here is the call graph for this function:

int moose_ElementField_setNum	(	_Field *	self,
		PyObject *	args,
		void *	closure
	)

Definition at line 540 of file mfield.cpp.

References RAISE_INVALID_ID.

{
    if (self->owner->oid_.bad())
    {
        RAISE_INVALID_ID(-1, "moose_ElementField_setNum");
    }
    unsigned int num;
    if (!PyInt_Check(args))
    {
        PyErr_SetString(PyExc_TypeError, "moose.ElementField.setNum - needes an integer.");
        return -1;
    }
    num = PyInt_AsUnsignedLongMask(args);
    if (!Field<unsigned int>::set(self->myoid, "numField", num))
    {
        PyErr_SetString(PyExc_RuntimeError, "moose.ElementField.setNum : Field::set returned False.");
        return -1;
    }
    return 0;
}

void moose_Field_dealloc

(

_Field *

self

)

Definition at line 134 of file mfield.cpp.

{
    Py_DECREF(self->owner);
    Py_TYPE(self)->tp_free((PyObject*)self);
}

long moose_Field_hash

(

_Field *

self

)

Return the hash of the string {objectpath}.{fieldName}

Definition at line 142 of file mfield.cpp.

References Id::isValid(), path, and RAISE_INVALID_ID.

{
    if (!Id::isValid(self->owner->oid_.id))
    {
        RAISE_INVALID_ID(-1, "moose_Field_hash");
    }
    string fieldPath = self->owner->oid_.path() + "." + self->name;
    PyObject * path = PyString_FromString(fieldPath.c_str());
    long hash = PyObject_Hash(path);
    Py_XDECREF(path);
    return hash;
}

Here is the call graph for this function:

int moose_Field_init	(	_Field *	self,
		PyObject *	args,
		PyObject *	kwargs
	)

Initialize field with ObjId and fieldName.

Definition at line 89 of file mfield.cpp.

References Id::isValid(), ObjIdType, owner, and RAISE_INVALID_ID.

Referenced by moose_ElementField_init().

{
    PyObject * owner;
    char * fieldName;
    if (!PyArg_ParseTuple(args, "Os:moose_Field_init", &owner, &fieldName))
    {
        return -1;
    }
    if (fieldName == NULL)
    {
        PyErr_SetString(PyExc_ValueError, "fieldName cannot be NULL");
        return -1;
    }
    if (owner == NULL)
    {
        PyErr_SetString(PyExc_ValueError, "owner cannot be NULL");
        return -1;
    }
    if (!PyObject_IsInstance(owner, (PyObject*)&ObjIdType))
    {
        PyErr_SetString(PyExc_TypeError, "Owner must be subtype of ObjId");
        return -1;
    }
    if (!Id::isValid(((_ObjId*)owner)->oid_.id))
    {
        Py_DECREF(self);
        RAISE_INVALID_ID(-1, "moose_Field_init");
    }
    self->owner = ((_ObjId*)owner);
    Py_INCREF(self->owner);
    self->name = strdup(fieldName);
    if (!self->name) {
        PyErr_NoMemory();
        return -1;
    }

    // In earlier version I tried to deallocate the existing
    // self->name if it is not NULL. But it turns out that it
    // causes a SIGABRT. In any case it should not be an issue as
    // we can safely assume __init__ will be called only once in
    // this case. The Fields are created only internally at
    // initialization of the MOOSE module.
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* moose_Field_repr

(

_Field *

self

)

String representation of fields is {objectpath}.{fieldName}

Definition at line 156 of file mfield.cpp.

References Id::isValid(), and RAISE_INVALID_ID.

{
    if (!Id::isValid(self->owner->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_Field_repr");
    }
    ostringstream fieldPath;
    fieldPath << self->owner->oid_.path() << "." << self->name;
    return PyString_FromString(fieldPath.str().c_str());
}

Here is the call graph for this function:

PyObject* moose_LookupField_getItem	(	_Field *	self,
		PyObject *	key
	)

Definition at line 221 of file mfield.cpp.

References getLookupField().

{
    return getLookupField(self->owner->oid_, self->name, key);
}

Here is the call graph for this function:

int moose_LookupField_setItem	(	_Field *	self,
		PyObject *	key,
		PyObject *	value
	)

Definition at line 226 of file mfield.cpp.

References setLookupField().

{
    return setLookupField(self->owner->oid_,
                          self->name, key, value);
}

Here is the call graph for this function:

PyDoc_STRVAR	(	moose_Field_documentation	,
		"Base class for MOOSE fields.\n""\n""Instances contain the field name and a pointer to the owner\n""object. Note on hash: the Field class is hashable but the hash is\n""constructed from the path of the container element and the field\n""name. Hence changing the name of the container element will cause the\n""hash to change. This is rather unusual in a moose	script,
		but if you\n""are putting fields as dictionary	keys,
		you should do that after names\n""of all elements have been finalized.\n""\n"
	)

PyDoc_STRVAR	(	moose_LookupField_documentation	,
		"LookupField is dictionary-like fields that map keys to values.\n""The keys need not be	fixed,
		as in case of interpolation	tables,
		\n""keys can be any number and the corresponding value is dynamically\n""computed by the method of interpolation.\n""Use moose.doc('classname.fieldname') to display builtin\n""documentation for`field`in class`classname`.\n""\n"
	)

PyDoc_STRVAR	(	moose_DestField_documentation	,
		"DestField is a method	field,
		i.e.it can be called like a function.\n""Use moose.doc('classname.fieldname') to display builtin\n""documentation for`field`in class`classname`.\n"
	)

PyDoc_STRVAR	(	moose_ElementField_documentation	,
		"ElementField represents fields that are themselves elements. For\n""	example,
		synapse in an IntFire neuron.Element fields can be traversed\n""like a sequence.	Additionally,
		you can set the number of entries by\n""setting the`num`attribute to a desired value.\n"
	)

PyDoc_STRVAR	(	moose_ElementField_num_documentation	,
		"Number of entries in the field."
	)

PyDoc_STRVAR	(	moose_ElementField_path_documentation	,
		"Path of the field element."
	)

PyDoc_STRVAR	(	moose_ElementField_name_documentation	,
		"Name of the field element."
	)

PyDoc_STRVAR	(	moose_ElementField_owner_documentation	,
		"Reference to owner element of the field element."
	)

PyDoc_STRVAR	(	moose_ElementField_id_documentation	,
		"Id of the field element."
	)

PyDoc_STRVAR	(	moose_ElementField_dataId_documentation	,
		"dataIndex of the field element"
	)

Variable Documentation

char dataIndex[] = "dataIndex"

static

Definition at line 406 of file mfield.cpp.

Referenced by matchInsideBrace(), moose_ObjId_hash(), HopFunc2< A1, A2 >::opVec(), MsgElement::rawIndex(), and testSendMsg().

PyGetSetDef ElementFieldGetSetters[]

static

Definition at line 408 of file mfield.cpp.

PySequenceMethods ElementFieldSequenceMethods

static

Initial value:

=
{
    (lenfunc)moose_ElementField_getLen, 
    0, 
    0, 
    (ssizeargfunc)moose_ElementField_getItem, 

    (ssizessizeargfunc)moose_ElementField_getSlice, 

    0, 

    0, 

    0, 
    0, 
    0 
}

Definition at line 455 of file mfield.cpp.

char emptyString[] = ""

Definition at line 407 of file mfield.cpp.

char id[] = "vec"

static

Definition at line 404 of file mfield.cpp.

Referenced by Neutral::initCinfo(), TestId::initCinfo(), Id::isValid(), moose_element(), ReadCell::ReadCell(), TgtInfo::set(), Dsolve::setCompartment(), DiffPoolVec::setId(), TestId::setId(), Dsolve::setStoich(), testSparseMsg(), and to_py().

PyTypeObject IdType

Definition at line 262 of file vec.cpp.

Referenced by moose_ElementField_getId().

PyMappingMethods LookupFieldMappingMethods

static

Initial value:

=
{
    0,
    (binaryfunc)moose_LookupField_getItem,
    (objobjargproc)moose_LookupField_setItem,
}

The mapping methods make it act like a Python dictionary.

Definition at line 236 of file mfield.cpp.

PyTypeObject moose_DestField

Definition at line 333 of file mfield.cpp.

Referenced by MODINIT(), and moose_ObjId_get_destField_attr().

PyTypeObject moose_ElementField

Definition at line 473 of file mfield.cpp.

Referenced by MODINIT(), and moose_ObjId_get_elementField_attr().

PyTypeObject moose_Field

static

Definition at line 178 of file mfield.cpp.

PyTypeObject moose_LookupField

Definition at line 252 of file mfield.cpp.

Referenced by MODINIT(), and moose_ObjId_get_lookupField_attr().

char name[] = "name"

static

Definition at line 401 of file mfield.cpp.

Referenced by ReadCell::addChannelMessage(), Cell::addMethod(), ReadKkit::assignPoolCompartments(), checkForSpine(), Neutral::child(), create_Id_from_path(), defineDestFinfos(), defineElementFinfos(), defineLookupFinfos(), Shell::doCreate(), Shell::doMove(), ReadCspace::expandEnzyme(), NeuroNode::filterSpines(), NeuroNode::findStartNode(), get_Id_attr(), Msg::getDestFieldsOnE1(), Msg::getDestFieldsOnE2(), Element::getMsgTargetAndFunctions(), Msg::getSrcFieldsOnE1(), Msg::getSrcFieldsOnE2(), Neutral::initCinfo(), isNamedPlot(), isPartOfDend(), makeCompt(), moose_copy(), moose_DestField_call(), moose_ObjId_get_destField_attr(), moose_ObjId_get_elementField_attr(), moose_ObjId_get_lookupField_attr(), ReadCspace::printFooter(), NeuroMesh::putSomaAtStart(), ReadCell::ReadCell(), ReadCell::readData(), Conv< T >::rttiType(), PyRun::setInputVar(), Neutral::setName(), Function::setNumVar(), PyRun::setOutputVar(), Element::showFields(), testCellDiffn(), testFinfoFields(), testMsgSrcDestFields(), testSmallCellDiffn(), and testWildcard().

char numfield[] = "num"

static

Definition at line 402 of file mfield.cpp.

PyTypeObject ObjIdType

Referenced by moose_Field_init().

char owner[] = "owner"

static

Definition at line 405 of file mfield.cpp.

Referenced by moose_DestField_call(), and moose_Field_init().

char path[] = "path"

static

Definition at line 403 of file mfield.cpp.

Referenced by Neuron::buildElist(), Shell::chopString(), moose::createMOOSEPath(), moose::createParentDirs(), doClassSpecificMessaging(), findModelParent(), moose::fixPath(), Neuron::getExprElist(), Neuron::getExprVal(), Neuron::getSpinesFromExpression(), Dsolve::initCinfo(), Stoich::initCinfo(), moose_element(), moose_ElementField_getPath(), moose_exists(), moose_Field_hash(), moose_Id_getPath(), moose_Id_init(), moose_ObjId_init_from_path(), moose_setCwe(), moose_useClock(), Streamer::reinit(), HSolve::setPath(), NeuroMesh::setSubTreePath(), testCopy(), testFindModelParent(), testMove(), testMsgElementListing(), testObjIdToAndFromPath(), ReadCspace::testReadModel(), testTreeTraversal(), moose::toFilename(), writeEnz(), writeGroup(), writeKkit(), and writePlot().