def __init__(self, parameters, output_layer=None, fileobj=None):
import py_paddle.swig_paddle as api
if output_layer is not None:
topo = topology.Topology(output_layer)
gm = api.GradientMachine.createFromConfigProto(
topo.proto(), api.CREATE_MODE_TESTING, [api.PARAMETER_VALUE])
self.__data_types__ = topo.data_type()
elif fileobj is not None:
tmp = cPickle.load(fileobj)
gm = api.GradientMachine.createByConfigProtoStr(
tmp['protobin'], api.CREATE_MODE_TESTING,
[api.PARAMETER_VALUE])
self.__data_types__ = tmp['data_type']
else:
raise ValueError("Either output_layer or fileobj must be set")
for param in gm.getParameters():
val = param.getBuf(api.PARAMETER_VALUE)
name = param.getName()
assert isinstance(val, api.Vector)
val.copyFromNumpyArray(parameters.get(name).flatten())
# the setValueUpdated function is called in randomize, zeroMem,
# load function in paddle/parameter/Parameter.cpp. But in the
# inference mode, the setValueUpdated is never called, it will
# cause the parameter will not be dispatched
# in MultiGradientMachine for multi-GPU. So setValueUpdated is
# called here, but it's better to call this function in one place.
param.setValueUpdated()
self.__gradient_machine__ = gm
def start_simulation(self):
self.topology = topology.Topology(self.adversary, self,
self.topology_model,
self.guard_lifetime_type)
# Handle node compromises here so that we can handle early Sybils.
self.topology.handle_node_compromises()
def getTopology(topologyFileName):
TOPOLOGY_FILE_NAME = "topology_20.txt"
topo = topology.Topology()
try:
topo.importFromFile(TOPOLOGY_FILE_NAME)
except:
print "could not read topology file", TOPOLOGY_FILE_NAME
return topo
def __init__(self, output_layer, parameters):
topo = topology.Topology(output_layer)
gm = api.GradientMachine.createFromConfigProto(
topo.proto(), api.CREATE_MODE_TESTING, [api.PARAMETER_VALUE])
for param in gm.getParameters():
val = param.getBuf(api.PARAMETER_VALUE)
name = param.getName()
assert isinstance(val, api.Vector)
val.copyFromNumpyArray(parameters.get(name).flatten())
self.__gradient_machine__ = gm
self.__data_types__ = topo.data_type()
def __init__(
self,
name="",
h=1,
N=25,
m=14,
topology=tp.Topology(name="AT_System"),
):
self.name = name
self.topology = topology
self.h = h
self.N = N
self.m = m
self.z = np.empty((M, M, N), np.complex128)
def test(self):
import topology
t = topology.Topology()
v0 = topology.Vertex(t)
v1 = topology.Vertex(t)
v2 = topology.Vertex(t)
v3 = topology.Vertex(t)
assert (v0.block.index is None)
assert (v1.block.index is None)
assert (v2.block.index is None)
assert (v3.block.index is None)
v1.block.index = 1
assert (v1.block.leftBlock is None)
assert (v1.block.rightBlock is None)
v3.block.index = 3
assert (v1.block.leftBlock is None)
assert (v1.block.rightBlock == v3.block)
assert (v3.block.leftBlock == v1.block)
assert (v3.block.rightBlock is None)
v2.block.index = 0
assert (v1.block.leftBlock == v2.block)
assert (v1.block.rightBlock == v3.block)
assert (v2.block.leftBlock is None)
assert (v2.block.rightBlock == v1.block)
assert (v3.block.leftBlock == v1.block)
assert (v3.block.rightBlock is None)
v2.block.index = 2
assert (v1.block.leftBlock is None)
assert (v1.block.rightBlock == v2.block)
assert (v2.block.leftBlock == v1.block)
assert (v2.block.rightBlock == v3.block)
assert (v3.block.leftBlock == v2.block)
assert (v3.block.rightBlock is None)
v0.block.index = 0
assert (v0.block.leftBlock is None)
assert (v0.block.rightBlock == v1.block)
assert (v1.block.leftBlock == v0.block)
assert (v1.block.rightBlock == v2.block)
assert (v2.block.leftBlock == v1.block)
assert (v2.block.rightBlock == v3.block)
assert (v3.block.leftBlock == v2.block)
assert (v3.block.rightBlock is None)
def parser(filename=None):
"""
Function created for parsing init file.
In init file are written agents and their
initial states of energy, as well as deltat (this
is discrete time : how often energies are updated).
:param: filename : str (name of the init file)
:return: topology.Topology() class instance
"""
if filename is None:
filename = os.path.join(os.getcwd(), "..", "init_files", "init.txt")
else:
filename = os.path.join(os.getcwd(), "..", "init_files", filename)
with open(filename, "r") as init:
agents = []
for line in init:
line.rstrip(os.linesep)
if "deltat" in line:
deltat = float(line.split(":")[-1])
else:
agent, data = line.split(":")
energy, x, y = data.split(",")
energy = float(energy)
x = float(x)
y = float(y)
if agent == "amussel":
new_mussel = data_structures.aMussel(energy)
new_mussel.coordinates = (x, y)
agents.append(new_mussel)
elif agent == "apad":
new_apad = data_structures.aPad(energy)
new_apad.coordinates = (x, y)
agents.append(new_apad)
system = topology.Topology()
system.all_agents = agents
system.mussels = [agent for agent in agents if isinstance(agent, data_structures.aMussel)]
system.pads = [agent for agent in agents if isinstance(agent, data_structures.aPad)]
system.deltat = deltat
return system
def test():
topo = topology.Topology()
node1 = topology.Node("1")
node2 = topology.Node("2")
node3 = topology.Node("3")
node4 = topology.Node("4")
node5 = topology.Node("5")
node6 = topology.Node("6")
edge1 = topology.Edge(node1, node2)
edge2 = topology.Edge(node3, node2)
edge3 = topology.Edge(node4, node2)
edge4 = topology.Edge(node4, node5)
edge5 = topology.Edge(node2, node6)
edge6 = topology.Edge(node5, node1)
topo.addNode(node1)
topo.addNode(node2)
topo.addNode(node3)
topo.addNode(node4)
topo.addNode(node5)
topo.addNode(node6)
topo.addEdge(edge1)
topo.addEdge(edge2)
topo.addEdge(edge3)
topo.addEdge(edge4)
topo.addEdge(edge5)
topo.addEdge(edge6)
#print topo.edges
intmat = topo.getInterconnectivityMatrix()
print intmat
#topo.exportToFile("topology.txt")
print "=============="
print "importing topology_20.txt file"
topo.importFromFile("topology_20.txt")
print topo.getInterconnectivityMatrix()
def testDivisonOfGrid():
topo = topology.Topology()
topoFile = "topology_200.txt"
try:
topo.importFromFile(topoFile)
except:
print "could not read topology file", topoFile
habNM = simulation.makeNeighConnMap(topo)
sects = simulation.divideGridToSection(habNM, GRID_SIZE, GRID_SIZE)
print "sects ", sects
k = 0
for habs in sects.values():
k = k + 1
X = pylab.ones((10, 10, 3)) * float(k * 0.4)
print "habs", habs
for hab in habs:
hab = hab - 1
xo = int(hab % GRID_SIZE) * 2
yo = int(hab / GRID_SIZE) * 2
print "X ", xo
print "Y ", yo
plt.figimage(X, xo, yo, origin='lower')
plt.show()
# S1 ---- S2
# / | \ |
# H1 H2 H3 H4
#
import topology, switch, host, port
topo = topology.Topology()
s1 = switch.Switch("s1")
topo.addSwitch(s1)
s2 = switch.Switch("s2")
topo.addSwitch(s2)
s3 = switch.Switch("s3")
topo.addSwitch(s3)
#s3.chassi=100
s4 = switch.Switch("s4")
topo.addSwitch(s4)
h1 = host.Host('h1')
h1.addPort(port.Port('AA:AA:AA:CC:CC:CC'))
h1.addPort(port.Port('AA:AA:AA:AC:CC:CC'))
h2 = host.Host('h2')
h2.addPort(port.Port('AA:AA:AA:CC:CC:CD'))
h3 = host.Host('h3')
h3.addPort(port.Port('AA:AA:AA:CC:CC:CE'))
def test():
logWriter = csv.writer(open(OUTPUT_FILE_NAME + ".csv", 'w'),
delimiter='\t',
quotechar='|',
quoting=csv.QUOTE_MINIMAL)
topo = topology.Topology()
topoFile = "topology_200.txt"
try:
topo.importFromFile(topoFile)
except:
print "could not read topology file", topoFile
habitatNeighMap = {}
for edge in topo.getInterconnMatInt():
if edge[0] not in habitatNeighMap:
habitatNeighMap[edge[0]] = []
if edge[1] not in habitatNeighMap[edge[0]]:
habitatNeighMap[edge[0]].append(edge[1])
if edge[1] not in habitatNeighMap:
habitatNeighMap[edge[1]] = []
if edge[0] not in habitatNeighMap[edge[1]]:
habitatNeighMap[edge[1]].append(edge[0])
habitatids = [int(node.label) for node in topo.nodes]
#print habitatids
#print habitatNeighMap
#print topo.getInterconnMatInt()
exit()
sim = simulation.Simulation(habitatNeighMap)
print "============"
#print "Diversity for 1. , 2. , 3. , ",sim.getNextDiversity(), sim.getNextDiversity(), sim.getNextDiversity()
print " diversity for cell i=0, j=0", sim.getNextDiversity(0, 0)
print " diversity for cell i=10, j=10", sim.getNextDiversity(10, 10)
print " diversity for cell i=20, j=20", sim.getNextDiversity(20, 20)
#print "selected habitat %d from %s"(habitat.id,str(neighbors))
print "============"
agents = sim.createAgents(20)
print "============"
print "agents strategy"
for agent in agents:
print agent.strategy
print "============"
sfdmat = []
for i in range(200):
sfdmat.append([])
for j in range(200):
sfdmat[i].append(sim.getNextDiversity())
habitats = sim.createHabitats(200, 200, sfdmat, 10, habitatids)
habitat = habitats[1]
neighbors = [habitats[x] for x in habitatNeighMap[habitat.id]]
print "============"
neighborids = [neigh.id for neigh in neighbors]
print "habitat id", habitat.id
print "neighbors ", neighborids
aneigh = sim.selectANeighborHabitat(habitat, neighbors)
print "selected habitat", aneigh
aneigh = sim.selectANeighborHabitat(habitat, neighbors)
print "selected habitat", aneigh
aneigh = sim.selectANeighborHabitat(habitat, neighbors)
print "selected habitat", aneigh
aneigh = sim.selectANeighborHabitat(habitat, neighbors)
print "selected habitat", aneigh
print "============"
prob = []
totalDegree = float(habitat.totalOutDegree)
prob.append(float(habitat.agents[0].outdegree) / totalDegree)
for i in range(1, len(habitat.agents)):
prob.append(prob[i - 1] +
float(habitat.agents[i].outdegree) / totalDegree)
print " outdegree of agents"
for agent in habitat.agents:
print agent.outdegree
for ed in habitat.intmat:
print ed
print prob
sel = sim.selectProb(habitat.agentnum, prob)
print "selected id", sel
print "============"
print " agents number, coop num, def num ", habitat.agentnum, habitat.coopnum, habitat.defnum
print "after adding a agent to habitat ;id ,strategy", agents[
0].id, agents[0].strategy
sim.addAgentIntoHabitat(agents[0], habitat, 10)
print "intmat ", habitat.intmat
ids = [agent.id for agent in habitat.agents]
print "agents", ids
print " agents number, coop num, def num ", habitat.agentnum, habitat.coopnum, habitat.defnum
print "============"
print "after removing a agent to habitat ;id ,strategy", habitat.agents[
0].id, habitat.agents[0].strategy
sim.removeAgentFromHabitat(habitat.agents[0], habitat)
print "intmat ", habitat.intmat
ids = [agent.id for agent in habitat.agents]
print "agents", ids
print " agents number, coop num, def num ", habitat.agentnum, habitat.coopnum, habitat.defnum
print "after removing a agent to habitat ;id ,strategy", habitat.agents[
1].id, habitat.agents[1].strategy
sim.removeAgentFromHabitat(habitat.agents[1], habitat)
print "intmat ", habitat.intmat
ids = [agent.id for agent in habitat.agents]
print "agents", ids
print " agents number, coop num, def num ", habitat.agentnum, habitat.coopnum, habitat.defnum
print "after removing a agent to habitat ;id ,strategy", habitat.agents[
3].id, habitat.agents[3].strategy
sim.removeAgentFromHabitat(habitat.agents[3], habitat)
print "intmat ", habitat.intmat
ids = [agent.id for agent in habitat.agents]
print "agents", ids
print " agents number, coop num, def num ", habitat.agentnum, habitat.coopnum, habitat.defnum
sim.createRandomEdge(len(agents), agents, habitats[1].agents[1], prob,
totalDegree)
#for k,hab in habitats.items():
# print hab.agentnum
sim.startSimulation(logWriter)
def worker(stimulus, stimulus_type):
# Neuron imports hoc and does a nrn = hoc.HocObject()
nrn = neuron.h
# To avoid Neuron displaying messages
copystdout = sys.stdout
# Print info of process
print("Rank = %s, Stimulus = %s, Experiment = %s" %
(rank, stimulus, stimulus_type))
comb = 0
for stim in stimulus:
# Reset PSTHs
PST_IN_ON = np.zeros((int(N * N * INratio), int(tsim / binsize)))
PST_IN_OFF = np.zeros((int(N * N * INratio), int(tsim / binsize)))
PST_RC_ON = np.zeros((int(N * N), int(tsim / binsize)))
PST_RC_OFF = np.zeros((int(N * N), int(tsim / binsize)))
PST_CXPY_h_ON = np.zeros((int(N * N), int(tsim / binsize)))
PST_CXPY_v_ON = np.zeros((int(N * N), int(tsim / binsize)))
PST_CXPY_h_OFF = np.zeros((int(N * N), int(tsim / binsize)))
PST_CXPY_v_OFF = np.zeros((int(N * N), int(tsim / binsize)))
for trial in np.arange(0, numbertrials):
# Remove all sections and set temperature
nrn("forall delete_section()")
nrn.celsius = 36.0
# To avoid Neuron displaying messages
f = open('/dev/null', 'w')
sys.stdout = f
# Simulation and topology modules
sim = simulation.Simulation()
tp = topology.Topology()
# Reset spike counters
spikes_IN_ON = []
spikes_IN_OFF = []
spikes_RC_ON = []
spikes_RC_OFF = []
spikes_CXPY_h_ON = []
spikes_CXPY_v_ON = []
spikes_CXPY_h_OFF = []
spikes_CXPY_v_OFF = []
# to store Neuron cells
NEURON_cells_to_sim = []
# to remember positions of IN's dendrites
IN_dend_dict = np.zeros([int(N * N), 2], dtype=int)
#################################
### Creation of neuron models ###
#################################
#### Retina ####
retina = ganglionCell.Retina()
spikes_ON = retina.loadSpikes(stim, trial, N, type_ret + "/ON")
spikes_OFF = retina.loadSpikes(stim, trial, N, type_ret + "/OFF")
### Interneuron ###
INs_ON = []
INs_OFF = []
template1 = interneuron.InterneuronTemplate()
n = 0
for x in np.arange(0, N * np.sqrt(INratio)):
for y in np.arange(0, N * np.sqrt(INratio)):
INs_ON.append(template1.return_cell())
NEURON_cells_to_sim.append(INs_ON[n])
INs_OFF.append(template1.return_cell())
NEURON_cells_to_sim.append(INs_OFF[n])
INs_ON[n].tstop = tsim
INs_ON[n].tstart = 0.0
INs_ON[n].dt = dt
INs_ON[n].dt = dt
INs_OFF[n].tstop = tsim
INs_OFF[n].tstart = 0.0
INs_OFF[n].dt = dt
INs_OFF[n].dt = dt
# spike counter
for sec in INs_ON[n].allseclist:
soma = sec
break
# exec( 'apc_IN_ON%s = nrn.APCount(INs_ON[n].soma(0.5))' % n)
exec('apc_IN_ON%s = nrn.APCount(soma(0.5))' % n)
exec('apc_IN_ON%s.thresh = -10.0' % n)
exec('apc_IN_count_ON%s = nrn.Vector(1)' % n)
exec('apc_IN_ON%s.record(apc_IN_count_ON%s)' % (n, n))
exec('spikes_IN_ON.append(apc_IN_count_ON%s)' % n)
for sec in INs_OFF[n].allseclist:
soma = sec
break
# exec( 'apc_IN_OFF%s = nrn.APCount(INs_OFF[n].cell.soma(0.5))' % n)
exec('apc_IN_OFF%s = nrn.APCount(soma(0.5))' % n)
exec('apc_IN_OFF%s.thresh = -10.0' % n)
exec('apc_IN_count_OFF%s = nrn.Vector(1)' % n)
exec('apc_IN_OFF%s.record(apc_IN_count_OFF%s)' % (n, n))
exec('spikes_IN_OFF.append(apc_IN_count_OFF%s)' % n)
syns = tp.fitSquare(
N, IN_RC_mask,
int(x / np.sqrt(INratio)) * N +
int(y / np.sqrt(INratio)))
# Retina inputs
count = 0
for sn in syns:
template1.createSynapse(INs_ON[n],
syn_comps_dist[count], True,
np.array(spikes_ON[int(sn)]))
template1.createSynapse(INs_ON[n],
syn_comps_prox[count], False,
np.array(spikes_ON[int(sn)]))
template1.createSynapse(INs_OFF[n],
syn_comps_dist[count], True,
np.array(spikes_OFF[int(sn)]))
template1.createSynapse(INs_OFF[n],
syn_comps_prox[count], False,
np.array(spikes_OFF[int(sn)]))
# Keep position of dendrite and corresponding IN
IN_dend_dict[int(sn), :] = [n, count]
count += 1
n += 1
#### Relay cell ####
RCs_ON = []
RCs_OFF = []
template2 = relayCell.RCTemplate()
n = 0
for x in np.arange(0, N):
for y in np.arange(0, N):
RCs_ON.append(template2.return_cell())
NEURON_cells_to_sim.append(RCs_ON[n])
RCs_OFF.append(template2.return_cell())
NEURON_cells_to_sim.append(RCs_OFF[n])
RCs_ON[n].tstop = tsim
RCs_ON[n].tstart = 0.0
RCs_ON[n].dt = dt
RCs_ON[n].dt = dt
RCs_OFF[n].tstop = tsim
RCs_OFF[n].tstart = 0.0
RCs_OFF[n].dt = dt
RCs_OFF[n].dt = dt
# spike counter
for sec in RCs_ON[n].allseclist:
soma = sec
break
# exec( 'apc_RC_ON%s = nrn.APCount(RCs_ON[n].cell.soma[0](0.5))' % n)
exec('apc_RC_ON%s = nrn.APCount(soma(0.5))' % n)
exec('apc_RC_ON%s.thresh = -10.0' % n)
exec('apc_RC_count_ON%s = nrn.Vector(1)' % n)
exec('apc_RC_ON%s.record(apc_RC_count_ON%s)' % (n, n))
exec('spikes_RC_ON.append(apc_RC_count_ON%s)' % n)
for sec in RCs_OFF[n].allseclist:
soma = sec
break
# exec( 'apc_RC_OFF%s = nrn.APCount(RCs_OFF[n].cell.soma[0](0.5))' % n)
exec('apc_RC_OFF%s = nrn.APCount(soma(0.5))' % n)
exec('apc_RC_OFF%s.thresh = -10.0' % n)
exec('apc_RC_count_OFF%s = nrn.Vector(1)' % n)
exec('apc_RC_OFF%s.record(apc_RC_count_OFF%s)' % (n, n))
exec('spikes_RC_OFF.append(apc_RC_count_OFF%s)' % n)
# Retina inputs
template2.createSynapse(RCs_ON[n], 0, False,
np.array(spikes_ON[n]), 1.0)
template2.createSynapse(RCs_OFF[n], 0, False,
np.array(spikes_OFF[n]), 1.0)
n += 1
#### Cortical pyramidal cell ####
PYs_h_ON = []
PYs_v_ON = []
PYs_h_OFF = []
PYs_v_OFF = []
template3 = cortex_PY.CorticalPyramidalTemplate()
n = 0
for x in np.arange(0, N):
for y in np.arange(0, N):
PYs_h_ON.append(template3.return_cell())
PYs_v_ON.append(template3.return_cell())
NEURON_cells_to_sim.append(PYs_h_ON[n])
NEURON_cells_to_sim.append(PYs_v_ON[n])
PYs_h_OFF.append(template3.return_cell())
PYs_v_OFF.append(template3.return_cell())
NEURON_cells_to_sim.append(PYs_h_OFF[n])
NEURON_cells_to_sim.append(PYs_v_OFF[n])
PYs_h_ON[n].tstop = tsim
PYs_h_ON[n].tstart = 0.0
PYs_h_ON[n].dt = dt
PYs_h_ON[n].dt = dt
PYs_v_ON[n].tstop = tsim
PYs_v_ON[n].tstart = 0.0
PYs_v_ON[n].dt = dt
PYs_v_ON[n].dt = dt
PYs_h_OFF[n].tstop = tsim
PYs_h_OFF[n].tstart = 0.0
PYs_h_OFF[n].dt = dt
PYs_h_OFF[n].dt = dt
PYs_v_OFF[n].tstop = tsim
PYs_v_OFF[n].tstart = 0.0
PYs_v_OFF[n].dt = dt
PYs_v_OFF[n].dt = dt
# spike counter
for sec in PYs_h_ON[n].allseclist:
soma = sec
break
# exec( 'apc_PYs_h_ON%s = nrn.APCount(PYs_h_ON[n].cell.soma[0](0.5))' % n)
exec('apc_PYs_h_ON%s = nrn.APCount(soma(0.5))' % n)
exec('apc_PYs_h_ON%s.thresh = -10.0' % n)
exec('apc_PYs_h_count_ON%s = nrn.Vector(1)' % n)
exec('apc_PYs_h_ON%s.record(apc_PYs_h_count_ON%s)' %
(n, n))
exec('spikes_CXPY_h_ON.append(apc_PYs_h_count_ON%s)' % n)
for sec in PYs_v_ON[n].allseclist:
soma = sec
break
# exec( 'apc_PYs_v_ON%s = nrn.APCount(PYs_v_ON[n].cell.soma[0](0.5))' % n)
exec('apc_PYs_v_ON%s = nrn.APCount(soma(0.5))' % n)
exec('apc_PYs_v_ON%s.thresh = -10.0' % n)
exec('apc_PYs_v_count_ON%s = nrn.Vector(1)' % n)
exec('apc_PYs_v_ON%s.record(apc_PYs_v_count_ON%s)' %
(n, n))
exec('spikes_CXPY_v_ON.append(apc_PYs_v_count_ON%s)' % n)
for sec in PYs_h_OFF[n].allseclist:
soma = sec
break
# exec( 'apc_PYs_h_OFF%s = nrn.APCount(PYs_h_OFF[n].cell.soma[0](0.5))' % n)
exec('apc_PYs_h_OFF%s = nrn.APCount(soma(0.5))' % n)
exec('apc_PYs_h_OFF%s.thresh = -10.0' % n)
exec('apc_PYs_h_count_OFF%s = nrn.Vector(1)' % n)
exec('apc_PYs_h_OFF%s.record(apc_PYs_h_count_OFF%s)' %
(n, n))
exec('spikes_CXPY_h_OFF.append(apc_PYs_h_count_OFF%s)' % n)
for sec in PYs_v_OFF[n].allseclist:
soma = sec
break
# exec( 'apc_PYs_v_OFF%s = nrn.APCount(PYs_v_OFF[n].cell.soma[0](0.5))' % n)
exec('apc_PYs_v_OFF%s = nrn.APCount(soma(0.5))' % n)
exec('apc_PYs_v_OFF%s.thresh = -10.0' % n)
exec('apc_PYs_v_count_OFF%s = nrn.Vector(1)' % n)
exec('apc_PYs_v_OFF%s.record(apc_PYs_v_count_OFF%s)' %
(n, n))
exec('spikes_CXPY_v_OFF.append(apc_PYs_v_count_OFF%s)' % n)
n += 1
############################
### Synaptic connections ###
############################
general_counter = 0
#### Interneuron -> RC connection
n = 0
for x in np.arange(0, N * np.sqrt(INratio)):
for y in np.arange(0, N * np.sqrt(INratio)):
syns = tp.fitSquare(
N, IN_RC_mask,
int(x / np.sqrt(INratio)) * N +
int(y / np.sqrt(INratio)))
# print(syns)
# tp.showConn(N,syns)
count = 0
for sn in syns:
# triadic synapse
exec(
'syn_ON%s = template2.triadSynapse(RCs_ON[int(sn)])'
% str(general_counter))
exec( 'netcon_ON%s = template1.triadCon(cell=INs_ON[n], syn=syn_ON%s, '\
'syn_loc=syn_comps_dist[count])' % (str(general_counter),str(general_counter)))
# soma connection
exec(
'syn_ON%s = template2.somaInhibition(RCs_ON[int(sn)])'
% str(general_counter + 1))
exec( 'netcon_ON%s = template1.somaCon(cell=INs_ON[n], '\
'syn=syn_ON%s)' % (str(general_counter+1),str(general_counter+1)))
# triadic synapse
exec(
'syn_OFF%s = template2.triadSynapse(RCs_OFF[int(sn)])'
% str(general_counter))
exec( 'netcon_OFF%s = template1.triadCon(cell=INs_OFF[n], syn=syn_OFF%s, '\
'syn_loc=syn_comps_dist[count])' % (str(general_counter),str(general_counter)))
# soma connection
exec(
'syn_OFF%s = template2.somaInhibition(RCs_OFF[int(sn)])'
% str(general_counter + 1))
exec( 'netcon_OFF%s = template1.somaCon(cell=INs_OFF[n], '\
'syn=syn_OFF%s)' % (str(general_counter+1),str(general_counter+1)))
count += 1
general_counter += 2
n += 1
#### RC connection -> PY cells (Receptive-field center)
n = 0
for x in np.arange(0, N):
for y in np.arange(0, N):
synsh = tp.rectMask(N, RC_PY_mask_h, n)
# print(synsh)
# tp.showConn(N,synsh)
count = 0
for sn in synsh:
exec('syn_ON%s = template3.TCConn(PYs_h_ON[int(n)])' %
str(general_counter))
exec( 'netcon_ON%s = template2.somaCon(cell=RCs_ON[int(sn)], '\
'syn=syn_ON%s,weight=0.05)' % (str(general_counter),str(general_counter)))
exec(
'syn_OFF%s = template3.TCConn(PYs_h_OFF[int(n)])' %
str(general_counter))
exec( 'netcon_OFF%s = template2.somaCon(cell=RCs_OFF[int(sn)], '\
'syn=syn_OFF%s,weight=0.05)' % (str(general_counter),str(general_counter)))
count += 1
general_counter += 1
synsv = tp.rectMask(N, RC_PY_mask_v, n)
# print(synsv)
# tp.showConn(N,synsv)
count = 0
for sn in synsv:
exec('syn_ON%s = template3.TCConn(PYs_v_ON[int(n)])' %
str(general_counter))
exec( 'netcon_ON%s = template2.somaCon(cell=RCs_ON[int(sn)], '\
'syn=syn_ON%s,weight=0.05)' % (str(general_counter),str(general_counter)))
exec(
'syn_OFF%s = template3.TCConn(PYs_v_OFF[int(n)])' %
str(general_counter))
exec( 'netcon_OFF%s = template2.somaCon(cell=RCs_OFF[int(sn)], '\
'syn=syn_OFF%s,weight=0.05)' % (str(general_counter),str(general_counter)))
count += 1
general_counter += 1
n += 1
#### RC connection -> PY cells (Receptive-field surround)
n = 0
for x in np.arange(0, N):
for y in np.arange(0, N):
synsh = tp.rectMask(N, RC_PY_s_mask_h, n + N)
# print(synsh)
# tp.showConn(N,synsh)
count = 0
for sn in synsh:
exec('syn_ON%s = template3.TCConn(PYs_h_OFF[int(n)])' %
str(general_counter))
exec( 'netcon_ON%s = template2.somaCon(cell=RCs_ON[int(sn)], '\
'syn=syn_ON%s,weight=0.02)' % (str(general_counter),str(general_counter)))
exec('syn_OFF%s = template3.TCConn(PYs_h_ON[int(n)])' %
str(general_counter))
exec( 'netcon_OFF%s = template2.somaCon(cell=RCs_OFF[int(sn)], '\
'syn=syn_OFF%s,weight=0.02)' % (str(general_counter),str(general_counter)))
count += 1
general_counter += 1
synsv = tp.rectMask(N, RC_PY_s_mask_v, n + 1)
# print(synsv)
# tp.showConn(N,synsv)
count = 0
for sn in synsv:
exec('syn_ON%s = template3.TCConn(PYs_v_OFF[int(n)])' %
str(general_counter))
exec( 'netcon_ON%s = template2.somaCon(cell=RCs_ON[int(sn)], '\
'syn=syn_ON%s,weight=0.02)' % (str(general_counter),str(general_counter)))
exec('syn_OFF%s = template3.TCConn(PYs_v_ON[int(n)])' %
str(general_counter))
exec( 'netcon_OFF%s = template2.somaCon(cell=RCs_OFF[int(sn)], '\
'syn=syn_OFF%s,weight=0.02)' % (str(general_counter),str(general_counter)))
count += 1
general_counter += 1
n += 1
#### Feedback: PY cells -> RC cells
if (feedback_type < 2):
n = 0
for x in np.arange(0, N):
for y in np.arange(0, N):
synRC = tp.rectMask(N, PY_RC_mask, n)
# print(synRC)
# tp.showConn(N,synRC)
count = 0
for sn in synRC:
## Phase-reversed feedback
if (feedback_type == 0):
exec(
'syn_ON%s = template2.somaExcitation(RCs_ON[int(sn)])'
% str(general_counter))
exec( 'netcon_ON%s = template3.somaCon(cell=PYs_h_OFF[int(n)], '\
'syn=syn_ON%s,weight=p1_ext[stimulus_type[comb]])'
% (str(general_counter),str(general_counter)))
exec(
'syn_ON%s = template2.somaExcitation(RCs_ON[int(sn)])'
% str(general_counter + 1))
exec( 'netcon_ON%s = template3.somaCon(cell=PYs_v_OFF[int(n)], '\
'syn=syn_ON%s,weight=p1_ext[stimulus_type[comb]])'
% (str(general_counter+1),str(general_counter+1)))
exec(
'syn_OFF%s = template2.somaExcitation(RCs_OFF[int(sn)])'
% str(general_counter))
exec(
'netcon_OFF%s = template3.somaCon(cell=PYs_h_ON[int(n)], '
'syn=syn_OFF%s,weight=p1_ext[stimulus_type[comb]])'
% (str(general_counter),
str(general_counter)))
exec(
'syn_OFF%s = template2.somaExcitation(RCs_OFF[int(sn)])'
% str(general_counter + 1))
exec( 'netcon_OFF%s = template3.somaCon(cell=PYs_v_ON[int(n)], '\
'syn=syn_OFF%s,weight=p1_ext[stimulus_type[comb]])'
% (str(general_counter+1),str(general_counter+1)))
## Phase-matched feedback
else:
exec(
'syn_ON%s = template2.somaExcitation(RCs_ON[int(sn)])'
% str(general_counter))
exec( 'netcon_ON%s = template3.somaCon(cell=PYs_h_ON[int(n)], '\
'syn=syn_ON%s,weight=p1_ext[stimulus_type[comb]])'
% (str(general_counter),str(general_counter)))
exec(
'syn_ON%s = template2.somaExcitation(RCs_ON[int(sn)])'
% str(general_counter + 1))
exec( 'netcon_ON%s = template3.somaCon(cell=PYs_v_ON[int(n)], '\
'syn=syn_ON%s,weight=p1_ext[stimulus_type[comb]])'
% (str(general_counter+1),str(general_counter+1)))
exec(
'syn_OFF%s = template2.somaExcitation(RCs_OFF[int(sn)])'
% str(general_counter))
exec( 'netcon_OFF%s = template3.somaCon(cell=PYs_h_OFF[int(n)], '\
'syn=syn_OFF%s,weight=p1_ext[stimulus_type[comb]])'
% (str(general_counter),str(general_counter)))
exec(
'syn_OFF%s = template2.somaExcitation(RCs_OFF[int(sn)])'
% str(general_counter + 1))
exec( 'netcon_OFF%s = template3.somaCon(cell=PYs_v_OFF[int(n)], '\
'syn=syn_OFF%s,weight=p1_ext[stimulus_type[comb]])'
% (str(general_counter+1),str(general_counter+1)))
count += 1
general_counter += 2
n += 1
#### Feedback: PY cells -> INs
if (feedback_type < 2):
n = 0
for x in np.arange(0, N):
for y in np.arange(0, N):
synRC = tp.rectMask(N, PY_RC_mask, n)
# print(synRC)
# tp.showConn(N,synRC)
for sn in synRC:
exec( 'synd_ON%s = template1.cortexCon(INs_ON[IN_dend_dict[sn,0]], '\
'syn_comps_int[IN_dend_dict[sn,1]])' % str(general_counter))
exec( 'netcon_ON%s = template3.somaCon(cell=PYs_h_ON[int(n)], '\
'syn=synd_ON%s,weight=p2_ext[stimulus_type[comb]])' % (str(general_counter),str(general_counter)))
exec( 'synd_ON%s = template1.cortexCon(INs_ON[IN_dend_dict[sn,0]], '\
'syn_comps_int[IN_dend_dict[sn,1]])' % str(general_counter+1))
exec( 'netcon_ON%s = template3.somaCon(cell=PYs_v_ON[int(n)], syn=synd_ON%s, '\
'weight=p2_ext[stimulus_type[comb]])' % (str(general_counter+2),str(general_counter+1)))
exec( 'synd_OFF%s = template1.cortexCon(INs_OFF[IN_dend_dict[sn,0]], '\
'syn_comps_int[IN_dend_dict[sn,1]])' % str(general_counter))
exec( 'netcon_OFF%s = template3.somaCon(cell=PYs_h_OFF[int(n)], syn=synd_OFF%s, '\
'weight=p2_ext[stimulus_type[comb]])' % (str(general_counter),str(general_counter)))
exec( 'synd_OFF%s = template1.cortexCon(INs_OFF[IN_dend_dict[sn,0]], '\
'syn_comps_int[IN_dend_dict[sn,1]])' % str(general_counter+1))
exec( 'netcon_OFF%s = template3.somaCon(cell=PYs_v_OFF[int(n)], syn=synd_OFF%s, '\
'weight=p2_ext[stimulus_type[comb]])' % (str(general_counter+2),str(general_counter+1)))
general_counter += 4
n += 1
#### Simulation
sim.simulateCells(NEURON_cells_to_sim)
sys.stdout = copystdout
# update PSTHs
for n in np.arange(0, len(INs_ON)):
h, e = np.histogram(np.array(spikes_IN_ON[n]),
bins=np.arange(0., tsim + binsize,
binsize))
PST_IN_ON[n, :] += h * (1000. / binsize)
for n in np.arange(0, len(INs_OFF)):
h, e = np.histogram(np.array(spikes_IN_OFF[n]),
bins=np.arange(0., tsim + binsize,
binsize))
PST_IN_OFF[n, :] += h * (1000. / binsize)
for n in np.arange(0, len(RCs_ON)):
h, e = np.histogram(np.array(spikes_RC_ON[n]),
bins=np.arange(0., tsim + binsize,
binsize))
PST_RC_ON[n, :] += h * (1000. / binsize)
for n in np.arange(0, len(RCs_OFF)):
h, e = np.histogram(np.array(spikes_RC_OFF[n]),
bins=np.arange(0., tsim + binsize,
binsize))
PST_RC_OFF[n, :] += h * (1000. / binsize)
for n in np.arange(0, len(PYs_h_ON)):
h, e = np.histogram(np.array(spikes_CXPY_h_ON[n]),
bins=np.arange(0., tsim + binsize,
binsize))
PST_CXPY_h_ON[n, :] += h * (1000. / binsize)
for n in np.arange(0, len(PYs_h_OFF)):
h, e = np.histogram(np.array(spikes_CXPY_h_OFF[n]),
bins=np.arange(0., tsim + binsize,
binsize))
PST_CXPY_h_OFF[n, :] += h * (1000. / binsize)
for n in np.arange(0, len(PYs_v_ON)):
h, e = np.histogram(np.array(spikes_CXPY_v_ON[n]),
bins=np.arange(0., tsim + binsize,
binsize))
PST_CXPY_v_ON[n, :] += h * (1000. / binsize)
for n in np.arange(0, len(PYs_v_OFF)):
h, e = np.histogram(np.array(spikes_CXPY_v_OFF[n]),
bins=np.arange(0., tsim + binsize,
binsize))
PST_CXPY_v_OFF[n, :] += h * (1000. / binsize)
# # Save membrane potentials
# if stim == stim_to_plot:
# times = [INs_ON[cell_number_IN].tvec,INs_ON[cell_number_IN].tvec,RCs_ON[cell_number].tvec,
# PYs_h_ON[cell_number].tvec,PYs_v_ON[cell_number].tvec]
# potentials = [INs_ON[cell_number_IN].vmem[0, :],INs_ON[cell_number_IN].vmem[syn_comps_dist[3], :],
# RCs_ON[cell_number].vmem[0, :],
# PYs_h_ON[cell_number].vmem[0, :],PYs_v_ON[cell_number].vmem[0, :]]
# spikes_arriving = [spikes_ON[cell_number],spikes_ON[cell_number],spikes_ON[cell_number],[0.0],[0.0]]
# labels = ["IN-ON","IN-ON-distal dendrite[3]","RC-ON","PY-horizontal-ON","PY-vertical-ON"]
# sim.saveMemPotential(str(stim)+"ON",times,potentials,spikes_arriving,labels)
# times = [INs_OFF[cell_number_IN].tvec,INs_OFF[cell_number_IN].tvec,RCs_OFF[cell_number].tvec,
# PYs_h_OFF[cell_number].tvec,PYs_v_OFF[cell_number].tvec]
# potentials = [INs_OFF[cell_number_IN].vmem[0, :],INs_OFF[cell_number_IN].vmem[syn_comps_dist[3], :],
# RCs_OFF[cell_number].vmem[0, :],
# PYs_h_OFF[cell_number].vmem[0, :],PYs_v_OFF[cell_number].vmem[0, :]]
# spikes_arriving = [spikes_OFF[cell_number],spikes_OFF[cell_number],spikes_OFF[cell_number],[0.0],[0.0]]
# labels = ["IN-OFF","IN-OFF-distal dendrite[3]","RC-OFF","PY-horizontal-OFF","PY-vertical-OFF"]
# sim.saveMemPotential(str(stim)+"OFF",times,potentials,spikes_arriving,labels)
# Release memory
sim.deleteAll(NEURON_cells_to_sim)
del NEURON_cells_to_sim
# Save PSTH matrix (for each stimuli)
sim.savePST(stim, "IN-ON", PST_IN_ON, type + str(stimulus_type[comb]))
sim.savePST(stim, "IN-OFF", PST_IN_OFF,
type + str(stimulus_type[comb]))
sim.savePST(stim, "RC-ON", PST_RC_ON, type + str(stimulus_type[comb]))
sim.savePST(stim, "RC-OFF", PST_RC_OFF,
type + str(stimulus_type[comb]))
sim.savePST(stim, "PY_h-ON", PST_CXPY_h_ON,
type + str(stimulus_type[comb]))
sim.savePST(stim, "PY_h-OFF", PST_CXPY_h_OFF,
type + str(stimulus_type[comb]))
sim.savePST(stim, "PY_v-ON", PST_CXPY_v_ON,
type + str(stimulus_type[comb]))
sim.savePST(stim, "PY_v-OFF", PST_CXPY_v_OFF,
type + str(stimulus_type[comb]))
comb += 1
return 1
def run_optimization(self):
# Prepare variables:
self.topy_dict['PASV_ELEM'] = np.array(self.passive)
self.topy_dict['ACTV_ELEM'] = np.array(self.active)
# Set up ToPy for the different load cases:
topy_cases = []
for load_case in self.load_cases:
topy_cases.append(topology.Topology())
topy_dict = self.topy_dict.copy()
topy_dict['LOAD_DOF'] = self.loaded_dof[load_case]
topy_dict['LOAD_VAL'] = self.loads[load_case]
topy_cases[-1].topydict = topy_dict
topy_cases[-1].set_top_params()
etas_avg = []
t1 = topy_cases[0]
# Optimising function:
def optimise():
# Perform analysis for the different load cases:
for topy_case in topy_cases:
topy_case.fea()
topy_case.sens_analysis()
# Update design variables:
for i in xrange(1,len(topy_cases)):
topy_cases[0].df += topy_cases[i].df*self.case_weights[self.load_cases[i]]
topy_cases[0].filter_sens_sigmund()
topy_cases[0].update_desvars_oc()
for i in xrange(1,len(topy_cases)):
topy_cases[i].desvars = topy_cases[0].desvars
topy_cases[i].p = topy_cases[0].p
# Below this line we print and create images:
create_3d_geom(t1.desvars, prefix=t1.probname, \
iternum=t1.itercount, time='none')
print '%4i | %3.6e | %3.3f | %3.4e | %3.3f | %3.3f | %1.3f | %3.3f '\
% (t1.itercount, t1.objfval, t1.desvars.sum()/(self.total_elements), \
t1.change, t1.p, t1.q, t1.eta.mean(), t1.svtfrac)
# Build a list of average etas:
etas_avg.append(t1.eta.mean())
# Start optimisation runs, create rest of design domains:
print '%5s | %11s | %5s | %10s | %5s | %5s | %7s | %5s ' % ('Iter', \
'Obj. func. ', 'Vol. ', 'Change ', 'P_FAC', 'Q_FAC', 'Ave ETA', 'S-V frac.')
print '-' * 79
ti = time()
n = 0
while n < self.max_iterations:
n += 1
optimise()
te = time()
# Print solid-void ratio info:
print '\nSolid plus void to total elements fraction = %3.5f' % (t1.svtfrac)
# Print iteration info:
print t1.itercount, 'iterations took %3.3f minutes (%3.3f min/iter. \
or %3.3f sec/iter.)'\
%((te - ti) / 60, (te - ti) / 60 / t1.itercount, (te - ti) / t1.itercount)
print 'Average of all ETA\'s = %3.3f (average of all a\'s = %3.3f)' \
% (np.array(etas_avg).mean(), 1/np.array(etas_avg).mean() - 1)
def start_simulation(self):
self.topology = topology.Topology(self.adversary, self,
self.topology_model)
gs_ci_robots[n] = GS_CI(n, initial.copy())
# gs_sci_robots[n] = GS_SCI(n, initial.copy())
landmarks = [None] * M
for m in range(M):
landmarks[m] = sim_env.Landmark(
m,
np.matrix(sim_env.landmark_position, dtype=float).getT())
# N = 5
topology.generate_topology(N, sim_env.observ_prob, sim_env.comm_prob)
### Network Topology
topo_file = open('topology/output.txt', 'r')
observ_topology = topology.Topology(N)
comm_topology = topology.Topology(N)
edge_num_str = topo_file.readline()
for i in range(int(edge_num_str)):
line = topo_file.readline()
edge = line.split(", ")
observ_topology.add_edge(int(edge[0]), int(edge[1]))
edge_num_str = topo_file.readline()
for i in range(int(edge_num_str)):
line = topo_file.readline()
edge = line.split(", ")
