forked from BhallaLab/moose-core
-
Notifications
You must be signed in to change notification settings - Fork 0
/
README
237 lines (164 loc) · 8.01 KB
/
README
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
# MOOSE
MOOSE is the Multiscale Object-Oriented Simulation Environment. It is designed
to simulate neural systems ranging from subcellular components and biochemical
reactions to complex models of single neurons, circuits, and large networks.
MOOSE can operate at many levels of detail, from stochastic chemical
computations, to multicompartment single-neuron models, to spiking neuron
network models.
MOOSE is multiscale: It can do all these calculations together. For example
it handles interactions seamlessly between electrical and chemical signaling.
MOOSE is object-oriented. Biological concepts are mapped into classes, and
a model is built by creating instances of these classes and connecting them
by messages. MOOSE also has classes whose job is to take over difficult
computations in a certain domain, and do them fast. There are such solver
classes for stochastic and deterministic chemistry, for diffusion, and for
multicompartment neuronal models.
MOOSE is a simulation environment, not just a numerical engine: It provides
data representations and solvers (of course!), but also a scripting interface
with Python, graphical displays with Matplotlib, PyQt, and OpenGL, and
support for many model formats. These include SBML, NeuroML, GENESIS kkit
and cell.p formats, HDF5 and NSDF for data writing.
# VERSION
This is MOOSE 3.0.1 "Gulab Jamun"
# ABOUT VERSION 3.0.1, Gulab Jamun
The Gulab Jamun release is the second of series 3 of MOOSE releases.
Gulab Juman is a classic North Indian sweet consisting of deep brown spheres
involving milk solids, cardamom and other spices, floating in a rich syrup.
MOOSE 3.0.1 is an evolutionary increment over 3.0.0::
- The GUI moves into beta with substantially more kinetic
modeling features, as well as an early release of the neuronal
modeling interface in the GUI.
- Multiscale modeling updates including better cross-compartment
reactions, including stochasticity.
- General robustness and error reporting improvements for solvers.
- HSolver updates to handle NMDA and other channels with Ca currents.
# LICENSE
MOOSE is released under GPLv3.
# HOMEPAGE
http://moose.ncbs.res.in/
# SOURCE REPOSITORY
https://sourceforge.net/projects/moose/
# REQUIREMENTS
## Core MOOSE
- g++ (>= 4.6.x) REQUIRED
--------------
For building the C++ MOOSE core.
- GSL (1.16.x) OPTIONAL
----------------
For core moose numerical computation
- OpenMPI (1.8.x) OPTIONAL
---------------
For running moose in parallel on clusters
## PyMOOSE REQUIRED except on cluster worker nodes
Python interface for core MOOSE API
- Python2 ( >= 2.7.x) REQUIRED
-------------------------
For building the MOOSE Python bindings
- Python-dev ( >= 2.7.x) REQUIRED
-------------------------
Python development headers and libraries
- NumPy ( >= 1.6.x) REQUIRED
-------------------------
For numerical computation in PyMOOSE
- H5py (2.3.x) REQUIRED
---------------------
For reading and writing data to HDF5 files
### Chemical Kinetics Network Simulations OPTIONAL
- GSL (1.16.x) REQUIRED
----------------
For core moose numerical computation
- PyQt4 (4.8.x) REQUIRED
---------------------
For Python GUI
- Matplotlib ( >= 1.1.x) REQUIRED
-------------------------
For plotting simulation results
- SBML (5.9.x) OPTIONAL
---------------------
For reading and writing signalling models to SBML files
### Compartmental Model Visualization OPTIONAL
- GSL (1.16.x) REQUIRED
----------------
For core moose numerical computation
- OSG (3.2.x) REQUIRED
---------------------
For 3D rendering and simulation of neuronal models
- Qt4 (4.8.x) REQUIRED
---------------------
For C++ GUI of Moogli
- PyQt4 (4.8.x) REQUIRED
---------------------
For Python GUI
- Matplotlib ( >= 1.1.x) REQUIRED
-------------------------
For plotting simulation results
# AUTHORS
- Upinder S. Bhalla - Primary Architect, Chemical kinetic solvers
- Niraj Dudani - Neuronal solver
- Subhasis Ray - PyMOOSE Design and Documentation, Python Plugin Interface, NSDF Format
- G.V.HarshaRani - Web page design, SBML support, Kinetikit Plugin Development
- Aditya Gilra - NeuroML reader development, integrate-and-fire neurons/networks, STDP
- Aviral Goel - Moogli/Neurokit Development
- Dilawar Singh - Packaging
# Support:
You can join the MOOSE generic mailing list for your queries -
https://lists.sourceforge.net/lists/listinfo/moose-generic
# Bugs:
You can file bug reports and feature requets at the sourceforge tracker -
http://sourceforge.net/p/moose/bugs/
# Getting started:
# Running MOOSE: the short short guide.
Moose is usually run within Python. Here is a template Python script that will
load and run various kinds of predefined model files:
>>> import moose
>>> help( moose ) # See what you can do with MOOSE.
>>> moose.loadModel( file_path, modelname ) # Load in your model
>>> moose.reinit() # Set initial conditions
>>> moose.start( runtime ) # Run the model
Using Matplotlib and a few more lines, one can plot the output of this
simulation, which will have been been stored in tables somewhere in the model:
>>> import pylab
>>> import numpy
>>> for x in moose.wildcardFind( '/modelname/##[ISA=Table]' ):
>>> t = numpy.arange( 0, x.vector.size, 1, ) * dt
>>> pylab.plot( t, x.vector, label = x.name )
>>> pylab.legend()
>>> pylab.show()
# Examples, tutorials and Demos:
Look in the Demos directory for sample code.
Demos/tutorials: Standalone scripts meant for teaching. Students are expected
to modify the scripts to learn the principles of the models.
Demos/squid: The Hodkin-Huxley squid model, fully graphical interface.
Demos/Genesis_files: A number of kinetics models used in MOOSE demos.
Demos/neuroml: A number of NeuroML models used in MOOSE demos
Demos/traub_2005: Example scripts for each of the individual cell models from
the Traub 2005 thalamocortical model.
Demos/snippets: Code snippets that can be used as building blocks and to
illustrate how to use certain kinds of objects in MOOSE. These
snippets are all meant to run as individual files.
# Supported file formats.
MOOSE comes with a NeuroML reader. Demos/neuroml has some
python scripts showing how to load NeuroML models.
MOOSE is backward compatible with GENESIS kinetikit.
Demos/Genesis_files has some examples. You can load a
kinetikit model with the loadModel function:
moose.loadModel(kkit_file_path, modelname )
MOOSE is backward compatible with GENESIS <model>.p files used for neuronal
model specification. The same loadModel
function can be used for this but you need to have all the channels
used in the .p file preloaded in /library:
moose.loadModel(prototype_file_path, modelname )
# Documentation
Top level moose documentation can be accessed in the Python
interpreter the usual way:
import moose
help(moose)
MOOSE classes have built-in documentation that can be accessed via
the `doc()` function -
moose.doc(classname)
This will give the full documentation for the class including the fields
available.
`moose.doc(classname.fieldname)`
will give you information about a particular field in a class.
Complete MOOSE Documentation can be found at -
http://moose.ncbs.res.in/content/view/5/6/