const Cinfo* initSigNeurCinfo()
{
static Finfo* sigNeurFinfos[] =
{
///////////////////////////////////////////////////////
// Field definitions
///////////////////////////////////////////////////////
new ValueFinfo( "cellProto",
ValueFtype1< Id >::global(),
GFCAST( &SigNeur::getCellProto ),
RFCAST( &SigNeur::setCellProto )
),
new ValueFinfo( "spineProto",
ValueFtype1< Id >::global(),
GFCAST( &SigNeur::getSpineProto ),
RFCAST( &SigNeur::setSpineProto )
),
new ValueFinfo( "dendProto",
ValueFtype1< Id >::global(),
GFCAST( &SigNeur::getDendProto ),
RFCAST( &SigNeur::setDendProto )
),
new ValueFinfo( "somaProto",
ValueFtype1< Id >::global(),
GFCAST( &SigNeur::getSomaProto ),
RFCAST( &SigNeur::setSomaProto )
),
new ValueFinfo( "cell",
ValueFtype1< Id >::global(),
GFCAST( &SigNeur::getCell ),
&dummyFunc
),
new ValueFinfo( "spine",
ValueFtype1< Id >::global(),
GFCAST( &SigNeur::getSpine ),
&dummyFunc
),
new ValueFinfo( "dend",
ValueFtype1< Id >::global(),
GFCAST( &SigNeur::getDend ),
&dummyFunc
),
new ValueFinfo( "soma",
ValueFtype1< Id >::global(),
GFCAST( &SigNeur::getSoma ),
&dummyFunc
),
new ValueFinfo( "cellMethod",
ValueFtype1< string >::global(),
GFCAST( &SigNeur::getCellMethod ),
RFCAST( &SigNeur::setCellMethod )
),
new ValueFinfo( "spineMethod",
ValueFtype1< string >::global(),
GFCAST( &SigNeur::getSpineMethod ),
RFCAST( &SigNeur::setSpineMethod )
),
new ValueFinfo( "dendMethod",
ValueFtype1< string >::global(),
GFCAST( &SigNeur::getDendMethod ),
RFCAST( &SigNeur::setDendMethod )
),
new ValueFinfo( "somaMethod",
ValueFtype1< string >::global(),
GFCAST( &SigNeur::getSomaMethod ),
RFCAST( &SigNeur::setSomaMethod )
),
new ValueFinfo( "sigDt",
ValueFtype1< double >::global(),
GFCAST( &SigNeur::getSigDt ),
RFCAST( &SigNeur::setSigDt )
),
new ValueFinfo( "cellDt",
ValueFtype1< double >::global(),
GFCAST( &SigNeur::getCellDt ),
RFCAST( &SigNeur::setCellDt )
),
new ValueFinfo( "Dscale",
ValueFtype1< double >::global(),
GFCAST( &SigNeur::getDscale ),
RFCAST( &SigNeur::setDscale )
),
new ValueFinfo( "lambda",
ValueFtype1< double >::global(),
GFCAST( &SigNeur::getLambda ),
RFCAST( &SigNeur::setLambda )
),
new ValueFinfo( "parallelMode",
ValueFtype1< int >::global(),
GFCAST( &SigNeur::getParallelMode ),
RFCAST( &SigNeur::setParallelMode )
),
new ValueFinfo( "updateStep", // Time between sig<->neuro updates
ValueFtype1< double >::global(),
GFCAST( &SigNeur::getUpdateStep ),
RFCAST( &SigNeur::setUpdateStep )
),
new LookupFinfo( "channelMap", // Mapping from channels to sig mols
LookupFtype< string, string >::global(),
GFCAST( &SigNeur::getChannelMap ),
RFCAST( &SigNeur::setChannelMap )
),
new LookupFinfo( "calciumMap", // Mapping from calcium to sig.
LookupFtype< string, string >::global(),
GFCAST( &SigNeur::getCalciumMap ),
RFCAST( &SigNeur::setCalciumMap )
),
new ValueFinfo( "calciumScale",
ValueFtype1< double >::global(),
GFCAST( &SigNeur::getCalciumScale ),
RFCAST( &SigNeur::setCalciumScale )
),
new ValueFinfo( "dendInclude",
ValueFtype1< string >::global(),
GFCAST( &SigNeur::getDendInclude ),
RFCAST( &SigNeur::setDendInclude )
),
new ValueFinfo( "dendExclude",
ValueFtype1< string >::global(),
GFCAST( &SigNeur::getDendExclude ),
RFCAST( &SigNeur::setDendExclude )
),
// Would be nice to have a way to include synaptic input into
// the mGluR input.
///////////////////////////////////////////////////////
// MsgSrc definitions
///////////////////////////////////////////////////////
///////////////////////////////////////////////////////
// MsgDest definitions
///////////////////////////////////////////////////////
new DestFinfo( "build", Ftype0::global(),
RFCAST( &SigNeur::build )
),
///////////////////////////////////////////////////////
// Synapse definitions
///////////////////////////////////////////////////////
///////////////////////////////////////////////////////
// Shared definitions
///////////////////////////////////////////////////////
};
// Schedule it to tick 1 stage 0
// static SchedInfo schedInfo[] = { { process, 0, 0 } };
static string doc[] =
{
"Name", "SigNeur",
"Author", "Upinder S. Bhalla, 2007, NCBS",
"Description", "SigNeur: Multiscale simulation setup object for doing combined electrophysiological "
"and signaling models of neurons. Takes the geometry from the neuronal model and "
"sets up diffusion between signaling models to fit in this geometry. Arranges "
"interfaces between channel conductances and molecular species representing "
"channels.Also interfaces calcium conc in the two kinds of model.",
};
static Cinfo sigNeurCinfo(
doc,
sizeof( doc ) / sizeof( string ),
initNeutralCinfo(),
sigNeurFinfos,
sizeof( sigNeurFinfos )/sizeof(Finfo *),
ValueFtype1< SigNeur >::global()
);
// methodMap.size(); // dummy function to keep compiler happy.
return &sigNeurCinfo;
}
const Cinfo* initIzhikevichNrnCinfo()
{
static Finfo* processShared[] = {
new DestFinfo( "process", Ftype1< ProcInfo >::global(),
RFCAST( &IzhikevichNrn::processFunc )),
new DestFinfo( "reinit", Ftype1< ProcInfo >::global(),
RFCAST( &IzhikevichNrn::reinitFunc )),
};
static Finfo* process = new SharedFinfo("process", processShared,
sizeof(processShared) / sizeof(Finfo*),
"This is a shared message to receive Process messages from the scheduler objects. "
"The first entry is a MsgDest for the Process operation. It has a single argument,ProcInfo, "
"which holds lots of information about current time, thread, dt and so on. "
"The second entry is a MsgDest for the Reinit operation. "
"It also uses ProcInfo.");
static Finfo* izhikevichNrnFinfos[] = {
new ValueFinfo("Vmax", ValueFtype1<double>::global(),
GFCAST(&IzhikevichNrn::getVmax),
RFCAST(&IzhikevichNrn::setVmax),
"Maximum membrane potential. Membrane potential is reset to c whenever"
" it reaches Vmax. NOTE: Izhikevich model specifies the PEAK voltage,"
" rather than THRSHOLD voltage. The threshold depends on the previous"
" history."),
new ValueFinfo("c", ValueFtype1<double>::global(),
GFCAST(&IzhikevichNrn::getC),
RFCAST(&IzhikevichNrn::setC),
"Reset potential. Membrane potential is reset to c whenever it reaches"
" Vmax."),
new ValueFinfo("d", ValueFtype1<double>::global(),
GFCAST(&IzhikevichNrn::getD),
RFCAST(&IzhikevichNrn::setD),
"Parameter d in Izhikevich model. Unit is V/s."),
new ValueFinfo("a", ValueFtype1<double>::global(),
GFCAST(&IzhikevichNrn::getA),
RFCAST(&IzhikevichNrn::setA),
"Parameter a in Izhikevich model. Unit is s^-1"),
new ValueFinfo("b", ValueFtype1<double>::global(),
GFCAST(&IzhikevichNrn::getB),
RFCAST(&IzhikevichNrn::setB),
"Parameter b in Izhikevich model. Unit is s^-1"),
new ValueFinfo("Vm", ValueFtype1<double>::global(),
GFCAST(&IzhikevichNrn::getVm),
RFCAST(&IzhikevichNrn::setVm),
"Membrane potential, equivalent to v in Izhikevich equation."),
new ValueFinfo("u", ValueFtype1<double>::global(),
GFCAST(&IzhikevichNrn::getU),
RFCAST(&dummyFunc),
"Parameter u in Izhikevich equation. Unit is V/s^-1"),
new ValueFinfo("Im", ValueFtype1<double>::global(),
GFCAST(&IzhikevichNrn::getInject),
RFCAST(&dummyFunc),
"Total current going through the membrane. Unit is A."),
new ValueFinfo("initVm", ValueFtype1<double>::global(),
GFCAST(&IzhikevichNrn::getInitVm),
RFCAST(&IzhikevichNrn::setInitVm),
"Initial membrane potential. Unit is V."),
new ValueFinfo("initU", ValueFtype1<double>::global(),
GFCAST(&IzhikevichNrn::getInitU),
RFCAST(&IzhikevichNrn::setInitU),
"Initial value of u."),
new ValueFinfo("alpha", ValueFtype1<double>::global(),
GFCAST(&IzhikevichNrn::getAlpha),
RFCAST(&IzhikevichNrn::setAlpha),
"Coefficient of v^2 in Izhikevich equation. Defaults to 0.04 in"
" physiological unit. In SI it should be 40000.0. Unit is V^-1 s^-1"),
new ValueFinfo("beta", ValueFtype1<double>::global(),
GFCAST(&IzhikevichNrn::getBeta),
RFCAST(&IzhikevichNrn::setBeta),
"Coefficient of v in Izhikevich model. Defaults to 5 in physiological"
" unit, 5000.0 for SI units. Unit is s^-1"),
new ValueFinfo("gamma", ValueFtype1<double>::global(),
GFCAST(&IzhikevichNrn::getGamma),
RFCAST(&IzhikevichNrn::setGamma),
"Constant term in Izhikevich model. Defaults to 140 in both"
" physiological and SI units. unit is V/s."),
new ValueFinfo("Rm", ValueFtype1<double>::global(),
GFCAST(&IzhikevichNrn::getRm),
RFCAST(&IzhikevichNrn::setRm),
"Hidden cefficient of input current term (I) in Izhikevich model. Defaults to 1e6 Ohm."),
///////////////////////////////
// MsgSrc definition
///////////////////////////////
new SrcFinfo("VmSrc", Ftype1<double>::global()),
new SrcFinfo("eventSrc", Ftype1<double>::global(),
"Sends out a trigger for an event whenever Vm >= c."),
///////////////////////////////
// MsgDest definition
///////////////////////////////
new DestFinfo("injectDest", Ftype1< double >::global(),
RFCAST( &IzhikevichNrn::setInject),
"Injection current into the neuron."),
new DestFinfo("cDest", Ftype1< double >::global(),
RFCAST(&IzhikevichNrn::setC),
"Destination message to modify parameter c at runtime."),
new DestFinfo("dDest", Ftype1< double >::global(),
RFCAST(&IzhikevichNrn::setD),
"Destination message to modify parameter d at runtime."),
new DestFinfo("aDest", Ftype1<double>::global(),
RFCAST(&IzhikevichNrn::setA),
"Destination message modify parameter a at runtime."),
new DestFinfo("bDest", Ftype1<double>::global(),
RFCAST(&IzhikevichNrn::setB),
"Destination message to modify parameter b at runtime"),
///////////////////////////////
// SharedFinfos
///////////////////////////////
process,
};
static SchedInfo schedInfo[] = { {process, 0, 0 },};
static string doc[] = {
"Name", "IzhikevichNrn",
"Author", "Subhasis Ray",
"Description", "Izhikevich model of spiking neuron "
"(Izhikevich,EM. 2003. Simple model of spiking neurons. Neural"
" Networks, IEEE Transactions on 14(6). pp 1569–1572).\n"
" This class obeys the equations (in physiological units):\n"
" dVm/dt = 0.04 * Vm^2 + 5 * Vm + 140 - u + inject\n"
" du/dt = a * (b * Vm - u)\n"
" if Vm >= Vmax then Vm = c and u = u + d\n"
" Vmax = 30 mV in the paper."
};
static Cinfo izhikevichNrnCinfo(
doc,
sizeof(doc) / sizeof(string),
initNeutralCinfo(),
izhikevichNrnFinfos,
sizeof(izhikevichNrnFinfos) / sizeof(Finfo*),
ValueFtype1<IzhikevichNrn>::global(),
schedInfo, 1);
return &izhikevichNrnCinfo;
}
void lookupFinfoTest()
{
cout << "\nTesting lookupFinfo set and get";
const Ftype* f1a = LookupFtype< double, string >::global();
const Ftype* f1d = ValueFtype1< double >::global();
const Ftype* f0 = Ftype0::global();
static Finfo* requestValShared[] =
{
new SrcFinfo( "procout", f0 ),
new DestFinfo( "dsum", f1d, RFCAST( &LookupTestClass::dsum ) ),
};
static Finfo* testFinfos[] =
{
new LookupFinfo( "dmap", f1a,
reinterpret_cast< GetFunc >( &LookupTestClass::getDmap ),
reinterpret_cast< RecvFunc >( &LookupTestClass::setDmap ) ),
new ValueFinfo( "dval", f1d,
LookupTestClass::getDval,
reinterpret_cast< RecvFunc >( &LookupTestClass::setDval ) ),
new SharedFinfo( "requestVal", requestValShared,
sizeof( requestValShared ) / sizeof( Finfo* ) ),
new SrcFinfo( "dsumout", f1d ),
new SrcFinfo( "procout", f0 ),
new DestFinfo( "dsum", f1d, RFCAST( &LookupTestClass::dsum ) ),
new DestFinfo( "proc", f0, &LookupTestClass::proc ),
};
Cinfo lookuptestclass( "lookuptestclass", "Upi",
"Lookup Test class",
initNeutralCinfo(),
testFinfos,
sizeof( testFinfos ) / sizeof( Finfo*),
ValueFtype1< LookupTestClass >::global() );
FuncVec::sortFuncVec();
sumSlot = lookuptestclass.getSlot( "dsumout" );
procSlot = lookuptestclass.getSlot( "procout" );
requestSlot = lookuptestclass.getSlot( "requestVal.procout" );
Element* a1 = lookuptestclass.create( Id::scratchId(), "a1" );
double dret = 0;
get< double >( a1, "dval", dret );
ASSERT( dret == 2.2202, "test get1");
set< double >( a1, "dval", 555.5 );
dret = 0;
get< double >( a1, "dval", dret );
ASSERT( dret == 555.5, "test set1");
vector< Finfo* > flist;
unsigned int ndyn = a1->listLocalFinfos( flist );
ASSERT( ndyn == 0, "Counting DynFinfos" );
// Here we have the crucial functions for the LookupFinfo:
// the ability to lookup the data using the lookupGet/Set functions
// where the index is provided in the function itself, rather
// than in the name of the field.
lookupGet< double, string >( a1, "dmap", dret, "0" );
ASSERT( dret == 0.1, "test lookupGet0");
lookupSet< double, string >( a1, "dmap", 1111.1, "0" );
dret = 0;
lookupGet< double, string >( a1, "dmap", dret, "0" );
ASSERT( dret == 1111.1, "test lookupSet0");
// Note that the match function will treat the indices as
// strings.
// First we confirm that the zeroth entry is the same as touched
// by the lookupSet previously.
get< double >( a1, "dmap[0]", dret );
ASSERT( dret == 1111.1, "test get0");
set< double >( a1, "dmap[0]", 1.1 );
dret = 0;
get< double >( a1, "dmap[0]", dret );
ASSERT( dret == 1.1, "test set0");
// Check that there is only one DynamicFinfo set up when looking at
// the same lookup index.
ASSERT( a1->listLocalFinfos( flist ) == 1, "Counting DynFinfos" );
get< double >( a1, a1->findFinfo( "dmap[1]" ), dret );
ASSERT( dret == 0.2, "test get1");
set< double >( a1, a1->findFinfo( "dmap[1]" ), 2.2 );
dret = 0;
get< double >( a1, a1->findFinfo( "dmap[1]" ), dret );
ASSERT( dret == 2.2, "test set1");
// Check that there is only one DynamicFinfo set up when looking at
// the same lookup index.
ASSERT( a1->listLocalFinfos( flist ) == 1, "Counting DynFinfos" );
get< double >( a1, a1->findFinfo( "dmap[3]" ), dret );
ASSERT( dret == 0.4, "test get3");
set< double >( a1, a1->findFinfo( "dmap[3]" ), 3.3 );
dret = 1234.567;
get< double >( a1, a1->findFinfo( "dmap[3]" ), dret );
ASSERT( dret == 3.3, "test set3");
// Check that the system reuses the DynamicFinfo.
ASSERT( a1->listLocalFinfos( flist ) == 1, "Counting DynFinfos" );
////////////////////////////////////////////////////////////////
// Check string set and get.
////////////////////////////////////////////////////////////////
string sret = "";
bool bret = 0;
bret = a1->findFinfo( "dmap[3]" )->strSet( a1, "-2.3" );
ASSERT( bret, "strSet" );
get< double >( a1, a1->findFinfo( "dmap[3]" ), dret );
ASSERT( dret == -2.3, "test strSet");
bret = a1->findFinfo( "dmap[3]" )->strGet( a1, sret );
ASSERT( bret, "strSet" );
ASSERT( sret == "-2.3", "test strSet");
bret = a1->findFinfo( "dmap[2]" )->strSet( a1, "-0.03" );
ASSERT( bret, "strSet" );
bret = get< double >( a1, a1->findFinfo( "dmap[2]" ), dret );
ASSERT( bret, "strGet" );
ASSERT( dret == -0.03, "test strGet");
////////////////////////////////////////////////////////////////
// Now we start testing messages between LookupFinfo fields.
////////////////////////////////////////////////////////////////
cout << "\nTesting lookupFinfo messaging";
Element* a2 = lookuptestclass.create( Id::scratchId(), "a2" );
// We will follow a1 messages to call proc on a2. Check a2->dval.
//
// proc on a2 will send this value of dval to a1->dmap[0]. Check it.
//
// a1 trigger message will call send on a2->dmap[1]. This goes
// to a1->dval. Check it.
//
// a1 trigger message will call send on a2->dmap[2]. This goes
// to a1->dmap[2]. The trigger is created first. Check it.
//
// a1 trigger message will call send on a2->dmap[3]. This goes
// to a1->dmap[3]. The send is created first. Check it.
// 1. We will follow a1 messages to call proc on a2. Check a2->dval.
const Finfo *f1 = a1->findFinfo( "procout" );
const Finfo *f2 = a2->findFinfo( "proc" );
bret = f1->add( a1, a2, f2, ConnTainer::Default );
ASSERT( bret, "adding procout to proc");
// 2. proc on a2 will send this value of dval to a1->dmap[0].
f1 = a2->findFinfo( "dsumout" );
f2 = a1->findFinfo( "dmap[0]" );
bret = f1->add( a2, a1, f2, ConnTainer::Default );
ASSERT( bret, "Adding dsumout to dval");
// We have already made a finfo for a1->dmap[0]. Check that this
// is the one that is used for the messaging.
ASSERT( a1->listLocalFinfos( flist ) == 1, "Counting DynFinfos" );
// 3. a1 trigger message will call request on a2->dmap[1]. The
// value comes back to a1, and is added to dval.
f1 = a1->findFinfo( "requestVal" );
f2 = a2->findFinfo( "dmap[1]" );
bret = f1->add( a1, a2, f2, ConnTainer::Default );
ASSERT( bret, "Adding requestVal to dmap[1]");
// Here we made a new DynamicFinfo for the regular ValueFinfo.
ASSERT( a2->listLocalFinfos( flist ) == 1, "Counting DynFinfos" );
// 4. a2 trigger message will call request on a1->dmap[2]. This
// is set up using reverse Shared messaging calls. The
// value comes back to a2 and is added to dval.
f1 = a1->findFinfo( "dmap[2]" );
f2 = a2->findFinfo( "requestVal" );
bret = f1->add( a1, a2, f2, ConnTainer::Default );
ASSERT( bret, "Adding a1.dmap[2] to a2.requestVal");
// We have not made a finfo for a1->dmap[2]. Check that this
// new one is used for the messaging.
ASSERT( a1->listLocalFinfos( flist ) == 2, "Counting DynFinfos" );
///////////////////////////////////////////////////////////////////
// Now setup is done, let's start sending info around.
///////////////////////////////////////////////////////////////////
bret = set< double >( a1, "dval", 4321.0 );
bret &= set< double >( a2, "dval", 1234.0 );
bret &= set< double >( a1, "dmap[0]", 10.0 );
bret &= set< double >( a1, "dmap[1]", 20.0 );
bret &= set< double >( a1, "dmap[2]", 30.0 );
bret &= set< double >( a1, "dmap[3]", 40.0 );
bret &= set< double >( a2, "dmap[0]", 1.0 );
bret &= set< double >( a2, "dmap[1]", 2.0 );
bret &= set< double >( a2, "dmap[2]", 3.0 );
bret &= set< double >( a2, "dmap[3]", 4.0 );
ASSERT( bret, "assignment");
bret = get< double >( a1, a1->findFinfo( "dmap[2]" ), dret );
ASSERT( bret, "test assignment");
ASSERT( dret == 30.0, "test assignment");
send0( a1, procSlot ); // procout
// Here a2->dval should simply become the sum of its lookup entries.
// As this has just been initialized, the sum should be 10.0.
// Bad Upi: should never test for equality of doubles.
get< double >( a2, a2->findFinfo( "dval" ), dret );
ASSERT( dret == 10.0, "test msg1");
// proc on a2 will send this value of dval to a1->dmap[0]. Check it.
dret = 0.0;
get< double >( a1, a1->findFinfo( "dmap[0]" ), dret );
ASSERT( dret == 10.0, "test msg2");
//////////////////////////////////////////////////////////////////////
// a1 trigger message will call send on a2->dmap[1], which currently
// holds the value 2. The value is added to a1->dval, which is 4321
send0( a1, requestSlot ); // procout
dret = 0.0;
get< double >( a1, a1->findFinfo( "dval" ), dret );
ASSERT( dret == 4323.0, "test msg3");
// 4. a2 trigger message will call request on a1->dmap[2]. This
// is set up using reverse Shared messaging calls. The
// value ( 30 ) comes back to a2 and is added to dval (10).
bret = get< double >( a2, a2->findFinfo( "dval" ), dret );
ASSERT( bret, "test msg4");
ASSERT( dret == 10.0, "test msg4");
dret = 0;
bret = get< double >( a1, a1->findFinfo( "dmap[2]" ), dret );
ASSERT( bret, "test msg4");
ASSERT( dret == 30.0, "test msg4");
send0( a2, requestSlot ); // procout
dret = 0.0;
get< double >( a2, a2->findFinfo( "dval" ), dret );
ASSERT( dret == 40, "test msg4");
// Check that there are no strange things happening with the
// Finfos when the messaging is actually used.
// Note that we set all of a1.dmap[], only 2 of which were already used
// Note that we set all of a2.dmap[], only 1 of which was already used
// Since the system reuses when it can, the net increment in each is 1.
ASSERT( a1->listLocalFinfos( flist ) == 3, "Counting DynFinfos" );
ASSERT( a2->listLocalFinfos( flist ) == 2, "Counting DynFinfos" );
}
const Cinfo* initOutputEventPortCinfo()
{
static Finfo* processShared[] =
{
new DestFinfo( "process", Ftype1< ProcInfo >::global(),
dummyFunc ),
new DestFinfo( "reinit", Ftype1< ProcInfo >::global(),
RFCAST( &OutputEventPort::reinitFunc ) )
};
static Finfo* process =
new SharedFinfo( "process", processShared,
sizeof( processShared ) / sizeof( Finfo* ) );
static Finfo* outputEventPortFinfos[] =
{
new ValueFinfo( "isConnected", ValueFtype1< unsigned int >::global(),
GFCAST( &OutputEventPort::getIsConnected ),
&dummyFunc
),
new ValueFinfo( "width", ValueFtype1< unsigned int >::global(),
GFCAST( &OutputEventPort::getWidth ),
&dummyFunc
),
new ValueFinfo( "maxBuffered", ValueFtype1< int >::global(),
GFCAST( &OutputEventPort::getMaxBuffered ),
RFCAST( &OutputEventPort::setMaxBuffered )
),
new DestFinfo( "initialise",
Ftype3< unsigned int, unsigned int,
MUSIC::EventOutputPort* >::global(),
RFCAST( &OutputEventPort::initialiseFunc )
),
process
};
/**
* Music ports should be initialized before the MusicManager gets initialized.
* In the default autoschedule,
*
* By default, /music is connected to clock 0, stage 1. In some cases it is
* possible to attach /music to a slow clock.
*/
static SchedInfo schedInfo[] = { { process, 0, 0 } };
static string doc[] =
{
"Name", "OutputEventPort",
"Author", "Niraj Dudani and Johannes Hjorth",
"Description", "OutputEventPort for communciation with the MUSIC API",
};
static Cinfo outputEventPortCinfo(
doc,
sizeof( doc ) / sizeof( string ),
initNeutralCinfo(),
outputEventPortFinfos,
sizeof( outputEventPortFinfos ) / sizeof( Finfo* ),
ValueFtype1< OutputEventPort >::global(),
schedInfo, 1 );
return &outputEventPortCinfo;
}
const Cinfo* initInputEventPortCinfo()
{
static Finfo* processShared[] =
{
new DestFinfo( "process", Ftype1< ProcInfo >::global(),
dummyFunc ),
new DestFinfo( "reinit", Ftype1< ProcInfo >::global(),
RFCAST( &InputEventPort::reinitFunc ) )
};
static Finfo* process =
new SharedFinfo( "process", processShared,
sizeof( processShared ) / sizeof( Finfo* ),
"This is a shared message to receive Process messages from the scheduler objects." );
static Finfo* inputEventPortFinfos[] =
{
new ValueFinfo( "isConnected", ValueFtype1< unsigned int >::global(),
GFCAST( &InputEventPort::getIsConnected ),
&dummyFunc
),
new ValueFinfo( "width", ValueFtype1< unsigned int >::global(),
GFCAST( &InputEventPort::getWidth ),
&dummyFunc
),
new ValueFinfo( "accLatency", ValueFtype1< double >::global(),
GFCAST( &InputEventPort::getAccLatency ),
RFCAST( &InputEventPort::setAccLatency )
),
new ValueFinfo( "maxBuffered", ValueFtype1< int >::global(),
GFCAST( &InputEventPort::getMaxBuffered ),
RFCAST( &InputEventPort::setMaxBuffered )
),
new DestFinfo( "initialise",
Ftype3< unsigned int, unsigned int, MUSIC::EventInputPort* >::global(),
RFCAST( &InputEventPort::initialiseFunc )
),
//////////////////////////////////////////////////////////////////
// SharedFinfos
//////////////////////////////////////////////////////////////////
process,
};
static SchedInfo schedInfo[] = { { process, 0, 0 } };
static string doc[] =
{
"Name", "InputEventPort",
"Author", "Niraj Dudani and Johannes Hjorth",
"Description", "InputEventPort for communciation with the MUSIC API",
};
static Cinfo inputEventPortCinfo(
doc,
sizeof( doc ) / sizeof( string ),
initNeutralCinfo(),
inputEventPortFinfos,
sizeof( inputEventPortFinfos ) / sizeof( Finfo* ),
ValueFtype1< InputEventPort >::global(),
schedInfo, 1 );
return &inputEventPortCinfo;
}
const Cinfo* initBinSynchanCinfo()
{
static Finfo* processShared[] =
{
new DestFinfo( "process", Ftype1< ProcInfo >::global(),
RFCAST( &BinSynchan::processFunc ) ),
new DestFinfo( "reinit", Ftype1< ProcInfo >::global(),
RFCAST( &BinSynchan::reinitFunc ) ),
};
static Finfo* process = new SharedFinfo( "process", processShared,
sizeof( processShared ) / sizeof( Finfo* ),
"This is a shared message to receive Process message from the scheduler." );
static Finfo* channelShared[] =
{
new SrcFinfo( "channel", Ftype2< double, double >::global() ),
new DestFinfo( "Vm", Ftype1< double >::global(),
RFCAST( &BinSynchan::channelFunc ) ),
};
///////////////////////////////////////////////////////
// Field definitions
///////////////////////////////////////////////////////
static Finfo* binSynchanFinfos[] =
{
new ValueFinfo( "Gbar", ValueFtype1< double >::global(),
GFCAST( &BinSynchan::getGbar ),
RFCAST( &BinSynchan::setGbar )
),
new ValueFinfo( "Ek", ValueFtype1< double >::global(),
GFCAST( &BinSynchan::getEk ),
RFCAST( &BinSynchan::setEk )
),
new ValueFinfo( "tau1", ValueFtype1< double >::global(),
GFCAST( &BinSynchan::getTau1 ),
RFCAST( &BinSynchan::setTau1 )
),
new ValueFinfo( "tau2", ValueFtype1< double >::global(),
GFCAST( &BinSynchan::getTau2 ),
RFCAST( &BinSynchan::setTau2 )
),
new ValueFinfo( "normalizeWeights",
ValueFtype1< bool >::global(),
GFCAST( &BinSynchan::getNormalizeWeights ),
RFCAST( &BinSynchan::setNormalizeWeights )
),
new ValueFinfo( "Gk", ValueFtype1< double >::global(),
GFCAST( &BinSynchan::getGk ),
RFCAST( &BinSynchan::setGk )
),
new ValueFinfo( "Ik", ValueFtype1< double >::global(),
GFCAST( &BinSynchan::getIk ),
RFCAST( &BinSynchan::setIk )
),
new ValueFinfo( "numSynapses",
ValueFtype1< unsigned int >::global(),
GFCAST( &BinSynchan::getNumSynapses ),
&dummyFunc // Prohibit reassignment of this index.
),
new LookupFinfo( "weight",
LookupFtype< double, unsigned int >::global(),
GFCAST( &BinSynchan::getWeight ),
RFCAST( &BinSynchan::setWeight )
),
new LookupFinfo( "delay",
LookupFtype< double, unsigned int >::global(),
GFCAST( &BinSynchan::getDelay ),
RFCAST( &BinSynchan::setDelay )
),
new LookupFinfo( "poolSize",
LookupFtype< int, unsigned int >::global(),
GFCAST( &BinSynchan::getPoolSize ),
RFCAST( &BinSynchan::setPoolSize )
),
new LookupFinfo( "releaseP",
LookupFtype< double, unsigned int>::global(),
GFCAST( &BinSynchan::getReleaseP ),
RFCAST( &BinSynchan::setReleaseP )
),
new LookupFinfo( "releaseCount",
LookupFtype< double, unsigned int>::global(),
GFCAST( &BinSynchan::getReleaseCount ),
&dummyFunc
),
///////////////////////////////////////////////////////
// Shared message definitions
///////////////////////////////////////////////////////
process,
new SharedFinfo( "channel", channelShared,
sizeof( channelShared ) / sizeof( Finfo* ),
"This is a shared message to couple channel to compartment. "
"The first entry is a MsgSrc to send Gk and Ek to the compartment. "
"The second entry is a MsgDest for Vm from the compartment. " ),
///////////////////////////////////////////////////////
// MsgSrc definitions
///////////////////////////////////////////////////////
new SrcFinfo( "IkSrc", Ftype1< double >::global() ),
new SrcFinfo( "origChannel", Ftype2< double, double >::
global() ),
///////////////////////////////////////////////////////
// MsgDest definitions
///////////////////////////////////////////////////////
new DestFinfo( "synapse", Ftype1< double >::global(),
RFCAST( &BinSynchan::synapseFunc ),
"Arrival of a spike. Arg is time of sending of spike." ),
new DestFinfo( "activation", Ftype1< double >::global(),
RFCAST( &BinSynchan::activationFunc ),
"Sometimes we want to continuously activate the channel" ),
new DestFinfo( "modulator", Ftype1< double >::global(),
RFCAST( &BinSynchan::modulatorFunc ),
"Modulate channel response" ),
};
// BinSynchan is scheduled after the compartment calculations.
static SchedInfo schedInfo[] = { { process, 0, 1 } };
static string doc[] =
{
"Name", "BinSynchan",
"Author", "Upinder S. Bhalla, 2007, NCBS",
"Description", "BinSynchan: Synaptic channel incorporating weight and delay. Does not "
"handle activity-dependent modification, see HebbBinSynchan for that. "
"Very similiar to the old synchan from GENESIS.",
};
static Cinfo binSynchanCinfo(
doc,
sizeof( doc ) / sizeof( string ),
initNeutralCinfo(),
binSynchanFinfos,
sizeof( binSynchanFinfos )/sizeof(Finfo *),
ValueFtype1< BinSynchan >::global(),
schedInfo, 1
);
return &binSynchanCinfo;
}
const Cinfo* initHSolveHubCinfoInner()
{
static Finfo* zombieShared[] =
{
new SrcFinfo( "process", Ftype1< ProcInfo >::global() ),
new SrcFinfo( "reinit", Ftype1< ProcInfo >::global() ),
};
static Finfo* compartmentChannelShared[] =
{
new DestFinfo(
"channel",
Ftype2< double, double >::global(),
RFCAST( &HSolveHub::compartmentChannelFunc ) ),
new SrcFinfo(
"Vm",
Ftype1< double >::global() ),
};
static Finfo* HSolveHubFinfos[] =
{
///////////////////////////////////////////////////////
// Field definitions
///////////////////////////////////////////////////////
///////////////////////////////////////////////////////
// MsgSrc definitions
///////////////////////////////////////////////////////
///////////////////////////////////////////////////////
// MsgDest definitions
///////////////////////////////////////////////////////
new DestFinfo( "integ-hub",
Ftype1< HSolveActive* >::global(),
RFCAST( &HSolveHub::hubFunc ),
"In this message, the hub receives a handle (a pointer) to the "
"solver. This is used by the hub to access the fields of the solver." ),
new DestFinfo( "destroy", Ftype0::global(),
&HSolveHub::destroy ),
new DestFinfo( "child", Ftype1< int >::global(),
RFCAST( &HSolveHub::childFunc ),
"override the Neutral::childFunc here, so that when this is deleted "
"all the zombies are reanimated." ),
new DestFinfo( "compartmentInjectMsg", Ftype1< double >::global(),
RFCAST( &HSolveHub::compartmentInjectMsgFunc ) ),
new SharedFinfo( "compartmentChannel", compartmentChannelShared,
sizeof( compartmentChannelShared ) / sizeof( Finfo* ),
"This message allows communication between external channels and "
"the Hines' solver." ),
///////////////////////////////////////////////////////
// Shared definitions
///////////////////////////////////////////////////////
new SharedFinfo( "compartmentSolve", zombieShared,
sizeof( zombieShared ) / sizeof( Finfo* ),
"This is identical to the message sent from clock Ticks to objects. "
"Here it is used to take over the Process message, usually only as "
"a handle from the solver to the object." ),
new SharedFinfo( "hhchannelSolve", zombieShared,
sizeof( zombieShared ) / sizeof( Finfo* ) ),
new SharedFinfo( "caconcSolve", zombieShared,
sizeof( zombieShared ) / sizeof( Finfo* ) ),
};
static string doc[] =
{
"Name",
"HSolveHub",
"Author",
"Niraj Dudani, 2007, NCBS",
"Description",
"HSolveHub: Ensures that field and message requests to solved objects "
"are cleanly redirected to their respective HSolve object.",
};
static Cinfo HSolveHubCinfo(
doc,
sizeof( doc ) / sizeof( string ),
initNeutralCinfo(),
HSolveHubFinfos,
sizeof( HSolveHubFinfos ) / sizeof( Finfo* ),
ValueFtype1< HSolveHub >::global()
);
return &HSolveHubCinfo;
}
const Cinfo* initPulseGenCinfo()
{
static Finfo* processShared[] =
{
new DestFinfo( "process", Ftype1<ProcInfo>::global(),
RFCAST(&PulseGen::processFunc)),
new DestFinfo( "reinit", Ftype1<ProcInfo>::global(),
RFCAST( &PulseGen::reinitFunc)),
};
static Finfo* process = new SharedFinfo( "process", processShared,
sizeof(processShared)/sizeof(Finfo*));
static Finfo* pulseGenFinfos[] =
{
new ValueFinfo("firstLevel", ValueFtype1<double>::global(),
GFCAST( &PulseGen::getFirstLevel),
RFCAST( &PulseGen::setFirstLevel),
"Amplitude of the first pulse output."),
new ValueFinfo("firstWidth", ValueFtype1<double>::global(),
GFCAST( &PulseGen::getFirstWidth),
RFCAST( &PulseGen::setFirstWidth),
"Duration of the first pulse output."),
new ValueFinfo("firstDelay", ValueFtype1<double>::global(),
GFCAST( &PulseGen::getFirstDelay),
RFCAST( &PulseGen::setFirstDelay),
"Delay to first pulse output. In FREE RUN mode, this is the interval" \
"from the end of the previous pulse till the start of the first pulse." \
"In case of TRIGGERED mode, this is how long it takes to start the "
"triggered pulse after the start of the triggering pulse."
"NOTE: If another triggering pulse comes before the triggered pulse "
"was generated, the triggered pulse will be lost as the last trigger "
"time is reset to the latest one and the pulsegen never reaches a state "
"where the time interval since the last trigger input never crosses "
"firstDelay."),
new ValueFinfo("secondLevel", ValueFtype1<double>::global(),
GFCAST( &PulseGen::getSecondLevel),
RFCAST( &PulseGen::setSecondLevel),
"Amplitude of the second pulse. Default value: 0"),
new ValueFinfo("secondWidth", ValueFtype1<double>::global(),
GFCAST( &PulseGen::getSecondWidth),
RFCAST( &PulseGen::setSecondWidth),
"Duration of the second pulse. Default value: 0"),
new ValueFinfo("secondDelay", ValueFtype1<double>::global(),
GFCAST( &PulseGen::getSecondDelay),
RFCAST( &PulseGen::setSecondDelay),
"Time interval between first and second pulse. If 0, there will be no "
"second pulse. Default value: 0"),
new ValueFinfo("baseLevel", ValueFtype1<double>::global(),
GFCAST( &PulseGen::getBaseLevel),
RFCAST( &PulseGen::setBaseLevel),
"Baseline output (when no pulse is being generated). Default value: 0."),
new ValueFinfo("output", ValueFtype1<double>::global(),
GFCAST( &PulseGen::getOutput),
&dummyFunc,
"Pulse output."),
new ValueFinfo("trigTime", ValueFtype1<double>::global(),
GFCAST( &PulseGen::getTrigTime),
RFCAST( &PulseGen::setTrigTime),
"Time since last time the input switched from 0 to non-zero. This is "
"supposed to be an internal variable, but old GENESIS scripts use this "
"field to generate a single pulse. If you set trigTime to a positive "
"value after reset, a single output will be generated at firstDelay "
"time."),
new ValueFinfo("count", ValueFtype1<int>::global(),
GFCAST( &PulseGen::getCount),
RFCAST( &PulseGen::setCount),
"Number of pulses in each period. Default is 2, where the second is "
"same as baseline at delay 0 with width 0."),
new LookupFinfo("width", LookupFtype<double, int>::global(),
GFCAST( &PulseGen::getWidth),
RFCAST( &PulseGen::setWidth),
"Width of i-th pulse in a period. Before you can set this, make sure "
"you have >= i pulses using pulseCount field."),
new LookupFinfo("delay", LookupFtype<double, int>::global(),
GFCAST( &PulseGen::getDelay),
RFCAST( &PulseGen::setDelay),
"Delay of i-th pulse in a period. Before you can set this, make sure"
" you have >= i pulses using pulseCount field."),
new LookupFinfo("level", LookupFtype<double, int>::global(),
GFCAST( &PulseGen::getLevel),
RFCAST( &PulseGen::setLevel),
"Amplitude of i-th pulse in a period. Before you can set this, make"
" sure you have >= i pulses using pulseCount field."),
new ValueFinfo("trigMode", ValueFtype1<int>::global(),
GFCAST( &PulseGen::getTrigMode),
RFCAST( &PulseGen::setTrigMode),
"TRIGGER MODES: \n"
"trig_mode = 0 free run \n"
"trig_mode = 1 ext. trig \n"
"trig_mode = 2 ext. gate" ),
new ValueFinfo("prevInput", ValueFtype1<int>::global(),
GFCAST( &PulseGen::getPreviousInput),
&dummyFunc),
//////////////////////////////////////////////////////////////////
// SharedFinfos
//////////////////////////////////////////////////////////////////
process,
///////////////////////////////////////////////////////
// MsgSrc definitions
///////////////////////////////////////////////////////
new SrcFinfo("outputSrc", Ftype1<double>::global()),
//////////////////////////////////////////////////////////////////
// MessageDestinations
//////////////////////////////////////////////////////////////////
new DestFinfo("input", Ftype1<double>::global(),
RFCAST(&PulseGen::inputFunc)),
new DestFinfo("levelDest", Ftype2<int, double>::global(),
RFCAST( &PulseGen::setLevelFunc)),
new DestFinfo("widthDest", Ftype2<int, double>::global(),
RFCAST( &PulseGen::setWidthFunc)),
new DestFinfo("delayDest", Ftype2<int, double>::global(),
RFCAST( & PulseGen::setDelayFunc)),
};
static SchedInfo schedInfo[] = { { process, 0, 0 } };
static string doc[] =
{
"Name", "PulseGen",
"Author", "Subhasis Ray, 2007, NCBS",
"Description", "PulseGen: general purpose pulse generator. This can generate any "
"number of pulses with specified level and duration.",
};
static Cinfo pulseGenCinfo(
doc,
sizeof( doc ) / sizeof( string ),
initNeutralCinfo(),
pulseGenFinfos,
sizeof(pulseGenFinfos)/sizeof(Finfo*),
ValueFtype1<PulseGen>::global(),
schedInfo, 1);
return &pulseGenCinfo;
}
const Cinfo* initGHKCinfo()
{
static Finfo* processShared[] =
{
new DestFinfo( "process", Ftype1< ProcInfo >::global(),
RFCAST( &GHK::processFunc ) ),
new DestFinfo( "reinit", Ftype1< ProcInfo >::global(),
RFCAST( &GHK::reinitFunc ) ),
};
static Finfo* process =
new SharedFinfo( "process", processShared,
sizeof( processShared ) / sizeof( Finfo* ) );
static Finfo* channelShared[] =
{
new SrcFinfo( "channel", Ftype2< double, double >::global() ),
new DestFinfo( "Vm", Ftype1< double >::global(),
RFCAST( &GHK::channelFunc ) ),
};
static Finfo* ghkShared[] =
{
new SrcFinfo( "Vm", Ftype1< double >::global() ),
new DestFinfo( "permeability", Ftype1< double >::global(),
RFCAST( &GHK::addPermeability ) ),
};
//!! Need to add channelFunc
static Finfo* GHKFinfos[] =
{
new ValueFinfo( "Ik", ValueFtype1< double >::global(),
GFCAST( &GHK::getIk ),
&dummyFunc
),
new ValueFinfo( "Gk", ValueFtype1< double >::global(),
GFCAST( &GHK::getGk ),
&dummyFunc
),
new ValueFinfo( "Ek", ValueFtype1< double >::global(),
GFCAST( &GHK::getEk ),
&dummyFunc
),
new ValueFinfo( "T", ValueFtype1< double >::global(),
GFCAST( &GHK::getTemperature ),
RFCAST( &GHK::setTemperature )
),
new ValueFinfo( "p", ValueFtype1< double >::global(),
GFCAST( &GHK::getPermeability ),
RFCAST( &GHK::setPermeability )
),
new ValueFinfo( "Vm", ValueFtype1< double >::global(),
GFCAST( &GHK::getVm ),
RFCAST( &GHK::setVm )
),
new ValueFinfo( "Cin", ValueFtype1< double >::global(),
GFCAST( &GHK::getCin ),
RFCAST( &GHK::setCin )
),
new ValueFinfo( "Cout", ValueFtype1< double >::global(),
GFCAST( &GHK::getCout ),
RFCAST( &GHK::setCout )
),
new ValueFinfo( "valency", ValueFtype1< double >::global(),
GFCAST( &GHK::getValency ),
RFCAST( &GHK::setValency )
),
process,
new SrcFinfo( "IkSrc", Ftype1< double >::global() ),
new DestFinfo( "CinDest", Ftype1< double >::global(),
RFCAST( &GHK::setCin ) ),
new DestFinfo( "CoutDest", Ftype1< double >::global(),
RFCAST( &GHK::setCout ) ),
new DestFinfo( "pDest", Ftype1< double >::global(),
RFCAST( &GHK::addPermeability ) ),
new SharedFinfo( "channel", channelShared,
sizeof( channelShared ) / sizeof( Finfo* ),
"This is a shared message to couple channel to compartment. "
"The first entry is a MsgSrc to send Gk and Ek to the compartment "
"The second entry is a MsgDest for Vm from the compartment." ),
new SharedFinfo( "ghk", ghkShared,
sizeof( ghkShared ) / sizeof( Finfo* ),
"This shared message connects to an HHChannel. "
"The first entry is a MsgSrc which relays the Vm received from "
"a compartment. The second entry is a MsgDest which receives "
"channel conductance, and interprets it as permeability." ),
};
// Order of updates: (t0) Compartment -> (t1) HHChannel -> (t2) GHK
static SchedInfo schedInfo[] = { { process, 0, 2 } };
static string doc[] =
{
"Name", "GHK",
"Author", "Johannes Hjorth, 2009, KTH, Stockholm",
"Description",
"Calculates the Goldman-Hodgkin-Katz (constant field) equation "
"for a single ionic species. Provides current as well as "
"reversal potential and slope conductance.",
};
static Cinfo GHKCinfo(
doc,
sizeof( doc ) / sizeof( string ),
initNeutralCinfo(),
GHKFinfos,
sizeof( GHKFinfos )/sizeof(Finfo *),
ValueFtype1< GHK >::global(),
schedInfo, 1
);
return &GHKCinfo;
}
const Cinfo* initRandomSpikeCinfo()
{
static Finfo* processShared[] =
{
new DestFinfo( "process", Ftype1<ProcInfo>::global(),
RFCAST(&RandomSpike::processFunc)),
new DestFinfo( "reinit", Ftype1<ProcInfo>::global(),
RFCAST( &RandomSpike::reinitFunc)),
};
static Finfo* process = new SharedFinfo( "process", processShared,
sizeof(processShared)/sizeof(Finfo*));
static Finfo* randomspikeFinfos[] =
{
new ValueFinfo("minAmp", ValueFtype1<double>::global(),
GFCAST( &RandomSpike::getMinAmp),
RFCAST( &RandomSpike::setMinAmp)),
new ValueFinfo("maxAmp", ValueFtype1<double>::global(),
GFCAST( &RandomSpike::getMaxAmp),
RFCAST( &RandomSpike::setMaxAmp)),
new ValueFinfo("rate", ValueFtype1<double>::global(),
GFCAST( &RandomSpike::getRate),
RFCAST( &RandomSpike::setRate)),
new ValueFinfo("resetValue", ValueFtype1<double>::global(),
GFCAST( &RandomSpike::getResetValue),
RFCAST( &RandomSpike::setResetValue)),
new ValueFinfo("state", ValueFtype1<double>::global(),
GFCAST( &RandomSpike::getState),
RFCAST( &RandomSpike::setState)),
new ValueFinfo("absRefract", ValueFtype1<double>::global(),
GFCAST( &RandomSpike::getAbsRefract),
RFCAST( &RandomSpike::setAbsRefract)),
new ValueFinfo("lastEvent", ValueFtype1<double>::global(),
GFCAST( &RandomSpike::getLastEvent),
&dummyFunc),
new ValueFinfo("reset", ValueFtype1<int>::global(),
GFCAST( &RandomSpike::getReset),
RFCAST( &RandomSpike::setReset)),
//////////////////////////////////////////////////////////////////
// SharedFinfos
//////////////////////////////////////////////////////////////////
process,
///////////////////////////////////////////////////////
// MsgSrc definitions
///////////////////////////////////////////////////////
new SrcFinfo("event", Ftype1<double>::global()),
new SrcFinfo("outputSrc", Ftype1<double>::global()),
//////////////////////////////////////////////////////////////////
// MessageDestinations
//////////////////////////////////////////////////////////////////
new DestFinfo("rateDest", Ftype1<double>::global(),
RFCAST(&RandomSpike::setRate)),
new DestFinfo("minAmpDest", Ftype1<double>::global(),
RFCAST( &RandomSpike::setMinAmp)),
new DestFinfo("maxAmpDest", Ftype1<double>::global(),
RFCAST( &RandomSpike::setMaxAmp)),
new DestFinfo("minmaxDest", Ftype2<double, double>::global(),
RFCAST( & RandomSpike::setMinMaxAmp)),
new DestFinfo("isiDest", Ftype1<double>::global(),
RFCAST( &RandomSpike::setISI),
"Interspike interval setting. The output of a random number generator \
can be connected to this and used as the interspike interval."),
};
static SchedInfo schedInfo[] = { { process, 0, 1 } };
static string doc[] =
{
"Name", "RandomSpike",
"Author", "Subhasis Ray, 2008, NCBS",
"Description", "RandomSpike: generates random events. It generates a random spike with "
"probability p = (rate * dt), where dt is the integration timestep for "
"the clock assigned to this object. Thus, it simulates a Poisson "
"process with rate {rate}. It is also possible to set the "
"inter-spike-interval dynamically, for example using a random number "
"generator object. The rate can also be changed dynamically via "
"rateDest message to simulate a non-homogeneous Poisson process."
,
};
static Cinfo randomSpikeCinfo(
doc,
sizeof( doc ) / sizeof( string ),
initNeutralCinfo(),
randomspikeFinfos,
sizeof(randomspikeFinfos)/sizeof(Finfo*),
ValueFtype1<RandomSpike>::global(),
schedInfo, 1);
return &randomSpikeCinfo;
}
