/** @see ca.nengo.model.Resettable#reset(boolean) */
public void reset(boolean randomize) {
Iterator<String> it = myNodeMap.keySet().iterator();
while (it.hasNext()) {
Node n = myNodeMap.get(it.next());
n.reset(randomize);
}
}
/** @see ca.nengo.model.Network#addNode(ca.nengo.model.Node) */
public void addNode(Node node) throws StructuralException {
if (myNodeMap.containsKey(node.getName())) {
throw new StructuralException("This Network already contains a Node named " + node.getName());
}
myNodeMap.put(node.getName(), node);
node.addChangeListener(this);
getSimulator().initialize(this);
fireVisibleChangeEvent();
}
/**
* Gathers all the origins of nodes contained in this network.
*
* @return arraylist of origins
*/
public ArrayList<Origin> getNodeOrigins() {
ArrayList<Origin> nodeOrigins = new ArrayList<Origin>();
Node[] nodes = getNodes();
for (Node node : nodes) {
Origin[] origs = node.getOrigins();
for (Origin orig : origs) {
nodeOrigins.add(orig);
}
}
return nodeOrigins;
}
/**
* Gathers all the terminations of nodes contained in this network.
*
* @return arraylist of terminations
*/
public ArrayList<Termination> getNodeTerminations() {
ArrayList<Termination> nodeTerminations = new ArrayList<Termination>();
Node[] nodes = getNodes();
for (Node node : nodes) {
Termination[] terms = node.getTerminations();
for (Termination term : terms) {
nodeTerminations.add(term);
}
}
return nodeTerminations;
}
/** @see ca.nengo.model.Node#setMode(ca.nengo.model.SimulationMode) */
public void setMode(SimulationMode mode) {
if (!myModeFixed) {
myMode = mode;
Iterator<Node> it = myNodeMap.values().iterator();
while (it.hasNext()) {
Node node = it.next();
if (node instanceof ca.nengo.model.nef.impl.NEFEnsembleImpl) {
if (!((ca.nengo.model.nef.impl.NEFEnsembleImpl) node).getModeFixed()) {
node.setMode(mode);
}
} else {
node.setMode(mode);
}
}
}
}
/** @see ca.nengo.model.Network#removeNode(java.lang.String) */
public void removeNode(String name) throws StructuralException {
if (myNodeMap.containsKey(name)) {
Node node = myNodeMap.get(name);
if (node instanceof Network) {
Network net = (Network) node;
Probe[] probes = net.getSimulator().getProbes();
for (Probe probe : probes) {
try {
net.getSimulator().removeProbe(probe);
} catch (SimulationException se) {
System.err.println(se);
return;
}
}
Node[] nodes = net.getNodes();
for (Node node2 : nodes) {
net.removeNode(node2.getName());
}
} else if (node instanceof DecodableEnsembleImpl) {
NEFEnsembleImpl pop = (NEFEnsembleImpl) node;
Origin[] origins = pop.getOrigins();
for (Origin origin : origins) {
String exposedName = getExposedOriginName(origin);
if (exposedName != null) {
hideOrigin(exposedName);
}
}
}
myNodeMap.remove(name);
node.removeChangeListener(this);
// VisiblyMutableUtils.nodeRemoved(this, node, myListeners);
} else {
throw new StructuralException("No Node named " + name + " in this Network");
}
getSimulator().initialize(this);
fireVisibleChangeEvent();
}
@Override
public Network clone() throws CloneNotSupportedException {
NetworkImpl result = (NetworkImpl) super.clone();
result.myNodeMap = new HashMap<String, Node>(10);
for (Node oldNode : myNodeMap.values()) {
Node newNode = oldNode.clone();
result.myNodeMap.put(newNode.getName(), newNode);
newNode.addChangeListener(result);
}
// TODO: Exposed states aren't handled currently, pending redesign of Probes (it should be
// possible
// to probe things that are nested deeply, in which case exposing state woulnd't be necessary)
// result.myProbeables
// result.myProbeableStates
// TODO: this works with a single Projection impl & no params; should add
// Projection.copy(Origin, Termination, Network)?
result.myProjectionMap = new HashMap<Termination, Projection>(10);
for (Projection oldProjection : getProjections()) {
try {
Origin newOrigin =
result
.getNode(oldProjection.getOrigin().getNode().getName())
.getOrigin(oldProjection.getOrigin().getName());
Termination newTermination =
result
.getNode(oldProjection.getTermination().getNode().getName())
.getTermination(oldProjection.getTermination().getName());
Projection newProjection = new ProjectionImpl(newOrigin, newTermination, result);
result.myProjectionMap.put(newTermination, newProjection);
} catch (StructuralException e) {
throw new CloneNotSupportedException("Problem copying Projectio: " + e.getMessage());
}
}
result.myExposedOrigins = new HashMap<String, Origin>(10);
result.myExposedOriginNames = new HashMap<Origin, String>(10);
result.OrderedExposedOrigins = new LinkedList<Origin>();
for (Origin exposed : getOrigins()) {
String name = exposed.getName();
Origin wrapped = ((OriginWrapper) exposed).getWrappedOrigin();
try {
Origin toExpose = result.getNode(wrapped.getNode().getName()).getOrigin(wrapped.getName());
result.exposeOrigin(toExpose, name);
} catch (StructuralException e) {
throw new CloneNotSupportedException("Problem exposing Origin: " + e.getMessage());
}
}
result.myExposedTerminations = new HashMap<String, Termination>(10);
result.myExposedTerminationNames = new HashMap<Termination, String>(10);
result.OrderedExposedTerminations = new LinkedList<Termination>();
for (Termination exposed : getTerminations()) {
String name = exposed.getName();
Termination wrapped = ((TerminationWrapper) exposed).getWrappedTermination();
try {
Termination toExpose =
result.getNode(wrapped.getNode().getName()).getTermination(wrapped.getName());
result.exposeTermination(toExpose, name);
} catch (StructuralException e) {
throw new CloneNotSupportedException("Problem exposing Termination: " + e.getMessage());
}
}
result.myListeners = new ArrayList<Listener>(5);
result.myMetaData = new HashMap<String, Object>(10);
for (String key : myMetaData.keySet()) {
Object o = myMetaData.get(key);
if (o instanceof Cloneable) {
Object copy = tryToClone((Cloneable) o);
result.myMetaData.put(key, copy);
} else {
result.myMetaData.put(key, o);
}
}
// TODO: take another look at Probe design (maybe Probeables reference Probes?)
result.mySimulator = mySimulator.clone();
result.mySimulator.initialize(result);
Probe[] oldProbes = mySimulator.getProbes();
for (Probe oldProbe : oldProbes) {
Probeable target = oldProbe.getTarget();
if (target instanceof Node) {
Node oldNode = (Node) target;
if (oldProbe.isInEnsemble()) {
try {
Ensemble oldEnsemble = (Ensemble) getNode(oldProbe.getEnsembleName());
int neuronIndex = -1;
for (int j = 0; j < oldEnsemble.getNodes().length && neuronIndex < 0; j++) {
if (oldNode == oldEnsemble.getNodes()[j]) {
neuronIndex = j;
}
}
result.mySimulator.addProbe(
oldProbe.getEnsembleName(), neuronIndex, oldProbe.getStateName(), true);
} catch (SimulationException e) {
ourLogger.warn("Problem copying Probe", e);
} catch (StructuralException e) {
ourLogger.warn("Problem copying Probe", e);
}
} else {
try {
result.mySimulator.addProbe(oldNode.getName(), oldProbe.getStateName(), true);
} catch (SimulationException e) {
ourLogger.warn("Problem copying Probe", e);
}
}
} else {
ourLogger.warn(
"Can't copy Probe on type "
+ target.getClass().getName()
+ " (to be addressed in a future release)");
}
}
return result;
}