function=pnl.FitzHughNagumoIntegrator(
name='FitzHughNagumoIntegrator Function-0',
d_v=1,
initial_v=-1,
initializer=[[0]],
default_variable=[[0]]))
im = pnl.IntegratorMechanism(name='im',
function=pnl.AdaptiveIntegrator(
initializer=[[0]],
rate=0.5,
default_variable=[[0]]))
comp.add_node(fn)
comp.add_node(im)
comp.add_projection(projection=pnl.MappingProjection(
name='MappingProjection from fn[OutputPort-0] to im[InputPort-0]',
function=pnl.LinearMatrix(matrix=[[1.0]], default_variable=[-1.0])),
sender=fn,
receiver=im)
comp.scheduler.add_condition(fn, pnl.Always())
comp.scheduler.add_condition(
im, pnl.All(pnl.EveryNCalls(fn, 20.0), pnl.AfterNCalls(fn, 1600.0)))
comp.scheduler.termination_conds = {
pnl.TimeScale.RUN: pnl.Never(),
pnl.TimeScale.TRIAL: pnl.AfterNCalls(fn, 2000)
}
comp.show_graph()
import psyneulink as pnl
comp = pnl.Composition(name='comp')
A = pnl.TransferMechanism(name='A')
B = pnl.TransferMechanism(name='B')
C = pnl.TransferMechanism(name='C')
comp.add_linear_processing_pathway([A, B, C])
comp.scheduler.add_condition_set({
A: pnl.AtNCalls(A, 0),
B: pnl.Always(),
C: pnl.EveryNCalls(B, 5),
})
comp.run(inputs={A: 1})
# A, B, B, B, B, B, C
print(comp.scheduler.execution_list[comp.default_execution_id])
with open(__file__.replace('.py', '.json'), 'w') as f:
f.write(comp.json_summary + '\n')
time_step_size=time_step_size,
)
print('Running simple model of FitzHugh Nagumo cell for %sms: %s' %
(simtime, fhn))
fn = pnl.IntegratorMechanism(name='fn', function=fhn)
comp = pnl.Composition(name='comp')
im = pnl.IntegratorMechanism(name='im') # only used to demonstrate conditions
comp.add_linear_processing_pathway([fn, im])
comp.scheduler.add_condition_set({
fn:
pnl.Always(), # default
im:
pnl.All( # run when both conditions are met
pnl.EveryNCalls(fn, 1 / dt), # every 1ms, based on fn frequency
pnl.AfterNCalls(fn,
.8 * simtime / dt) # after 80ms, based on fn frequency
)
})
comp.termination_processing = {
pnl.TimeScale.RUN: pnl.Never(
), # default, "Never" for early termination - ends when all trials finished
pnl.TimeScale.TRIAL: pnl.AfterNCalls(fn, int(simtime / dt))
}
print('Running the SimpleFN model...')
)
ABCD.add_projection(
projection=pnl.MappingProjection(
name="MappingProjection_from_A_RESULT__to_C_InputPort_0_",
function=pnl.LinearMatrix(default_variable=[2.0], matrix=[[1.0]]),
),
sender=A,
receiver=C,
)
ABCD.add_projection(
projection=pnl.MappingProjection(
name="MappingProjection_from_C_RESULT__to_D_InputPort_0_",
function=pnl.LinearMatrix(default_variable=[1.0], matrix=[[1.0]]),
),
sender=C,
receiver=D,
)
ABCD.scheduler.add_condition(A, pnl.Always())
ABCD.scheduler.add_condition(C, pnl.EveryNCalls(dependency=A, n=1))
ABCD.scheduler.add_condition(B, pnl.EveryNCalls(dependency=A, n=1))
ABCD.scheduler.add_condition(
D,
pnl.All(pnl.EveryNCalls(dependency=C, n=1),
pnl.EveryNCalls(dependency=B, n=1)))
ABCD.scheduler.termination_conds = {
pnl.TimeScale.ENVIRONMENT_SEQUENCE: pnl.Never(),
pnl.TimeScale.ENVIRONMENT_STATE_UPDATE: pnl.AllHaveRun(),
}
