Esempio n. 1
0
 /** @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);
   }
 }
Esempio n. 2
0
  /** @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();
  }
Esempio n. 3
0
  /**
   * 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;
  }
Esempio n. 4
0
  /**
   * 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;
  }
Esempio n. 5
0
  /** @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);
        }
      }
    }
  }
Esempio n. 6
0
  /** @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();
  }
Esempio n. 7
0
  @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;
  }