Using NeuroML with Neosim

How to use NeuroML to parameter Neosim

This page describes how to use NeuroML ot parameter a Neosim simulation.
For more informations about NeuroML, please consult the NeuroML web site.
The best is to use the sample file as a template.
The steps to describe a simulation are :

defining the entities
defining the network
- the populations
- the projections
defining the source and destination methods
defining the simulation's controls
defining the external modules used

Defining the entities


<neuroml class="NeuromlPkg" description="" author="tutorial master" keywords="tutorial spike neuron model">
   <models>
      <model name="our_cells" class="CellPkg">
         <solutions>
         </solutions>
         <sectionProperties>
         </sectionProperties>
         <neurons>
            <neuron name="SpikeNeuron" class="ModuleNeuron">
              <module module="SpikeNeuronjar">
		 <parameters class="tutorial.neuron.SpikeNeuronFactory" 
                     threshold="0.0"
		     excitation="20.0" 
                     inhibition ="-10.0"/>
	      </module>
            </neuron>
         </neurons>
         <structures>
         </structures>
      </model>
   </models>
</neuroml>

name : name of the entity in the list. This name will be the one to which populations refer
class : NeuroML provides different templates to define neurons. the one we use here is "ModuleNeuron" which defines simple neurons using external code module with specific parameters
module : this is the link to the module code. It should refer to a module name in the module list
parameters : the tag <parameters> defines a list of custom parameters the user can freely specify. Those parameters will be given to the module coding the entity, so they must reflect the actual entity parameters.

Defining the network


<neuroml class="NeuromlPkg" description="four neurons producing walking pattern" author="tutorial master"
	  keywords="tutorial spike neuron model">
   <models>
      <model name="the_networks" class="NetworkPkg">
         <networks>
            <network name="our_network">
               <elements>
               </elements>
               <projections>
               </projections>
            </network>
         </networks>
      </model>
   </models>
</neuroml>

The tag <networks> is a list of networks, each network being described by a <network> tag.
In the current model we define only one network. The attributes of a network are :

elements : a list of elements (populations or entities)
projections : a list of projections

Defining a network is then defining its populations and projections :

defining the populations
defining the projections

Defining the populations


<neuroml class="NeuromlPkg" description="four neurons producing walking pattern" author="tutorial master" keywords="tutorial spike neuron model">
   <models>
      <model name="the_networks" class="NetworkPkg">
         <networks>
            <network name="our_network">
               <elements>

                  <element name="SpikeNeurons" elementClass="SpikeNeuron">
                     <structure class="Grid1DStructure" size="4"/>
                  </element>

                <element name="SpikeNeurons3D" elementClass="SpikeNeuron">
                     <structure class="Grid3DStructure" xsize="5" ysize="5" zsize="2"/>
                  </element>

               </elements>
               <projections>
               </projections>
            </network>
         </networks>
      </model>
   </models>
</neuroml>

The list of elements can contain as many populations as wanted. The attributes of a population are :

name : name of the population, to which the projections will refer
elementClass : reference to the element's name
structure : the structure of a population

The structure of a population can be of many kind according to the needs.
Here are shown two different kinds of structures used in the current model : the first one, a Grid1DStructure just specifies its number of elements without any spatial constraints, whereas the second one is a Grid3Dstructure able to emulate a three dimensional array.

The attributes of the Grid1DStructure structure are :

class : the class of the structure
size : the number of elements

The attributes of the Grid3DStructure structure are :

class : the class of the structure
xsize,ysize,zsize : the number of elements per dimension

Defining the projections


<neuroml class="NeuromlPkg" description="four neurons producing walking pattern" author="tutorial master" keywords="tutorial spike neuron model">
   <models>
      <model name="the_networks" class="NetworkPkg">
         <networks>
            <network name="our_network">
               <elements>
               </elements>
               <projections>

                  <projection name="fromGen" class="RawProjection" source="SpikeGens" dest="SpikeNeurons">
                    <connections>
		      <connection name="unique" sourceIndex="0" destIndex="0" 
		                  sourcePort="out" destPort="in" delay="2.0ms" weight="1.0" />
		    </connections>
                  </projection>

                  <projection name="betweenNeurons"
		     class="ModuleProjection" source="SpikeNeurons" dest="SpikeNeurons">
                     <sourceMethod module="modules.toNextSrc">
                        <parameters class="tutorial.sourcemethod.SpikeSourceMethod" srcPort="out"/>
                     </sourceMethod>
                     <destMethod module="modules.toNextDest">
                        <parameters class="tutorial.destmethod.SpikeDestMethod" dstPort="in" delay="2.0"/>
                     </destMethod>
                  </projection>

               </projections>
            </network>
         </networks>
      </model>
   </models>
</neuroml>

The projections to be defined are also part of a list, called projections.
Here we show two different kind of projections : RawProjection and ModuleProjection.

The Raw projection is a class of projection allowing us to explicitly define each connection, one by one.

The attributes of the Raw projection are :

name : name of the projection
class : class of the projection, for instance : RawProjection
source : reference to the source population name
dest : reference to the destination population name
connections : the explicit list of connections

The connections are then defined by the connection tag.
The default connection class has the following attributes :

name : name of the connection
sourceIndex : index of the source population element
destIndex : index of the destination element
sourcePort : source port name, usually "out"
destPort : destination port name, usually "in"
delay : delay of the connection
weight : weight of the connection

As most of the time, it would be too costly to explicitely define each connections, we introduce here the ModuleProjection, which uses external code modules (in .jar files) to define the connectivity.

The attributes of the ModuleProjection are :

name : name of the projection
source : reference to the source population name
dest : reference to the destination population name
sourceMethod : definition of the source method
destMethod : definition of the destination method

The following section explains how to define Source and Destination methods.

Defining the destination and source methods


        <sourceMethod module="modules.toNextSrc">
 	   <parameters class="tutorial.sourcemethod.SpikeSourceMethod" srcPort="out"/>
        </sourceMethod>

        <destMethod module="modules.toNextDest" >
           <parameters class="tutorial.destmethod.SpikeDestMethod" dstPort ="in" delay="2.0"/>  
        </destMethod>

module : reference to the name of the code module link.
parameters : the method's parameters. These parameters are exaclty those of the code module coding the projection methods.

Defining the simulation's controls


<neuroml class="NeuromlPkg" description="" author="tutorial master" keywords="tutorial spike neuron model">
   <models>
   </models>
   <environment>
      <io>
      </io>     
      <schedule class="ControlledSchedule" module="Controljar">
       <parameters class=tutorial.TurorialControl time="10" 
           neuronpop="SpikeNeurons" genpop="SpikeGens"/> 
      </schedule>
   </environment>
   <modules>
   </modules>
</neuroml>

inputs : list of non-biological entities used to send intput into the model.
outputs : list of non-biological probes used to get outputs from the model.
schedule : control of the simulation's run.

class : Name of the schedule class used. ControlledSchedule is not the default class for schedules and therefore must be explicitly named.
module : reference to the name of the code module link.
parameters : parameters of this control module.

Defining the external modules used


<neuroml class="NeuromlPkg" description="" author="tutorial master" keywords="tutorial spike neuron model">
   <models>
   </models>
   <environment>
   </environment>
   <modules>
      <module name="toNextSrc" class="SourceMethodModule"
            location="http://www.anc.ed.ac.uk/~paulro/jars/tutsourcemethod.jar"/>
      <module name="toNextDest" class="DestMethodModule"
            location="http://www.anc.ed.ac.uk/~paulro/jars/tutdestmethod.jar"/>
      <module name="Controljar" class="ControlModule" location="http://www.anc.ed.ac.uk/~paulro/jars/tutcontrol.jar"/>
      <module name="SpikeNeuronjar"
            location="http://www.anc.ed.ac.uk/~paulro/jars/tutspikeneuron.jar"/>
      <module name="SpikeGenjar"
            location="http://www.anc.ed.ac.uk/~paulro/jars/tutspikegen.jar"/>
   </modules>
</neuroml>

The actual paths for code modules are not explicitely given everytime a module has to be specified.
Instead a reference is given, targeting a module name placed in a module list.

The list of modules contain the modules name and location