Пример #1
0
  public void parseGroup(Group g) throws Hdf5Exception, EndOfSequenceException {
    startGroup(g);

    java.util.List members = g.getMemberList();

    // NOTE: parsing contents twice to ensure subgroups are handled before datasets
    // This is mainly because synapse_props groups will need to be parsed before dataset of
    // connections

    for (int j = 0; j < members.size(); j++) {
      HObject obj = (HObject) members.get(j);

      if (obj instanceof Group) {
        Group subGroup = (Group) obj;

        logger.logComment("---------    Found a sub group: " + subGroup.getName());

        parseGroup(subGroup);
      }
    }

    for (int j = 0; j < members.size(); j++) {
      HObject obj = (HObject) members.get(j);

      if (obj instanceof Dataset) {
        Dataset ds = (Dataset) obj;

        logger.logComment("Found a dataset: " + ds.getName());

        dataSet(ds);
      }
    }

    endGroup(g);
  }
Пример #2
0
  public static void main(String[] args) {
    new ExampleProjects();

    try {

      File exsDir = new File("osb/showcase/neuroConstructShowcase");

      File mainFile = new File("docs/XML/xmlForHtml/samples/index.xml");

      logger.logComment("Going to create docs at: " + mainFile.getCanonicalPath(), true);

      generateMainPage(mainFile, exsDir);

      logger.logComment("Created doc at: " + mainFile.getCanonicalPath(), true);
      /*
      File modelsDir = new File("nCmodels");
      mainFile = new File("docs/XML/xmlForHtml/models/index.xml");


      generateMainPage(mainFile, modelsDir);

      logger.logComment("Created doc at: "+ mainFile.getCanonicalPath(), true);

       */
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  public void loadFromFile(File positionFile) throws java.io.IOException {
    logger.logComment("Loading position records from file: " + positionFile.getAbsolutePath());

    this.reset();

    Reader in = new FileReader(positionFile);
    LineNumberReader reader = new LineNumberReader(in);
    String nextLine = null;

    String currentInputRef = null;

    while ((nextLine = reader.readLine()) != null) {
      // logger.logComment("Parsing line: "+ nextLine);

      if (nextLine.endsWith(":")) {
        currentInputRef = nextLine.substring(0, nextLine.length() - 1);
        logger.logComment("currentInputRef: " + currentInputRef);
      } else {
        SingleElectricalInput input = new SingleElectricalInput(nextLine);
        this.addSingleInput(currentInputRef, input);
      }
    }
    in.close();

    logger.logComment("Finished loading cell info. Internal state: " + this.toString());
  }
  @Override
  public void reset() {
    super.reset();

    numProposedPoints = 0;
    logger.logComment("------------------  Adapter being reset...");
  }
Пример #5
0
  public static void main(String args[]) {

    try {

      logger.logComment("Sys prop: " + System.getProperty("java.library.path"), true);

      // File projFile = new File("../copyNcModels/NewGranCellLayer/NewGranCellLayer.neuro.xml");

      // File projFile = new File("../nC_projects/Bignet/Bignet.neuro.xml");
      File projFile = new File("testProjects/TestNetworkML/TestNetworkML.neuro.xml");

      // Project testProj = Project.loadProject(new File("projects/Parall/Parall.neuro.xml"),null);
      // Project testProj = Project.loadProject(new
      // File("examples/Ex5-Networks/Ex5-Networks.neuro.xml"),null);
      Project testProj = Project.loadProject(projFile, null);

      // File h5File = new File(projFile.getParentFile().getAbsolutePath()+
      // "/savedNetworks/hhh.h5");
      // File h5File = new File(projFile.getParentFile().getAbsolutePath()+
      // "/savedNetworks/nnnn.h5");

      File h5File = new File("testProjects/TestNetworkML/savedNetworks/small.h5");

      // logger.logComment("Loading netml cell from "+ h5File.getAbsolutePath(), true);

      NetworkMLReader nmlReader = new NetworkMLReader(testProj);

      nmlReader.parse(h5File);

      logger.logComment("Contents: " + testProj.generatedCellPositions);
      logger.logComment("Net conns: " + testProj.generatedNetworkConnections);
      logger.logComment("Inputs: " + testProj.generatedElecInputs.details(false));

    } catch (Exception e) {
      e.printStackTrace();
      System.exit(0);
    }
  }
  public SynapticPropertiesDialog(Frame frame, SynapticProperties synProps, Project project) {
    super(frame, "Synaptic Properties", false);

    this.mySynProps = synProps;
    this.project = project;

    try {
      jbInit();
      extraInit();
      pack();
    } catch (Exception ex) {
      logger.logComment("Exception starting GUI: " + ex);
    }
  }
  public SynapticPropertiesDialog(Dialog dlg, SynapticProperties synProps, Project project) {
    super(dlg, "Synaptic Properties", false);

    logger.logComment("Starting with: " + synProps);

    this.mySynProps = synProps;
    this.project = project;

    try {
      jbInit();
      extraInit();
      pack();
    } catch (Exception ex) {
      ex.printStackTrace();
    }
  }
Пример #8
0
  public void endGroup(Group g) throws Hdf5Exception {
    logger.logComment("-----   Going out of a group: " + g.getFullName());

    if (g.getName().equals(NetworkMLConstants.POPULATIONS_ELEMENT)) {
      inPopulations = false;
    } else if (g.getName().equals(NetworkMLConstants.PROJECTIONS_ELEMENT)) {
      inProjections = false;
    } else if (g.getName().equals(NetworkMLConstants.INPUTS_ELEMENT)) {
      inInputs = false;
    } else if (g.getName().equals(NetworkMLConstants.INPUT_ELEMENT) && inInputs) {
      currentInput = null;
    } else if (g.getName().startsWith(NetworkMLConstants.POPULATION_ELEMENT) && inPopulations) {
      currentCellGroup = null;
    } else if (g.getName().startsWith(NetworkMLConstants.PROJECTION_ELEMENT) && inProjections) {
      currentNetConn = null;
      globConnProps = new ArrayList<ConnSpecificProps>();
    } else if (g.getName().startsWith(NetworkMLConstants.CONNECTION_ELEMENT)) {
      localConnProps = new ArrayList<ConnSpecificProps>();
      localAPDelay = 0;
    }
  }
  public void saveToFile(File inputsFile) throws java.io.IOException {
    logger.logComment(
        "Saving "
            + this.getNumberSingleInputs()
            + " inputs to file: "
            + inputsFile.getAbsolutePath());

    // will create the parent dir if it doesn't exist.
    if (!inputsFile.exists()) {
      logger.logComment("File: " + inputsFile + " doesn't exist.");
      if (!inputsFile.getParentFile().exists()) {
        logger.logComment("Parent dir: " + inputsFile.getParentFile() + " doesn't exist.");
        // String parentDirName = inputsFile.getParentFile().getCanonicalPath();
        File projectDir = inputsFile.getParentFile().getParentFile();

        if (!projectDir.exists()) {
          throw new FileNotFoundException(
              "Project dir doesn't exist: " + projectDir.getAbsolutePath());
        }
        // logger.logComment("Going to create dir: "+ parentDirName +" in dir :"+ projectDir);

        logger.logComment("Going to create dir: " + inputsFile.getParentFile());

        inputsFile.getParentFile().mkdir();

        logger.logComment("Success? " + inputsFile.getParentFile().exists());
      }
    }

    FileWriter fw = new FileWriter(inputsFile);

    Enumeration keys = this.myElecInputs.keys();

    while (keys.hasMoreElements()) {
      String input = (String) keys.nextElement();
      ArrayList<SingleElectricalInput> inputs = getInputLocations(input);

      fw.write(input + ":\n");

      for (int i = 0; i < inputs.size(); i++) {
        fw.write(inputs.get(i) + "\n");
      }
    }
    logger.logComment("Finished saving data to file: " + inputsFile.getAbsolutePath());
    fw.flush();
    fw.close();
  }
  void jButtonOK_actionPerformed(ActionEvent e) {
    logger.logComment("OK button pressed");
    cancelled = false;

    double threshold;

    try {
      threshold = Double.parseDouble(jTextFieldThreshold.getText());
    } catch (NumberFormatException ex) {
      GuiUtils.showErrorMessage(
          logger,
          "Please enter a number (usually -50 -> 0) for the millivolt value of the firing threshold",
          ex,
          this);
      return;
    }
    mySynProps.setThreshold(threshold);

    String selectedSynapse = (String) jComboBoxSynapseType.getSelectedItem();

    mySynProps.setSynapseType(selectedSynapse);

    this.dispose();
  }
  public ArrayList<SimpleXMLEntity> getNetworkMLEntities(
      int unitSystem, NeuroMLConstants.NeuroMLVersion version, SimpleXMLElement topLevelCompElement)
      throws NeuroMLException {
    ArrayList<SimpleXMLEntity> entities = new ArrayList<SimpleXMLEntity>();

    Units timeUnits = UnitConverter.timeUnits[unitSystem];
    Units currentUnits = UnitConverter.currentUnits[unitSystem];

    SimpleXMLElement inputsElement = null;
    try {
      logger.logComment(
          "Going to save file in NeuroML format: "
              + this.getNumberSingleInputs()
              + " inputs in total");

      if (getNumberSingleInputs() == 0) {
        SimpleXMLComment comm =
            new SimpleXMLComment("There are no electrical inputs present in the network");
        entities.add(comm);
        return entities;
      }

      boolean nml2 = version.isVersion2();
      boolean nml2alpha = version.isVersion2alpha();

      if (!nml2) {
        inputsElement = new SimpleXMLElement(NetworkMLConstants.INPUTS_ELEMENT);
        entities.add(inputsElement);

        if (unitSystem == UnitConverter.GENESIS_PHYSIOLOGICAL_UNITS) {
          inputsElement.addAttribute(
              new SimpleXMLAttribute(
                  NetworkMLConstants.UNITS_ATTR, NetworkMLConstants.UNITS_PHYSIOLOGICAL));
        } else if (unitSystem == UnitConverter.GENESIS_SI_UNITS) {
          inputsElement.addAttribute(
              new SimpleXMLAttribute(NetworkMLConstants.UNITS_ATTR, NetworkMLConstants.UNITS_SI));
        }
      }

      Enumeration keys = myElecInputs.keys();

      while (keys.hasMoreElements()) {
        String inputReference = (String) keys.nextElement();
        ArrayList<SingleElectricalInput> inputsHere = getInputLocations(inputReference);

        logger.logComment("Adding " + inputsHere.size() + " inputs");

        StimulationSettings nextStim = project.elecInputInfo.getStim(inputReference);

        ElectricalInput myElectricalInput = nextStim.getElectricalInput();

        SimpleXMLElement inputElement = new SimpleXMLElement(NetworkMLConstants.INPUT_ELEMENT);

        inputElement.addAttribute(
            new SimpleXMLAttribute(NetworkMLConstants.INPUT_NAME_ATTR, inputReference));

        if (myElectricalInput instanceof IClamp) {
          IClamp ic = (IClamp) myElectricalInput;

          float delay = ic.getDel().getNominalNumber();
          float duration = ic.getDur().getNominalNumber();
          float amplitude = ic.getAmp().getNominalNumber();

          SimpleXMLElement inputTypeElement =
              new SimpleXMLElement(NetworkMLConstants.PULSEINPUT_ELEMENT);

          float del =
              (float) UnitConverter.getTime(delay, UnitConverter.NEUROCONSTRUCT_UNITS, unitSystem);
          float dur =
              (float)
                  UnitConverter.getTime(duration, UnitConverter.NEUROCONSTRUCT_UNITS, unitSystem);
          float amp =
              (float)
                  UnitConverter.getCurrent(
                      amplitude, UnitConverter.NEUROCONSTRUCT_UNITS, unitSystem);

          inputTypeElement.addAttribute(
              new SimpleXMLAttribute(NetworkMLConstants.INPUT_DELAY_ATTR, del + ""));

          inputTypeElement.addAttribute(
              new SimpleXMLAttribute(NetworkMLConstants.INPUT_DUR_ATTR, dur + ""));

          inputTypeElement.addAttribute(
              new SimpleXMLAttribute(NetworkMLConstants.INPUT_AMP_ATTR, amp + ""));

          inputElement.addChildElement(inputTypeElement);

          inputElement.addContent("\n        ");

          if (nml2) {
            SimpleXMLElement pulseGenElement =
                new SimpleXMLElement(NetworkMLConstants.NEUROML2_PULSE_GEN_ELEMENT);
            pulseGenElement.addAttribute(NeuroMLConstants.NEUROML_ID_V2, inputReference);
            pulseGenElement.addAttribute(
                NetworkMLConstants.INPUT_DELAY_ATTR, del + timeUnits.getNeuroML2Symbol());
            pulseGenElement.addAttribute(
                NetworkMLConstants.INPUT_DUR_ATTR, dur + timeUnits.getNeuroML2Symbol());
            pulseGenElement.addAttribute(
                NetworkMLConstants.INPUT_AMP_ATTR, amp + currentUnits.getNeuroML2Symbol());

            topLevelCompElement.addContent("\n\n    ");
            topLevelCompElement.addChildElement(pulseGenElement);
            topLevelCompElement.addContent("\n\n    ");
          }

        } else if (myElectricalInput instanceof RandomSpikeTrain) {
          RandomSpikeTrain rst = (RandomSpikeTrain) myElectricalInput;

          float stimFreq = rst.getRate().getNominalNumber();
          String stimMech = rst.getSynapseType();

          SimpleXMLElement inputTypeElement =
              new SimpleXMLElement(NetworkMLConstants.RANDOMSTIM_ELEMENT);
          float rate =
              (float)
                  UnitConverter.getRate(stimFreq, UnitConverter.NEUROCONSTRUCT_UNITS, unitSystem);
          inputTypeElement.addAttribute(
              new SimpleXMLAttribute(
                  NetworkMLConstants.RND_STIM_FREQ_ATTR,
                  (float)
                          UnitConverter.getRate(
                              stimFreq, UnitConverter.NEUROCONSTRUCT_UNITS, unitSystem)
                      + ""));

          inputTypeElement.addAttribute(
              new SimpleXMLAttribute(NetworkMLConstants.RND_STIM_MECH_ATTR, stimMech));
          inputElement.addChildElement(inputTypeElement);
          inputElement.addContent("\n        ");

          if (nml2 && !nml2alpha) {
            SimpleXMLElement spikeGenElement =
                new SimpleXMLElement(NetworkMLConstants.NEUROML2_SPIKE_GEN_POISSON_ELEMENT);
            spikeGenElement.addAttribute(NeuroMLConstants.NEUROML_ID_V2, inputReference);
            spikeGenElement.addAttribute(
                NetworkMLConstants.NEUROML2_SPIKE_GEN_POISSON_RATE_ATTR,
                rate
                    + " "
                    + UnitConverter.rateUnits[UnitConverter.NEUROCONSTRUCT_UNITS]
                        .getNeuroML2Symbol()
                    + "");

            topLevelCompElement.addContent("\n\n    ");
            topLevelCompElement.addChildElement(spikeGenElement);
            topLevelCompElement.addContent("\n\n    ");
          }
        } else {
          throw new NeuroMLException(
              "Error trying to save input "
                  + inputReference
                  + ". Cannot save in NeuroML an input of type: "
                  + myElectricalInput.getType());
        }

        SimpleXMLElement inputTargetElement =
            new SimpleXMLElement(NetworkMLConstants.INPUT_TARGET_ELEMENT);

        inputTargetElement.addAttribute(
            new SimpleXMLAttribute(
                NetworkMLConstants.INPUT_TARGET_POPULATION_ATTR, nextStim.getCellGroup()));

        inputElement.addChildElement(inputTargetElement);
        inputTargetElement.addContent("\n            ");

        SimpleXMLElement inputTargetSitesElement =
            new SimpleXMLElement(NetworkMLConstants.INPUT_TARGET_SITES_ELEMENT);

        inputTargetSitesElement.addAttribute(
            new SimpleXMLAttribute(
                NetworkMLConstants.INPUT_SITES_SIZE_ATTR, inputsHere.size() + ""));

        inputTargetElement.addChildElement(inputTargetSitesElement);

        SimpleXMLElement stimProjElement = null;

        if (version.isVersion2betaOrLater()) {

          if (myElectricalInput instanceof IClamp) {
            SimpleXMLElement inputListElement =
                new SimpleXMLElement(NetworkMLConstants.NEUROML2_INPUT_LIST_ELEMENT);
            entities.add(inputListElement);
            inputListElement.addAttribute(NeuroMLConstants.NEUROML_ID_V2, nextStim.getReference());
            inputListElement.addAttribute(
                NetworkMLConstants.NEUROML2_INPUT_COMPONENT, inputReference);
            inputListElement.addAttribute(
                NetworkMLConstants.NEUROML2_INPUT_POPULATION, nextStim.getCellGroup());

            // inputElement.addContent("\n    ");
            inputTargetSitesElement = inputListElement;

          } else if (myElectricalInput instanceof RandomSpikeTrain) {
            SimpleXMLElement popElement =
                new SimpleXMLElement(NetworkMLConstants.POPULATION_ELEMENT);
            entities.add(0, popElement);
            popElement.addAttribute(
                NeuroMLConstants.NEUROML_ID_V2, nextStim.getReference() + "_population");
            popElement.addAttribute(
                NetworkMLConstants.NEUROML2_POPULATION_COMPONENT,
                nextStim.getReference() + "_population");
            popElement.addAttribute(
                NetworkMLConstants.NEUROML2_POPULATION_SIZE, inputsHere.size() + "");

            stimProjElement = new SimpleXMLElement(NetworkMLConstants.PROJECTION_ELEMENT);
            stimProjElement.addAttribute(
                NeuroMLConstants.NEUROML_ID_V2, nextStim.getReference() + "_projection");
            entities.add(stimProjElement);
          }
        }

        // Iterate around the list of sites
        for (int i = 0; i < inputsHere.size(); i++) {
          inputTargetSitesElement.addContent("\n                ");

          SingleElectricalInput sei = inputsHere.get(i);

          SimpleXMLElement inputTargetSiteElement =
              new SimpleXMLElement(NetworkMLConstants.INPUT_TARGET_SITE_ELEMENT);

          inputTargetSiteElement.addAttribute(
              new SimpleXMLAttribute(
                  NetworkMLConstants.INPUT_SITE_CELLID_ATTR, sei.getCellNumber() + ""));
          inputTargetSiteElement.addAttribute(
              new SimpleXMLAttribute(
                  NetworkMLConstants.INPUT_SITE_SEGID_ATTR, sei.getSegmentId() + ""));
          inputTargetSiteElement.addAttribute(
              new SimpleXMLAttribute(
                  NetworkMLConstants.INPUT_SITE_FRAC_ATTR, sei.getFractionAlong() + ""));

          if (!nml2) inputTargetSitesElement.addChildElement(inputTargetSiteElement);

          if (nml2 && !nml2alpha) {
            if (myElectricalInput instanceof RandomSpikeTrain) {
              String connElName = NetworkMLConstants.CONNECTION_ELEMENT;

              SimpleXMLElement connElement = new SimpleXMLElement(connElName);

              connElement.addAttribute(
                  new SimpleXMLAttribute(NetworkMLConstants.CONNECTION_ID_ATTR, i + ""));
              stimProjElement.addContent("\n    ");
              stimProjElement.addChildElement(connElement);
              stimProjElement.addContent("\n    ");
            }
          }

          if (sei.getInstanceProps() != null) {
            inputTargetSiteElement.addContent("\n                ");
            inputTargetSiteElement.addComment("Adding the site specific props");

            if (sei.getInstanceProps() instanceof IClampInstanceProps) {
              IClampInstanceProps ic = (IClampInstanceProps) sei.getInstanceProps();

              float delay =
                  (float)
                      UnitConverter.getTime(
                          ic.getDelay(), UnitConverter.NEUROCONSTRUCT_UNITS, unitSystem);
              float duration =
                  (float)
                      UnitConverter.getTime(
                          ic.getDuration(), UnitConverter.NEUROCONSTRUCT_UNITS, unitSystem);
              float amp =
                  (float)
                      UnitConverter.getCurrent(
                          ic.getAmplitude(), UnitConverter.NEUROCONSTRUCT_UNITS, unitSystem);

              if (!nml2) {
                SimpleXMLElement inputTypeElement =
                    new SimpleXMLElement(NetworkMLConstants.PULSEINPUT_INSTANCE_ELEMENT);

                inputTypeElement.addAttribute(
                    new SimpleXMLAttribute(NetworkMLConstants.INPUT_DELAY_ATTR, delay + ""));

                inputTypeElement.addAttribute(
                    new SimpleXMLAttribute(NetworkMLConstants.INPUT_DUR_ATTR, duration + ""));

                // System.out.println("Converted "+amp+" to "+ a);
                inputTypeElement.addAttribute(
                    new SimpleXMLAttribute(NetworkMLConstants.INPUT_AMP_ATTR, amp + ""));

                inputTargetSiteElement.addContent("                    ");
                inputTargetSiteElement.addChildElement(inputTypeElement);

                inputTargetSiteElement.addContent("\n                ");
              } else {
                SimpleXMLElement pulseGenElement =
                    new SimpleXMLElement(NetworkMLConstants.NEUROML2_PULSE_GEN_ELEMENT);
                pulseGenElement.addAttribute(
                    NeuroMLConstants.NEUROML_ID_V2, inputReference + "__" + i);
                pulseGenElement.addAttribute(
                    NetworkMLConstants.INPUT_DELAY_ATTR, delay + timeUnits.getNeuroML2Symbol());
                pulseGenElement.addAttribute(
                    NetworkMLConstants.INPUT_DUR_ATTR, duration + timeUnits.getNeuroML2Symbol());
                pulseGenElement.addAttribute(
                    NetworkMLConstants.INPUT_AMP_ATTR, amp + currentUnits.getNeuroML2Symbol());

                topLevelCompElement.addContent("\n\n    ");
                topLevelCompElement.addChildElement(pulseGenElement);
                topLevelCompElement.addContent("\n\n    ");

                if (version.isVersion2alpha()) {
                  String target = nextStim.getCellGroup() + "[" + sei.getCellNumber() + "]";
                  SimpleXMLElement expInputElement =
                      new SimpleXMLElement(NetworkMLConstants.NEUROML2_EXP_INPUT_ELEMENT);
                  expInputElement.addAttribute(
                      NetworkMLConstants.NEUROML2_EXP_INPUT_TARGET_ATTR, target);
                  expInputElement.addAttribute(
                      NetworkMLConstants.NEUROML2_EXP_INPUT_INPUT_ATTR, inputReference + "__" + i);

                  entities.add(expInputElement);
                } else {
                  String target =
                      "../"
                          + nextStim.getCellGroup()
                          + "/"
                          + sei.getCellNumber()
                          + "/"
                          + project.cellGroupsInfo.getCellType(nextStim.getCellGroup());
                  SimpleXMLElement expInputElement =
                      new SimpleXMLElement(NetworkMLConstants.NEUROML2_INPUT_LIST_ELEMENT);
                  expInputElement.addAttribute(
                      NetworkMLConstants.NEUROML2_EXP_INPUT_TARGET_ATTR, target);
                  expInputElement.addAttribute(
                      NetworkMLConstants.NEUROML2_EXP_INPUT_INPUT_ATTR, inputReference + "__" + i);

                  entities.add(expInputElement);
                }
              }
            } else if (sei.getInstanceProps() instanceof RandomSpikeTrainInstanceProps) {
              RandomSpikeTrainInstanceProps rst =
                  (RandomSpikeTrainInstanceProps) sei.getInstanceProps();

              float stimFreq = rst.getRate();
              // String stimMech = rst.get;

              SimpleXMLElement inputTypeElement =
                  new SimpleXMLElement(NetworkMLConstants.RANDOMSTIM_INSTANCE_ELEMENT);

              inputTypeElement.addAttribute(
                  new SimpleXMLAttribute(
                      NetworkMLConstants.RND_STIM_FREQ_ATTR,
                      (float)
                              UnitConverter.getRate(
                                  stimFreq, UnitConverter.NEUROCONSTRUCT_UNITS, unitSystem)
                          + ""));

              // inputTypeElement.addAttribute(new
              // SimpleXMLAttribute(NetworkMLConstants.RND_STIM_MECH_ATTR, stimMech));

              inputTargetSiteElement.addContent("                    ");
              inputTargetSiteElement.addChildElement(inputTypeElement);
              inputTargetSiteElement.addContent("\n                ");

            } else {
              throw new NeuroMLException(
                  "Error trying to save input "
                      + inputReference
                      + ". Cannot save in NeuroML an input of type: "
                      + myElectricalInput.getType());
            }
          } else {
            if (nml2) {
              if (version.isVersion2alpha()) {
                String target = nextStim.getCellGroup() + "[" + sei.getCellNumber() + "]";
                SimpleXMLElement expInputElement =
                    new SimpleXMLElement(NetworkMLConstants.NEUROML2_EXP_INPUT_ELEMENT);
                expInputElement.addAttribute(
                    NetworkMLConstants.NEUROML2_EXP_INPUT_TARGET_ATTR, target);
                expInputElement.addAttribute(
                    NetworkMLConstants.NEUROML2_EXP_INPUT_INPUT_ATTR, inputReference);

                entities.add(expInputElement);
              } else {
                String target =
                    "../"
                        + nextStim.getCellGroup()
                        + "/"
                        + sei.getCellNumber()
                        + "/"
                        + project.cellGroupsInfo.getCellType(nextStim.getCellGroup());
                SimpleXMLElement expInputElement =
                    new SimpleXMLElement(NetworkMLConstants.NEUROML2_INPUT_ELEMENT);
                expInputElement.addAttribute(NeuroMLConstants.NEUROML_ID_V2, i + "");
                expInputElement.addAttribute(
                    NetworkMLConstants.NEUROML2_EXP_INPUT_TARGET_ATTR, target);
                expInputElement.addAttribute(
                    NetworkMLConstants.NEUROML2_INPUT_DESTINATION,
                    NetworkMLConstants.NEUROML2_INPUT_DESTINATION_DEFAULT);

                inputTargetSitesElement.addChildElement(expInputElement);
              }
            }
          }

          if (i == inputsHere.size() - 1) inputTargetSitesElement.addContent("\n            ");

          // Next Site
        }
        inputTargetElement.addContent("\n        ");

        if (!nml2) {
          inputsElement.addChildElement(inputElement);
          inputElement.addContent("\n    ");
        }
      }
      logger.logComment("Finished saving data to inputs element");

    } catch (Exception ex) {
      ex.printStackTrace();
      throw new NeuroMLException("Problem creating inputs element file", ex);
    }
    return entities;
  }
 void jButtonCancel_actionPerformed(ActionEvent e) {
   logger.logComment("Cancel button pressed");
   cancelled = true;
   this.dispose();
 }
Пример #13
0
  public void startGroup(Group g) throws Hdf5Exception {
    logger.logComment("-----   Going into a group: " + g.getFullName());

    ArrayList<Attribute> attrs = Hdf5Utils.parseGroupForAttributes(g);

    for (Attribute attribute : attrs) {
      // attribute.
      logger.logComment(
          "Group: "
              + g.getName()
              + " has attribute: "
              + attribute.getName()
              + " = "
              + Hdf5Utils.getFirstStringValAttr(attrs, attribute.getName()));
    }

    if (g.getName().equals(NetworkMLConstants.ROOT_ELEMENT)) {
      logger.logComment("Found the main group");

      String simConfigName =
          Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.NC_SIM_CONFIG);

      if (simConfigName != null) this.foundSimConfig = simConfigName;

      String randomSeed =
          Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.NC_NETWORK_GEN_RAND_SEED);

      if (randomSeed != null) this.foundRandomSeed = Long.parseLong(randomSeed);

    } else if (g.getName().equals(NetworkMLConstants.POPULATIONS_ELEMENT)) {
      logger.logComment("Found the pops group");
      inPopulations = true;

    } else if (g.getName().startsWith(NetworkMLConstants.POPULATION_ELEMENT) && inPopulations) {
      String name = Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.POP_NAME_ATTR);

      logger.logComment("Found a population: " + name);
      currentCellGroup = name;
    } else if (g.getName().equals(NetworkMLConstants.PROJECTIONS_ELEMENT)) {
      logger.logComment("Found the projections group");
      inProjections = true;

      String units = Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.UNITS_ATTR);

      projUnitSystem = UnitConverter.getUnitSystemIndex(units);

    } else if (g.getName().startsWith(NetworkMLConstants.PROJECTION_ELEMENT) && inProjections) {
      String name = Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.PROJ_NAME_ATTR);
      String source = Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.SOURCE_ATTR);
      String target = Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.TARGET_ATTR);

      logger.logComment("Found a projection: " + name + " from " + source + " to " + target);

      if (!project.morphNetworkConnectionsInfo.isValidSimpleNetConn(name)
          && !project.volBasedConnsInfo.isValidVolBasedConn(name)) {
        throw new Hdf5Exception(
            "Error: there is a network connection with name: "
                + name
                + " specified in "
                + "that file, but no such NetConn exists in the project. Add one to allow import of this file");
      }

      /* TODO: Add checks on source & target!!
       */

      if (project.morphNetworkConnectionsInfo.isValidSimpleNetConn(name)) {
        // if (project.morphNetworkConnectionsInfo)
      }

      currentNetConn = name;
    } else if (g.getName().startsWith(NetworkMLConstants.SYN_PROPS_ELEMENT + "_")
        && inProjections) {
      String name = Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.SYN_TYPE_ATTR);

      ConnSpecificProps cp = new ConnSpecificProps(name);

      String internalDelay =
          Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.INTERNAL_DELAY_ATTR);
      if (internalDelay != null)
        cp.internalDelay =
            (float)
                UnitConverter.getTime(
                    Float.parseFloat(internalDelay),
                    projUnitSystem,
                    UnitConverter.NEUROCONSTRUCT_UNITS);

      // Lump them in to the internal delay...
      String preDelay = Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.PRE_DELAY_ATTR);
      if (preDelay != null)
        cp.internalDelay =
            cp.internalDelay
                + (float)
                    UnitConverter.getTime(
                        Float.parseFloat(preDelay),
                        projUnitSystem,
                        UnitConverter.NEUROCONSTRUCT_UNITS);

      String postDelay = Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.POST_DELAY_ATTR);
      if (postDelay != null)
        cp.internalDelay =
            cp.internalDelay
                + (float)
                    UnitConverter.getTime(
                        Float.parseFloat(postDelay),
                        projUnitSystem,
                        UnitConverter.NEUROCONSTRUCT_UNITS);

      cp.weight =
          Float.parseFloat(Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.WEIGHT_ATTR));

      String propDelay = Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.PROP_DELAY_ATTR);
      if (propDelay != null)
        globAPDelay =
            (float)
                UnitConverter.getTime(
                    Float.parseFloat(propDelay),
                    projUnitSystem,
                    UnitConverter.NEUROCONSTRUCT_UNITS);

      logger.logComment("Found: " + cp);

      globConnProps.add(cp);
    } else if (g.getName().equals(NetworkMLConstants.INPUTS_ELEMENT)) {
      logger.logComment("Found the Inputs group");
      inInputs = true;

      String units = Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.UNITS_ATTR);

      inputUnitSystem = UnitConverter.getUnitSystemIndex(units);
    } else if (g.getName().startsWith(NetworkMLConstants.INPUT_ELEMENT) && inInputs) {
      // The table of input sites is within the input group so get sites from here

      String inputName = g.getName().substring(6);

      // String inputName = Hdf5Utils.getFirstStringValAttr(attrs,
      // NetworkMLConstants.INPUT_ELEMENT);

      logger.logComment("Found an Input: " + inputName);
      // inInput = true;

      if (project.elecInputInfo.getStim(inputName) == null) {
        throw new Hdf5Exception(
            "Error: there is an electrical input with name: "
                + inputName
                + " specified in "
                + "that file, but no such electrical input exists in the project. Add one to allow import of this file");
      }
      // Get the atributes of the Input and compare them with the attributes within the project
      // Test to find out what type of input this is

    } else if (g.getName().startsWith("IClamp") && inInputs) {
      String inputName = g.getParent().getName().substring(6);
      // Get the input sites from the table

      String cellGroup =
          Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.INPUT_TARGET_POPULATION_ATTR);
      if (cellGroup == null) {
        cellGroup =
            Hdf5Utils.getFirstStringValAttr(
                attrs, NetworkMLConstants.INPUT_TARGET_CELLGROUP_OLD_ATTR); // check old name
      }

      float readDelay =
          (float)
              UnitConverter.getTime(
                  Float.parseFloat(
                      Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.INPUT_DELAY_ATTR)),
                  inputUnitSystem,
                  UnitConverter.NEUROCONSTRUCT_UNITS);
      float readDuration =
          (float)
              UnitConverter.getTime(
                  Float.parseFloat(
                      Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.INPUT_DUR_ATTR)),
                  inputUnitSystem,
                  UnitConverter.NEUROCONSTRUCT_UNITS);
      float readAmp =
          (float)
              UnitConverter.getCurrent(
                  Float.parseFloat(
                      Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.INPUT_AMP_ATTR)),
                  inputUnitSystem,
                  UnitConverter.NEUROCONSTRUCT_UNITS);

      StimulationSettings nextStim = project.elecInputInfo.getStim(inputName);
      ElectricalInput myElectricalInput = nextStim.getElectricalInput();
      IClamp ic = (IClamp) myElectricalInput;

      logger.logComment("Found an IClamp Input");

      float currDelay = -1, currDur = -1, currAmp = -1;

      /*
      try
      {
          ic.getDelay().reset();
          currDelay = ic.getDelay().getNumber();
          ic.getDuration().reset();
          currDur = ic.getDuration().getNumber();
          ic.getAmplitude().reset();
          currAmp = ic.getAmplitude().getNumber();
      }
      catch (Exception ex)
      {
          logger.logError("Legacy error getting iclamp params!!");
      }*/

      currDelay = ic.getDel().getNominalNumber();
      currDur = ic.getDur().getNominalNumber();
      currAmp = ic.getAmp().getNominalNumber();

      if ((!project.elecInputInfo.getStim(inputName).getCellGroup().equals(cellGroup))
          || (readDelay != currDelay)
          || (readDuration != currDur)
          || (readAmp != currAmp)) {
        throw new Hdf5Exception(
            "Error: the input properties of the file do not match those in the project for input "
                + inputName
                + ""
                + "\nreadDelay: "
                + readDelay
                + ", currDelay: "
                + currDelay
                + "\nreadDuration: "
                + readDuration
                + ", currDur: "
                + currDur
                + "\nreadAmp: "
                + readAmp
                + ", currAmp: "
                + currAmp
                + ", str: "
                + Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.INPUT_AMP_ATTR));
      }
      currentInput = inputName;
    } else if (g.getName().startsWith("RandomSpikeTrain") && inInputs) {
      String inputName = g.getParent().getName().substring(6);
      // Get the input sites from the table
      String cellGroup =
          Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.INPUT_TARGET_POPULATION_ATTR);
      if (cellGroup == null) {
        cellGroup =
            Hdf5Utils.getFirstStringValAttr(
                attrs, NetworkMLConstants.INPUT_TARGET_CELLGROUP_OLD_ATTR); // check old name
      }

      float frequency =
          (float)
              UnitConverter.getRate(
                  Float.parseFloat(
                      Hdf5Utils.getFirstStringValAttr(
                          attrs, NetworkMLConstants.RND_STIM_FREQ_ATTR)),
                  inputUnitSystem,
                  UnitConverter.NEUROCONSTRUCT_UNITS);
      String mechanism =
          Hdf5Utils.getFirstStringValAttr(attrs, NetworkMLConstants.RND_STIM_MECH_ATTR);

      StimulationSettings nextStim = project.elecInputInfo.getStim(inputName);
      ElectricalInput myElectricalInput = nextStim.getElectricalInput();
      RandomSpikeTrain rs = (RandomSpikeTrain) myElectricalInput;

      logger.logComment("Found an Random Spike Train Input");

      if ((!project.elecInputInfo.getStim(inputName).getCellGroup().equals(cellGroup))
          || frequency != rs.getRate().getFixedNum()
          || !rs.getSynapseType().equals(mechanism)) {
        throw new Hdf5Exception(
            "Error: the input properties of the file do not match those in the project for input "
                + inputName);
      }
      currentInput = inputName;
    }
  }
Пример #14
0
  public static void generateMainPage(File mainFile, File sourceProjDir)
      throws IOException, ProjectFileParsingException, NeuroMLException {
    SimpleXMLElement root = new SimpleXMLElement("document");
    SimpleXMLElement header = new SimpleXMLElement("header");
    root.addChildElement(header);

    SimpleXMLElement title = new SimpleXMLElement("title");
    header.addChildElement(title);

    SimpleXMLElement body = new SimpleXMLElement("body");
    root.addChildElement(body);
    SimpleXMLElement intro = new SimpleXMLElement("p");
    body.addChildElement(intro);

    if (!mainFile.getParentFile().exists()) mainFile.getParentFile().mkdir();

    File targetDownloadDir = new File(mainFile.getParentFile(), "downloads");
    if (!targetDownloadDir.exists()) targetDownloadDir.mkdir();

    if (sourceProjDir.getName().indexOf("examples") >= 0) {
      title.addContent("neuroConstruct example projects");

      intro.addContent(
          "Downloadable neuroConstruct example projects. These <strong>illustrate the core "
              + "functionality of neuroConstruct</strong>, as opposed to providing electrophysiologically accurate "
              + "models. Projects based on published conductance based models can be found <a href=\"../models/index.html\">here</a>");
    }
    if (sourceProjDir.getName().indexOf("models") >= 0) {
      title.addContent("neuroConstruct projects based on published neuronal and network models");

      intro.addContent(
          "Downloadable neuroConstruct projects <strong>based on published conductance based models</strong>. "
              + "Some examples to illustrate the core functionality of neuroConstruct, as opposed to "
              + "providing electrophysiologically accurate models can be found <a href=\"../samples/index.html\">here</a>."
              + "<p>Note: These models are currently being moved to a repository to allow open source, collaborative development of NeuroML models.</p>"
              + "<p>See the <a href=\"http://www.opensourcebrain.org\">Open Source Brain</a> website for full details.&nbsp;&nbsp;&nbsp;&nbsp;"
              + "<img alt=\"Open Source Brain\" src=\"http://www.opensourcebrain.org/images/logo.png\"/></p>");
    }
    File[] fileArray = sourceProjDir.listFiles();

    fileArray = GeneralUtils.reorderAlphabetically(fileArray, true);

    ArrayList<File> files = GeneralUtils.toArrayList(fileArray);
    // if (files.contains(""))

    ArrayList<String> toIgnore = new ArrayList<String>();
    // toIgnore.add("Thalamocortical"); // temporarily
    // toIgnore.add("CA1PyramidalCell"); // temporarily
    // toIgnore.add("SolinasEtAl-GolgiCell"); // temporarily

    for (File exProjDir : files) {
      File morphDir = new File(exProjDir, "cellMechanisms");

      if (morphDir.isDirectory() && !toIgnore.contains(exProjDir.getName())) {
        String projName = exProjDir.getName();
        SimpleXMLElement section = new SimpleXMLElement("section");
        body.addChildElement(section);

        SimpleXMLElement secTitle = new SimpleXMLElement("title");
        section.addChildElement(secTitle);
        secTitle.addContent(projName);

        SimpleXMLElement anchor = new SimpleXMLElement("anchor");
        section.addChildElement(anchor);
        anchor.addAttribute("id", projName);

        SimpleXMLElement table = new SimpleXMLElement("table");

        section.addChildElement(table);

        SimpleXMLElement row = new SimpleXMLElement("tr");
        table.addChildElement(row);

        String largeImg = "large.png";
        String smallImg = "small.png";

        File targetImageDir = new File(mainFile.getParentFile(), "images");
        if (!targetImageDir.exists()) targetImageDir.mkdir();

        File targetProjImageDir = new File(targetImageDir, projName);

        if (!targetProjImageDir.exists()) targetProjImageDir.mkdir();

        File smallImgFile = new File(exProjDir, "images/" + smallImg);
        File largeImgFile = new File(exProjDir, "images/" + largeImg);

        if (smallImgFile.exists()) {
          GeneralUtils.copyFileIntoDir(smallImgFile, targetProjImageDir);

          SimpleXMLElement col2 = new SimpleXMLElement("td");
          row.addChildElement(col2);
          col2.addAttribute("width", "120");

          SimpleXMLElement secImg = new SimpleXMLElement("p");
          col2.addChildElement(secImg);

          SimpleXMLElement img = new SimpleXMLElement("img");
          img.addAttribute("src", "images/" + projName + "/small.png");
          img.addAttribute("alt", "Screenshot of " + projName);

          if (largeImgFile.exists()) {
            GeneralUtils.copyFileIntoDir(largeImgFile, targetProjImageDir);

            SimpleXMLElement imgRef = new SimpleXMLElement("a");
            img.addAttribute("title", "Click to enlarge");
            imgRef.addAttribute("href", "images/" + projName + "/" + largeImg);
            imgRef.addChildElement(img);
            secImg.addChildElement(imgRef);
          } else {
            secImg.addChildElement(img);
          }
        }

        SimpleXMLElement secIntro = new SimpleXMLElement("p");
        SimpleXMLElement colMid = new SimpleXMLElement("td");
        SimpleXMLElement colRight = new SimpleXMLElement("td");
        row.addChildElement(colMid);
        row.addChildElement(colRight);
        colRight.addAttribute("width", "150");
        colMid.addChildElement(secIntro);
        secIntro.addContent("Project name: <strong>" + projName + "</strong>");

        File projFile = ProjectStructure.findProjectFile(exProjDir);

        Project project = Project.loadProject(projFile, null);
        String descFull = project.getProjectDescription();
        String breakpoint = "\n\n";
        String descShort = new String(descFull);

        if (descFull.indexOf(breakpoint) > 0) {
          descShort = descFull.substring(0, descFull.indexOf(breakpoint));
        }

        SimpleXMLElement desc = new SimpleXMLElement("p");
        colMid.addChildElement(desc);
        desc.addContent(GeneralUtils.parseForHyperlinks(descShort));

        SimpleXMLElement modified = new SimpleXMLElement("p");
        colMid.addChildElement(modified);

        SimpleDateFormat formatter = new SimpleDateFormat("EEEE MMMM d, yyyy");

        java.util.Date date = new java.util.Date(projFile.lastModified());

        modified.addContent("Project last modified: " + formatter.format(date));

        File zipFile = null;
        String zipFileName =
            targetDownloadDir.getAbsolutePath()
                + "/"
                + projName
                + ProjectStructure.getNewProjectZipFileExtension();

        ArrayList<String> ignore = new ArrayList<String>();
        ArrayList<String> ignoreNone = new ArrayList<String>();
        ArrayList<String> ignoreExtns = new ArrayList<String>();

        ignore.add("i686");
        ignore.add("x86_64");
        ignore.add(".svn");
        ignore.add("simulations");
        ignore.add("generatedNEURON");
        ignore.add("generatedNeuroML");
        ignore.add("generatedGENESIS");
        ignore.add("generatedMOOSE");
        ignore.add("generatedPyNN");
        ignore.add("generatedPSICS");
        ignore.add("dataSets");
        ignoreExtns.add("bak");

        zipFile = ZipUtils.zipUp(exProjDir, zipFileName, ignore, ignoreExtns);

        logger.logComment(
            "The zip file: "
                + zipFile.getAbsolutePath()
                + " ("
                + zipFile.length()
                + " bytes)  contains all of the project files");

        SimpleXMLElement downloads = new SimpleXMLElement("p");
        colRight.addChildElement(downloads);
        downloads.addContent("Downloads<a href=\"#downloadInfo\">*</a>:");

        SimpleXMLElement downloadProj = new SimpleXMLElement("p");
        colRight.addChildElement(downloadProj);

        SimpleXMLElement link = new SimpleXMLElement("a");
        link.addAttribute("href", "downloads/" + zipFile.getName());
        link.addContent("neuroConstruct project");
        link.addAttribute("title", "Download full project for loading into neuroConstruct");
        downloadProj.addChildElement(link);

        ArrayList<String> noNeuroML = new ArrayList<String>();
        noNeuroML.add("Ex3_Morphology");
        noNeuroML.add("DentateGyrus");
        noNeuroML.add("RothmanEtAl_KoleEtAl_PyrCell");

        if (!noNeuroML.contains(projName)) {
          project.neuromlFileManager.generateNeuroMLFiles(
              null, new OriginalCompartmentalisation(), 1234, false);

          File neuroMLDir = ProjectStructure.getNeuroML1Dir(project.getProjectMainDirectory());

          String nmlZipFileName =
              targetDownloadDir.getAbsolutePath() + "/" + projName + "_NeuroML.zip";

          zipFile = ZipUtils.zipUp(neuroMLDir, nmlZipFileName, ignoreNone, ignoreNone);

          SimpleXMLElement downloadNml = new SimpleXMLElement("p");
          colRight.addChildElement(downloadNml);
          // downloadNml.addContent("Download project as pure NeuroML: ");

          SimpleXMLElement img = new SimpleXMLElement("img");
          img.addAttribute("src", "../images/NeuroMLSmall.png");
          String info = "Download core project elements in NeuroML format";
          img.addAttribute("alt", info);

          SimpleXMLElement imgRef = new SimpleXMLElement("a");
          img.addAttribute("title", info);
          imgRef.addAttribute("href", "downloads/" + zipFile.getName());
          imgRef.addChildElement(img);

          downloadNml.addChildElement(imgRef);
        }
      }
    }

    SimpleXMLElement end = new SimpleXMLElement("p");
    body.addChildElement(end);
    end.addContent("&nbsp;");

    SimpleXMLElement infoDlanchor = new SimpleXMLElement("anchor");
    body.addChildElement(infoDlanchor);
    end.addAttribute("id", "downloadInfo");

    SimpleXMLElement infoDl = new SimpleXMLElement("p");
    body.addChildElement(infoDl);
    end.addContent(
        "* Note: neuroConstruct project downloads (most of which are included with the standard software distribution) "
            + "can be loaded directly into neuroConstruct to generate cell and network scripts for NEURON, GENESIS, etc.,"
            + " but NeuroML downloads just consist of the core elements of the project"
            + " (morphologies, channels, etc.) which have been exported in NeuroML format. The latter can be useful for testing NeuroML compliant applications. "
            + "If no NeuroML download link is present, this usually indicates that the model is mainly implemented using channel/synapse mechanisms in a simulator's "
            + "native language (e.g. mod files) which have not fully been converted to ChannelML yet.");

    SimpleXMLElement end2 = new SimpleXMLElement("p");
    body.addChildElement(end2);
    end2.addContent("&nbsp;");

    FileWriter fw = null;
    try {

      fw = new FileWriter(mainFile);
      fw.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); // quick hack, todo: add to
      // SimpleXMLDoc...

      fw.write(
          "<!DOCTYPE document PUBLIC \"-//APACHE//DTD Documentation V2.0//EN\" \"http://forrest.apache.org/dtd/document-v20.dtd\">\n\n");
      fw.write(root.getXMLString("", false));

      fw.flush();
      fw.close();

    } catch (IOException ex) {
      logger.logError("Problem: ", ex);
      fw.close();
    }

    /*
             <header>
      <title>Examples of neuroConstruct in use</title>
    </header>
    <body>
        <p>Some screenshots of neuroConstruct in action are given below.
        Click on the thumbnails to see a full size version of the screenshots</p>

      <section>
        <title>Examples included with distribution</title>*/

  }
Пример #15
0
 /** Here to support saving of Unit via XMLEncoder */
 public Unit() {
   logger.logComment("Calling Unit()");
 }
Пример #16
0
  public void dataSet(Dataset d) throws Hdf5Exception {
    logger.logComment("-----   Looking through dataset: " + d);

    ArrayList<Attribute> attrs = Hdf5Utils.parseDatasetForAttributes(d);

    for (Attribute attribute : attrs) {
      logger.logComment(
          "Dataset: "
              + d.getName()
              + " has attribute: "
              + attribute.getName()
              + " = "
              + Hdf5Utils.getFirstStringValAttr(attrs, attribute.getName()));
    }

    float[][] data = Hdf5Utils.parse2Ddataset(d);

    logger.logComment("Data has size: (" + data.length + ", " + data[0].length + ")");

    if (inPopulations && currentCellGroup != null) {
      for (int i = 0; i < data.length; i++) {
        int id = (int) data[i][0];
        float x = data[i][1];
        float y = data[i][2];
        float z = data[i][3];

        PositionRecord posRec = new PositionRecord(id, x, y, z);

        if (data[0].length == 5) {
          posRec.setNodeId((int) data[i][4]);
        }

        this.project.generatedCellPositions.addPosition(currentCellGroup, posRec);
      }
    }
    if (inProjections && currentNetConn != null) {
      logger.logComment("Adding info for NetConn: " + currentNetConn);

      int id_col = -1;

      int pre_cell_id_col = -1;
      int pre_segment_id_col = -1;
      int pre_fraction_along_col = -1;

      int post_cell_id_col = -1;
      int post_segment_id_col = -1;
      int post_fraction_along_col = -1;

      int prop_delay_col = -1;

      for (Attribute attribute : attrs) {
        String storedInColumn = Hdf5Utils.getFirstStringValAttr(attrs, attribute.getName());

        if (storedInColumn.equals(NetworkMLConstants.CONNECTION_ID_ATTR)) {
          id_col = Integer.parseInt(attribute.getName().substring("column_".length()));
          logger.logComment("id col: " + id_col);
        } else if (storedInColumn.equals(NetworkMLConstants.PRE_CELL_ID_ATTR)) {
          pre_cell_id_col = Integer.parseInt(attribute.getName().substring("column_".length()));
        } else if (storedInColumn.equals(NetworkMLConstants.PRE_SEGMENT_ID_ATTR)) {
          pre_segment_id_col = Integer.parseInt(attribute.getName().substring("column_".length()));
          logger.logComment("pre_segment_id_col: " + pre_segment_id_col);
        } else if (storedInColumn.equals(NetworkMLConstants.PRE_FRACT_ALONG_ATTR)) {
          pre_fraction_along_col =
              Integer.parseInt(attribute.getName().substring("column_".length()));
          logger.logComment("pre_fraction_along_col: " + pre_fraction_along_col);
        } else if (storedInColumn.equals(NetworkMLConstants.POST_CELL_ID_ATTR)) {
          post_cell_id_col = Integer.parseInt(attribute.getName().substring("column_".length()));
        } else if (storedInColumn.equals(NetworkMLConstants.POST_SEGMENT_ID_ATTR)) {
          post_segment_id_col = Integer.parseInt(attribute.getName().substring("column_".length()));
        } else if (storedInColumn.equals(NetworkMLConstants.POST_FRACT_ALONG_ATTR)) {
          post_fraction_along_col =
              Integer.parseInt(attribute.getName().substring("column_".length()));
        } else if (storedInColumn.startsWith(NetworkMLConstants.PROP_DELAY_ATTR)) {
          prop_delay_col = Integer.parseInt(attribute.getName().substring("column_".length()));
        }

        for (String synType : getConnectionSynTypes()) {
          if (storedInColumn.endsWith(synType)) {
            ConnSpecificProps cp = null;

            for (ConnSpecificProps currCp : localConnProps) {
              if (currCp.synapseType.equals(synType)) cp = currCp;
            }
            if (cp == null) {
              cp = new ConnSpecificProps(synType);
              cp.internalDelay = -1;
              cp.weight = -1;
              localConnProps.add(cp);
            }

            if (storedInColumn.startsWith(NetworkMLConstants.INTERNAL_DELAY_ATTR)) {
              cp.internalDelay =
                  Integer.parseInt(
                      attribute
                          .getName()
                          .substring("column_".length())); // store the col num temporarily..
            }
            if (storedInColumn.startsWith(NetworkMLConstants.WEIGHT_ATTR)) {
              cp.weight =
                  Integer.parseInt(
                      attribute
                          .getName()
                          .substring("column_".length())); // store the col num temporarily..
            }
          }
        }
      }

      for (int i = 0; i < data.length; i++) {
        int pre_seg_id = 0;
        float pre_fract_along = 0.5f;
        int post_seg_id = 0;
        float post_fract_along = 0.5f;

        int id = (int) data[i][id_col];
        int pre_cell_id = (int) data[i][pre_cell_id_col];
        int post_cell_id = (int) data[i][post_cell_id_col];

        float prop_delay = 0;

        if (pre_segment_id_col >= 0) pre_seg_id = (int) data[i][pre_segment_id_col];
        if (pre_fraction_along_col >= 0) pre_fract_along = data[i][pre_fraction_along_col];
        if (post_segment_id_col >= 0) post_seg_id = (int) data[i][post_segment_id_col];
        if (post_fraction_along_col >= 0) post_fract_along = data[i][post_fraction_along_col];

        // (float)UnitConverter.getTime(XXXXXXXXX, UnitConverter.NEUROCONSTRUCT_UNITS,
        // unitSystem)+"";
        if (prop_delay_col >= 0)
          prop_delay =
              (float)
                  UnitConverter.getTime(
                      data[i][prop_delay_col], projUnitSystem, UnitConverter.NEUROCONSTRUCT_UNITS);

        ArrayList<ConnSpecificProps> props = new ArrayList<ConnSpecificProps>();

        if (localConnProps.size() > 0) {
          for (ConnSpecificProps currCp : localConnProps) {
            logger.logComment("Pre cp: " + currCp);
            ConnSpecificProps cp2 = new ConnSpecificProps(currCp.synapseType);

            if (currCp.internalDelay > 0) // index was stored in this val...
            cp2.internalDelay =
                  (float)
                      UnitConverter.getTime(
                          data[i][(int) currCp.internalDelay],
                          projUnitSystem,
                          UnitConverter.NEUROCONSTRUCT_UNITS);
            if (currCp.weight > 0) // index was stored in this val...
            cp2.weight = data[i][(int) currCp.weight];

            logger.logComment("Filled cp: " + cp2);

            props.add(cp2);
          }
        }

        this.project.generatedNetworkConnections.addSynapticConnection(
            currentNetConn,
            GeneratedNetworkConnections.MORPH_NETWORK_CONNECTION,
            pre_cell_id,
            pre_seg_id,
            pre_fract_along,
            post_cell_id,
            post_seg_id,
            post_fract_along,
            prop_delay,
            props);
      }
    }
    if (inInputs && currentInput != null) {
      logger.logComment("Adding info for: " + currentInput);
      StimulationSettings nextStim = project.elecInputInfo.getStim(currentInput);
      ElectricalInput myElectricalInput = nextStim.getElectricalInput();
      String electricalInputType = myElectricalInput.getType();
      String cellGroup = nextStim.getCellGroup();

      for (int i = 0; i < data.length; i++) {
        Float fileCellId = data[i][0];
        Float fileSegmentId = data[i][1];
        Float fractionAlong = data[i][2];
        int cellId = fileCellId.intValue();
        int segmentId = fileSegmentId.intValue();

        SingleElectricalInput singleElectricalInputFromFile =
            new SingleElectricalInput(
                electricalInputType, cellGroup, cellId, segmentId, fractionAlong, null);

        this.project.generatedElecInputs.addSingleInput(
            currentInput, singleElectricalInputFromFile);
      }
    }
  }
  protected Point3f generateNextPosition() throws CellPackingException {
    Point3f proposedPoint = null;

    logger.logComment(
        "----   Generating next position. positionsAlreadyTaken.size() = "
            + getNumPosAlreadyTaken());

    float minXLoc, minYLoc, minZLoc, maxXLoc, maxYLoc, maxZLoc;

    if (mustBeCompletelyInsideRegion()) {
      // limit the extent for possible location of soma centre to box which
      // will preclude soma wall impacting region boundary.

      minXLoc = myRegion.getLowestXValue() - CellTopologyHelper.getMinXExtent(myCell, true, false);
      minYLoc = myRegion.getLowestYValue() - CellTopologyHelper.getMinYExtent(myCell, true, false);
      minZLoc = myRegion.getLowestZValue() - CellTopologyHelper.getMinZExtent(myCell, true, false);

      maxXLoc = myRegion.getHighestXValue() - CellTopologyHelper.getMaxXExtent(myCell, true, false);
      maxYLoc = myRegion.getHighestYValue() - CellTopologyHelper.getMaxYExtent(myCell, true, false);
      maxZLoc = myRegion.getHighestZValue() - CellTopologyHelper.getMaxZExtent(myCell, true, false);
    } else {
      // in this case the soma centre can be anywhere inside the region..

      minXLoc = myRegion.getLowestXValue();
      minYLoc = myRegion.getLowestYValue();
      minZLoc = myRegion.getLowestZValue();

      maxXLoc = myRegion.getHighestXValue();
      maxYLoc = myRegion.getHighestYValue();
      maxZLoc = myRegion.getHighestZValue();
    }

    Point3f startPoint = new Point3f(minXLoc, minYLoc, minZLoc);

    logger.logComment("minXLoc: " + minXLoc + ", maxXLoc: " + maxXLoc);

    if (maxXLoc - minXLoc < 0 || maxYLoc - minYLoc < 0 || maxZLoc - minZLoc < 0) {
      throw new CellPackingException("Diameter of cell is smaller than region");
    }

    if (getNumPosAlreadyTaken() >= getNumberCells()) {
      throw new CellPackingException("All cells successfully placed");
    }

    if (getNumberCells() == 0) {
      throw new CellPackingException("Cell number set to zero!!");
    } else if (getNumberCells() == 1) {
      if (parameterList[DIMENSION_PARAM].value == DIMENSION_PARAM_X) {
        proposedPoint = new Point3f((minXLoc + maxXLoc) / 2, minYLoc, minZLoc);

      } else if (parameterList[DIMENSION_PARAM].value == DIMENSION_PARAM_Y) {
        proposedPoint = new Point3f(minXLoc, (minYLoc + maxYLoc) / 2, minZLoc);

      } else if (parameterList[DIMENSION_PARAM].value == DIMENSION_PARAM_Z) {

        proposedPoint = new Point3f(minXLoc, minYLoc, (minZLoc + maxZLoc) / 2);
      }

    } else {

      // Point3f lastPositionedPoint = getLastPosTaken();

      if (parameterList[DIMENSION_PARAM].value == DIMENSION_PARAM_X) {
        float distanceApart = (maxXLoc - minXLoc) / (getNumberCells() - 1);

        proposedPoint = new Point3f(startPoint);
        proposedPoint.add(new Point3f(distanceApart * numProposedPoints, 0, 0));

        logger.logComment(
            "Placing one of "
                + getNumberCells()
                + " cells in x dim..."
                + distanceApart
                + " apart, new: "
                + proposedPoint
                + ", already proposed: "
                + numProposedPoints);

        if (proposedPoint.x > maxXLoc) throw new CellPackingException("Reached end of x dimension");
      } else if (parameterList[DIMENSION_PARAM].value == DIMENSION_PARAM_Y) {
        logger.logComment("Placing cell in y dim...");
        float distanceApart = (maxYLoc - minYLoc) / (getNumberCells() - 1);
        proposedPoint = new Point3f(startPoint);
        proposedPoint.add(new Point3f(0, distanceApart * numProposedPoints, 0));

        if (proposedPoint.y > maxYLoc) throw new CellPackingException("Reached end of y dimension");
      } else if (parameterList[DIMENSION_PARAM].value == DIMENSION_PARAM_Z) {
        logger.logComment("Placing cell in z dim...");
        float distanceApart = (maxZLoc - minZLoc) / (getNumberCells() - 1);
        proposedPoint = new Point3f(startPoint);
        proposedPoint.add(new Point3f(0, 0, distanceApart * numProposedPoints));
        if (proposedPoint.z > maxZLoc) throw new CellPackingException("Reached end of z dimension");
      }

      if (proposedPoint == null) throw new CellPackingException("Cannot successfully place cell.");
    }
    // lastProposedPoint = new Point3d(proposedPoint);
    numProposedPoints++;

    return new Point3f(proposedPoint);
  }