@Override
  public String toString() {
    StringBuilder sb = new StringBuilder();

    sb.append("GeneratedElecInputs with " + this.getNumberSingleInputs() + " inputs in total\n");

    Enumeration keys = this.myElecInputs.keys();

    while (keys.hasMoreElements()) {
      String input = (String) keys.nextElement();
      ArrayList<SingleElectricalInput> singleInputList = myElecInputs.get(input);
      StimulationSettings ss = project.elecInputInfo.getStim(input);
      sb.append(
          input + " (" + ss.toLongString() + ") has " + singleInputList.size() + " entries.\n");
      for (int i = 0; (i < singleInputList.size() && i < 9); i++) {
        SingleElectricalInput sei = singleInputList.get(i);
        sb.append("   Input " + i + ": " + sei.toString());
        if (sei.getInstanceProps() != null)
          sb.append(" (" + sei.getInstanceProps().details(false) + ")");

        sb.append("\n");
      }
    }
    return sb.toString();
  }
  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;
  }