Finfo* initCompartmentZombieFinfo() { static Finfo* compartmentFields[] = { new ValueFinfo( "Vm", ValueFtype1< double >::global(), GFCAST( &HSolveHub::getVm ), RFCAST( &HSolveHub::setVm ) ), new ValueFinfo( "Im", ValueFtype1< double >::global(), GFCAST( &HSolveHub::getIm ), &dummyFunc ), new ValueFinfo( "inject", ValueFtype1< double >::global(), GFCAST( &HSolveHub::getInject ), RFCAST( &HSolveHub::setInject ) ), }; static const ThisFinfo* tf = dynamic_cast< const ThisFinfo* >( initCompartmentCinfo()->getThisFinfo() ); assert( tf != 0 ); static SolveFinfo compartmentZombieFinfo( compartmentFields, sizeof( compartmentFields ) / sizeof( Finfo* ), tf, "These fields will replace the original compartment fields so that the lookups refer to the solver rather " "than the compartment." ); return &compartmentZombieFinfo; }
const Cinfo* initBinomialRngCinfo() { static Finfo* binomialRngFinfos[] = { new ValueFinfo("n", ValueFtype1< double >::global(), GFCAST( &BinomialRng::getN), RFCAST(&BinomialRng::setN)), new ValueFinfo("p", ValueFtype1< double >::global(), GFCAST( &BinomialRng::getP), RFCAST(&BinomialRng::setP)), new DestFinfo("nDest", Ftype1 < double >::global(), RFCAST(&BinomialRng::setN)), new DestFinfo("pDest", Ftype1 < double >::global(), RFCAST(&BinomialRng::setP)), }; static string doc[] = { "Name", "BinomialRng", "Author", "Subhasis Ray", "Description", "Binomially distributed random number generator.", }; static Cinfo binomialRngCinfo( doc, sizeof( doc ) / sizeof( string ), initRandGeneratorCinfo(), binomialRngFinfos, sizeof(binomialRngFinfos)/sizeof(Finfo*), ValueFtype1<BinomialRng>::global() ); return &binomialRngCinfo; }
const Cinfo* initPoissonRngCinfo() { static Finfo* poissonRngFinfos[] = { new ValueFinfo("mean", ValueFtype1<double>::global(), GFCAST( &PoissonRng::getMean), RFCAST( &PoissonRng::setMean)), }; static string doc[] = { "Name", "PoissonRng", "Author", "Subhasis Ray", "Description", "Poisson distributed random number generator.", }; static Cinfo poissonRngCinfo( doc, sizeof( doc ) / sizeof( string ), initRandGeneratorCinfo(), poissonRngFinfos, sizeof(poissonRngFinfos)/sizeof(Finfo*), ValueFtype1<PoissonRng>::global() ); return &poissonRngCinfo; }
const Cinfo* initStochSpikeGenCinfo() { static Finfo* stochSpikeGenFinfos[] = { new ValueFinfo( "pr", ValueFtype1< double >::global(), GFCAST( &StochSpikeGen::getPr ), RFCAST( &StochSpikeGen::setPr ), "Release probability." ), }; static string doc[] = { "Name", "StochSpikeGen", "Author", "Subhasis Ray", "Description", "StochSpikeGen object, is a generalization of SpikeGen object " "where it transmits a spike with a release probability specified by " "Pr (=0.95 by default)." }; static Cinfo stochSpikeGenCinfo( doc, sizeof( doc ) / sizeof( string ), initSpikeGenCinfo(), stochSpikeGenFinfos, sizeof( stochSpikeGenFinfos ) / sizeof( Finfo* ), ValueFtype1< StochSpikeGen >::global()); return &stochSpikeGenCinfo; }
Finfo* initCaConcZombieFinfo() { static Finfo* caconcFields[] = { new ValueFinfo( "Ca", ValueFtype1< double >::global(), GFCAST( &HSolveHub::getCa ), RFCAST( &HSolveHub::setCa ) ), }; static const ThisFinfo* tf = dynamic_cast< const ThisFinfo* >( initCaConcCinfo()->getThisFinfo() ); assert( tf != 0 ); static SolveFinfo caconcZombieFinfo( caconcFields, sizeof( caconcFields ) / sizeof( Finfo* ), tf ); return &caconcZombieFinfo; }
Finfo* initHHChannelZombieFinfo() { static Finfo* hhchannelFields[] = { new ValueFinfo( "Gbar", ValueFtype1< double >::global(), GFCAST( &HSolveHub::getHHChannelGbar ), RFCAST( &HSolveHub::setHHChannelGbar ) ), new ValueFinfo( "Ek", ValueFtype1< double >::global(), GFCAST( &HSolveHub::getEk ), RFCAST( &HSolveHub::setEk ) ), new ValueFinfo( "Gk", ValueFtype1< double >::global(), GFCAST( &HSolveHub::getGk ), RFCAST( &HSolveHub::setGk ) ), new ValueFinfo( "Ik", ValueFtype1< double >::global(), GFCAST( &HSolveHub::getIk ), &dummyFunc ), new ValueFinfo( "X", ValueFtype1< double >::global(), GFCAST( &HSolveHub::getX ), RFCAST( &HSolveHub::setX ) ), new ValueFinfo( "Y", ValueFtype1< double >::global(), GFCAST( &HSolveHub::getY ), RFCAST( &HSolveHub::setY ) ), new ValueFinfo( "Z", ValueFtype1< double >::global(), GFCAST( &HSolveHub::getZ ), RFCAST( &HSolveHub::setZ ) ), }; static const ThisFinfo* tf = dynamic_cast< const ThisFinfo* >( initHHChannelCinfo()->getThisFinfo() ); assert( tf != 0 ); static SolveFinfo hhchannelZombieFinfo( hhchannelFields, sizeof( hhchannelFields ) / sizeof( Finfo* ), tf ); return &hhchannelZombieFinfo; }
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; }
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* 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* initGssaStoichCinfo() { static Finfo* processShared[] = { new DestFinfo( "process", Ftype1< ProcInfo >::global(), RFCAST( &GssaStoich::processFunc )), new DestFinfo( "reinit", Ftype1< ProcInfo >::global(), RFCAST( &GssaStoich::reinitFunc )), }; static Finfo* process = new SharedFinfo( "process", processShared, sizeof( processShared ) / sizeof( Finfo* ) ); //These are the fields of the stoich class static Finfo* gssaStoichFinfos[] = { /////////////////////////////////////////////////////// // Field definitions /////////////////////////////////////////////////////// new ValueFinfo( "method", ValueFtype1< string >::global(), GFCAST( &GssaStoich::getMethod ), RFCAST( &GssaStoich::setMethod ) ), /* * Inherited. Get rid of after testing. new ValueFinfo( "path", ValueFtype1< string >::global(), GFCAST( &GssaStoich::getPath ), RFCAST( &GssaStoich::setPath ) ), */ /////////////////////////////////////////////////////// // MsgSrc definitions /////////////////////////////////////////////////////// /////////////////////////////////////////////////////// // MsgDest definitions /////////////////////////////////////////////////////// /////////////////////////////////////////////////////// // Shared definitions /////////////////////////////////////////////////////// /* new SharedFinfo( "integrate", integrateShared, sizeof( integrateShared )/ sizeof( Finfo* ) ), new SharedFinfo( "gssa", gssaShared, sizeof( gssaShared )/ sizeof( Finfo* ) ), */ process, }; static SchedInfo schedInfo[] = { { process, 0, 0 } }; static string doc[] = { "Name", "GssaStoich", "Author", "Upinder S. Bhalla, 2008, NCBS", "Description", "GssaStoich: Gillespie Stochastic Simulation Algorithm object.Closely based on the " "Stoich object and inherits its handling functions for constructing the matrix. Sets up " "stoichiometry matrix based calculations from a\nwildcard path for the reaction system.Knows how to " "compute derivatives for most common things, also knows how to handle special cases where the object " "will have to do its own computation.Generates a stoichiometry matrix, which is useful for lots of " "other operations as well.", }; static Cinfo gssaStoichCinfo( doc, sizeof( doc ) / sizeof( string ), initStoichCinfo(), gssaStoichFinfos, sizeof( gssaStoichFinfos )/sizeof(Finfo *), ValueFtype1< GssaStoich >::global(), schedInfo, 1 ); return &gssaStoichCinfo; }
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* 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* initKinSynChanCinfo() { static Finfo* KinSynChanFinfos[] = { new ValueFinfo("rInf", ValueFtype1< double >::global(), GFCAST(&KinSynChan::getRinf), RFCAST(&KinSynChan::setRinf), "The fraction of bound receptors at steady state."), new ValueFinfo( "tau1", ValueFtype1< double >::global(), GFCAST( &SynChan::getTau1 ), RFCAST( &SynChan::setTau1 ), "Decay time constant for the synaptic conductance. This corresponds to 1/beta in [Destexhe, Mainen and Sejnowski, 1994]. You can set this tau1 or rInf, one deciding the value of the other." ), // new ValueFinfo( "tau2", ValueFtype1< double >::global(), // GFCAST( &KinSynChan::getTau2 ), // RFCAST( &KinSynChan::setTau2 ), // "Rise time constant for the synaptic conductance. It is calculated using rInf and tau1 [See: Destexhe, Mainen and Sejnowski, 1994. It corresponds to tau_r in that paper]." // ), // new ValueFinfo( "tauR", ValueFtype1< double >::global(), // GFCAST( &SynChan::getTau2 ), // RFCAST( &SynChan::setTau2 ), // "Rise time constant for the synaptic conductance. It is calculated using rInf and tau1 [See: Destexhe, Mainen and Sejnowski, 1994. It corresponds to tau_r in that paper.]" // ), new ValueFinfo( "pulseWidth", ValueFtype1< double >::global(), GFCAST( &KinSynChan::getPulseWidth ), RFCAST( &KinSynChan::setPulseWidth ), "The duration of the neuroTransmitter pulse. [See: Destexhe, Mainen and Sejnowski, 1994. It corresponds to t1 in that paper.]" ), /////////////////////////////////////////////////////// // MsgSrc definitions /////////////////////////////////////////////////////// /////////////////////////////////////////////////////// // MsgDest definitions /////////////////////////////////////////////////////// }; static string doc[] = { "Name", "KinSynChan", "Author", "Aditya Gilra and Subhasis Ray, 2010, NCBS", "Description", "KinSynChan: Synaptic channel incorporating kinetic model of receptor binding. " "From Destexhe, Mainen and Sejnowski, 1994" "Handles saturation of synapse. Incorporates weight and delay. Does not " "handle activity-dependent modification, see HebbSynChan for that. " }; static Cinfo KinSynChanCinfo( doc, sizeof( doc ) / sizeof( string ), initSynChanCinfo(), KinSynChanFinfos, sizeof( KinSynChanFinfos )/sizeof(Finfo *), ValueFtype1< KinSynChan >::global()); return &KinSynChanCinfo; }
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* 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* 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* 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; }