# MOOSE Functions¶

## element¶

moose.element(arg) -> moose object

Convert a path or an object to the appropriate builtin moose class instance.

arg : str/vec/moose object
path of the moose element to be converted or another element (possibly available as a superclass instance).
Returns - melement
MOOSE element (object) corresponding to the arg converted to write subclass.

## getFieldNames¶

moose.getFieldNames(className, finfoType='valueFinfo') -> tuple

Get a tuple containing the name of all the fields of finfoType kind.

className : string
Name of the class to look up.
finfoType : string
The kind of field - valueFinfo - srcFinfo - destFinfo - lookupFinfo- fieldElementFinfo -
Returns - tuple
Names of the fields of type finfoType in class className.

## copy¶

moose.copy(src, dest, name, n, toGlobal, copyExtMsg) -> bool

Make copies of a moose object.

src : vec, element or str
source object.
dest : vec, element or str
Destination object to copy into.
name : str
Name of the new object. If omitted, name of the original will be used.
n : int
Number of copies to make.
toGlobal : int
Relevant for parallel environments only. If false, the copies will reside on local node, otherwise all nodes get the copies.
copyExtMsg : int
If true, messages to/from external objects are also copied.
Returns - vec
newly copied vec

## move¶

moose.move(...)
Move a vec object to a destination.

## delete¶

moose.delete(...)
delete(obj)->None

Delete the underlying moose object. This does not delete any of the Python objects referring to this vec but does invalidate them. Any attempt to access them will raise a ValueError.

id : vec
vec of the object to be deleted.

Returns - None

## useClock¶

moose.useClock(tick, path, fn)

schedule fn function of every object that matches path on tick no. tick.

Most commonly the function is 'process'. NOTE: unlike earlier versions, now autoschedule is not available. You have to call useClock for every element that should be updated during the simulation.

The sequence of clockticks with the same dt is according to their number. This is utilized for controlling the order of updates in various objects where it matters. The following convention should be observed when assigning clockticks to various components of a model:

Clock ticks 0-3 are for electrical (biophysical) components, 4 and 5 are for chemical kinetics, 6 and 7 are for lookup tables and stimulus, 8 and 9 are for recording tables.

Generally, process is the method to be assigned a clock tick. Notable exception is init method of Compartment class which is assigned tick 0.

• 0 : Compartment: init
• 1 : Compartment: process
• 2 : HHChannel and other channels: process
• 3 : CaConc : process
• 4,5 : Elements for chemical kinetics : process
• 6,7 : Lookup (tables), stimulus : process
• 8,9 : Tables for plotting : process
tick : int
tick number on which the targets should be scheduled.
path : str
path of the target element(s). This can be a wildcard also.
fn : str
name of the function to be called on each tick. Commonly process.

Examples -

In multi-compartmental neuron model a compartment's membrane potential (Vm) is dependent on its neighbours' membrane potential. Thus it must get the neighbour's present Vm before computing its own Vm in next time step. This ordering is achieved by scheduling the init function, which communicates membrane potential, on tick 0 and process function on tick 1.:

>>> moose.useClock(0, '/model/compartment_1', 'init')
>>> moose.useClock(1, '/model/compartment_1', 'process')


## setClock¶

moose.setClock(tick, dt)

set the ticking interval of tick to dt.

A tick with interval dt will call the functions scheduled on that tick every dt timestep.

tick : int
tick number
dt : double
ticking interval

## start¶

moose.start(time, notify = False) -> None

Run simulation for t time. Advances the simulator clock by t time. If 'notify = True', a message is written to terminal whenever 10% of simulation time is over.

After setting up a simulation, YOU MUST CALL MOOSE.REINIT() before CALLING MOOSE.START() TO EXECUTE THE SIMULATION. Otherwise, the simulator behaviour will be undefined. Once moose.reinit() has been called, you can call moose.start(t) as many time as you like. This will continue the simulation from the last state for t time.

t : float
duration of simulation.
notify : bool
default False. If True, notify user whenever 10% of simultion is over.

Returns - None

## reinit¶

moose.reinit() -> None

Reinitialize simulation.

This function (re)initializes moose simulation. It must be called before you start the simulation (see moose.start). If you want to continue simulation after you have called moose.reinit() and moose.start(), you must NOT call moose.reinit() again. Calling moose.reinit() again will take the system back to initial setting (like clear out all data recording tables, set state variables to their initial values, etc.

moose.stop(...)
Stop simulation

## isRunning¶

moose.isRunning(...)
True if the simulation is currently running.

## exists¶

moose.exists(...)
True if there is an object with specified path.

Load model from a file to a specified path.

filename : str
model description file.
modelpath : str
moose path for the top level element of the model to be created.
solverclass : str, optional
solver type to be used for simulating the model.
Returns - vec

## connect¶

moose.connect(src, srcfield, destobj, destfield[,msgtype]) -> bool

Create a message between src_field on src object to dest_field on dest object. This function is used mainly, to say, connect two entities, and to denote what kind of give-and-take relationship they share.It enables the 'destfield' (of the 'destobj') to acquire the data, from 'srcfield'(of the 'src').
src : element/vec/string
the source object (or its path) (the one that provides information)
srcfield : str
source field on self.(type of the information)
destobj : element
Destination object to connect to. (The one that need to get information)
destfield : str
field to connect to on destobj.
msgtype : str
type of the message. Can be Single - OneToAll - AllToOne - OneToOne - Reduce - Sparse - Default: Single.
Returns - msgmanager : melement
message-manager for the newly created message.

Examples - Connect the output of a pulse generator to the input of a spike generator:

>>> pulsegen = moose.PulseGen('pulsegen')
>>> spikegen = moose.SpikeGen('spikegen')
>>> pulsegen.connect('output', spikegen, 'Vm')


## getCwe¶

moose.getCwe(...)
Get the current working element. 'pwe' is an alias of this function.

## setCwe¶

moose.setCwe(...)
Set the current working element. 'ce' is an alias of this function

## getFieldDict¶

moose.getFieldDict(className, finfoType) -> dict

Get dictionary of field names and types for specified class.
className : str
MOOSE class to find the fields of.
finfoType : str (optional)
Finfo type of the fields to find. If empty or not specified, all fields will be retrieved.
Returns - dict
field names and their types.
Notes -
This behaviour is different from getFieldNames where only valueFinfos are returned when finfoType remains unspecified.
Examples -

List all the source fields on class Neutral:

>>> moose.getFieldDict('Neutral', 'srcFinfo')
>>> {'childMsg': 'int'}


## getField¶

moose.getField(...)
getField(element, field, fieldtype) -- Get specified field of specified type from object vec.

## seed¶

moose.seed(...)

moose.seed(seedvalue) -> seed

Reseed MOOSE random number generator.

seed : int

Value to use for seeding. All RNGs in moose except rand functions in moose.Function expression use this seed. By default (when this function is not called) seed is initializecd to some random value using system random device (if available).

default: random number generated using system random device

Returns - None

## rand¶

moose.rand(...)

moose.rand() -> [0,1)

Returns - float in [0, 1) real interval generated by MT19937.

Notes - MOOSE does not automatically seed the random number generator. You must explicitly call moose.seed() to create a new sequence of random numbers each time.

## wildcardFind¶

moose.wildcardFind(expression) -> tuple of melements.

Find an object by wildcard.
expression : str

MOOSE allows wildcard expressions of the form:

{PATH}/{WILDCARD}[{CONDITION}]


where {PATH} is valid path in the element tree. {WILDCARD} can be # or ##.

# causes the search to be restricted to the children of the element specified by {PATH}.

## makes the search to recursively go through all the descendants of the {PATH} element. {CONDITION} can be:

TYPE={CLASSNAME} : an element satisfies this condition if it is of
class {CLASSNAME}.
ISA={CLASSNAME} : alias for TYPE={CLASSNAME}
CLASS={CLASSNAME} : alias for TYPE={CLASSNAME}
FIELD({FIELDNAME}){OPERATOR}{VALUE} : compare field {FIELDNAME} with
{VALUE} by {OPERATOR} where {OPERATOR} is a comparison operator (=,
!=, >, <, >=, <=).


For example, /mymodel/##[FIELD(Vm)>=-65] will return a list of all the objects under /mymodel whose Vm field is >= -65.

Returns - tuple
all elements that match the wildcard.

## quit¶

Finalize MOOSE threads and quit MOOSE. This is made available for debugging purpose only. It will automatically get called when moose module is unloaded. End user should not use this function.
moose.quit(...)
Finalize MOOSE threads and quit MOOSE. This is made available for debugging purpose only. It will automatically get called when moose module is unloaded. End user should not use this function.