コード例 #1
0
ファイル: IrisVisualizer.java プロジェクト: jbudynk/iris
  private synchronized void display(ExtSed sed) {

    manageAssociatedManagerWindows(sed);

    try {

      SpectrumContainer container =
          (SpectrumContainer) sed.getAttachment(IrisDisplayManager.FIT_MODEL);

      // There is no Sed attachment, so build a model manager and attach it.

      if (container == null) {
        if (buildAttachment(sed)) {
          return;
        }
      }

      // VAOPD-879: spectrum name must be identical with Sed name.
      if (container != null) {
        container.getSpectrum().setName(sed.getId());
      }

      // Now display the Sed.

      idm.display(sed, sed.getId());

      // and add its frame to the workspace.

      JInternalFrame frame = idm.getInternalFrame();

      // VAOPD-863
      frame.setTitle(sed.getId());

      if (container != null) {
        JFrame modelManagerFrame = container.getModelManager().getFrame();
        if (modelManagerFrame != null) {
          modelManagerFrame.setTitle(sed.getId());
        }
      }

      if (frame != currentFrame) {
        lastLocation = null;
        disposeCurrentFrame();
        currentFrame = frame;
        currentFrame.setDefaultCloseOperation(JInternalFrame.HIDE_ON_CLOSE);
        if (lastLocation != null) {
          currentFrame.setLocation(lastLocation);
        }
        frame.setTitle("Iris Visualizer");
        ws.addFrame(frame);
      }

    } catch (Exception ex) {
      LogEvent.getInstance().fire(this, new LogEntry("Error: " + ex.getMessage(), sed));
      Logger.getLogger("IrisVisualizer").log(Level.SEVERE, null, ex);
    }
  }
コード例 #2
0
  public ExtSed interpolate(ExtSed sed, InterpolationConfig interpConf) throws Exception {

    if (sed.getNumberOfSegments() == 0) {
      throw new SedNoDataException();
    }

    ExtSed newsed = ExtSed.flatten(sed, "Angstrom", "Jy");

    String intervUnits = interpConf.getUnits();
    Double xmin = interpConf.getXMin();
    Double xmax = interpConf.getXMax();

    if (xmin > Double.NEGATIVE_INFINITY)
      xmin = um.convertX(new double[] {xmin}, intervUnits, "Angstrom")[0];

    if (xmax < Double.POSITIVE_INFINITY)
      xmax = um.convertX(new double[] {xmax}, intervUnits, "Angstrom")[0];

    interpConf.setXMin(Math.min(xmin, xmax));
    interpConf.setXMax(Math.max(xmin, xmax));

    interpConf.setX(newsed.getSegment(0).getSpectralAxisValues());
    interpConf.setY(newsed.getSegment(0).getFluxAxisValues());
    SAMPMessage message =
        SAMPFactory.createMessage(INTERPOLATE_MTYPE, interpConf, InterpolationPayload.class);
    Response rspns = client.sendMessage(message);

    InterpolationPayload response =
        (InterpolationPayload) SAMPFactory.get(rspns.getResult(), InterpolationPayload.class);

    if (xmin > Double.NEGATIVE_INFINITY)
      xmin = um.convertX(new double[] {xmin}, "Angstrom", intervUnits)[0];

    if (xmax < Double.POSITIVE_INFINITY)
      xmax = um.convertX(new double[] {xmax}, "Angstrom", intervUnits)[0];

    interpConf.setXMin(Math.min(xmin, xmax));
    interpConf.setXMax(Math.max(xmin, xmax));

    double[] x = um.convertX(response.getX(), "Angstrom", intervUnits);

    Segment segment = new Segment();
    segment.setSpectralAxisValues(x);
    segment.setFluxAxisValues(response.getY());
    segment.setTarget(sed.getSegment(0).getTarget());
    segment.setSpectralAxisUnits(intervUnits);
    segment.setFluxAxisUnits("Jy");
    String ucd = "em.wl";
    if (intervUnits.equals("Hz")) ucd = "em.freq";
    else if (intervUnits.equals("keV")) ucd = "em.energy";
    segment.createChar().createSpectralAxis().setUcd(ucd);
    segment.createChar().createFluxAxis().setUcd("phot.flux.density;" + ucd);

    ExtSed newSed = manager.newSed(sed.getId() + "_" + interpConf.getMethod().replaceAll(" ", ""));
    newSed.addSegment(segment);
    newSed.checkChar();

    return newSed;
  }
コード例 #3
0
ファイル: IrisVisualizer.java プロジェクト: jbudynk/iris
  public void invalidateModel(ExtSed sed) {
    if (sed != null) {
      SpectrumContainer container =
          (SpectrumContainer) sed.getAttachment(IrisDisplayManager.FIT_MODEL);
      if (container != null) {

        ModelManager2 mm = container.getModelManager();
        if (mm != null && mm.isActive()) {
          mm.dispose();
        }

        sed.removeAttachment(IrisDisplayManager.FIT_MODEL);
      }
    }
  }
コード例 #4
0
ファイル: IrisVisualizer.java プロジェクト: jbudynk/iris
  private void manageAssociatedManagerWindows(ExtSed sed) {

    ExtSed displaying = idm.getDisplaying();

    if (displaying != null) {
      if (!sed.getId().equals(displaying.getId())) {

        // displayed Sed is exiting: make its model manager and metadata windows invisible.

        SpectrumContainer container =
            (SpectrumContainer) displaying.getAttachment(IrisDisplayManager.FIT_MODEL);

        if (container != null) {

          ModelManager2 modelManager = container.getModelManager();
          modelManager.setVisible(false);
          SpectrumVisualEditor editor = idm.getVisualEditor();

          if (editor != null) {
            editor.getJFrame().setVisible(false);
          }
        }

        // new Sed is entering display: make its model manager window visible if active.

        if (sed != null) {

          container = (SpectrumContainer) sed.getAttachment(IrisDisplayManager.FIT_MODEL);

          if (container != null) {
            ModelManager2 modelManager = container.getModelManager();
            modelManager.setVisible(modelManager.isActive());
          }
        }
      }
    }
  }
コード例 #5
0
ファイル: IrisVisualizer.java プロジェクト: jbudynk/iris
  public boolean buildAttachment(ExtSed sed)
      throws SedNoDataException, SedInconsistentException, SpectrumException {

    Spectrum sp = factory.readAllSegments(null, sed);

    if (sp == null) {
      return true;
    }

    sp.setName(sed.getId());

    JDesktopPane desktop = ws.getDesktop();
    SherpaModelManager modelManager = new SherpaModelManager(sp, idm.getSAMPConnector(), desktop);
    modelManager.setActive(false);

    SpectrumContainer container = new SpectrumContainer(sp, modelManager);
    sed.addAttachment(IrisDisplayManager.FIT_MODEL, container);

    // This is needed to capture the 'Quit' button action
    // that comes from the model manager GUI.
    modelManager.setCallbackOnDispose(new OnDisposeCommand(sed));

    return false;
  }
コード例 #6
0
  @Test
  public void testStacker() throws Exception {
    ExtSed sed1 = new ExtSed("Sed1");
    ExtSed sed2 = new ExtSed("Sed2");
    ExtSed sed3 = new ExtSed("Sed3");

    Segment seg1 = new Segment();

    for (int k = 0; k < x1.length; k++) {
      y1[k] = y1[k] * 1e23;
      yerr1[k] = yerr1[k] * 1e23;
    }
    seg1.setFluxAxisValues(y1);
    seg1.setSpectralAxisValues(x1);
    seg1.setFluxAxisUnits("Jy");
    seg1.setSpectralAxisUnits("Angstrom");
    seg1.setDataValues(yerr1, UTYPE.FLUX_STAT_ERROR);
    sed1.addSegment(seg1);

    Segment seg2 = new Segment();
    seg2.setFluxAxisValues(y2);
    seg2.setSpectralAxisValues(x2);
    seg2.setFluxAxisUnits("erg/s/cm2/Hz");
    seg2.setSpectralAxisUnits("Angstrom");
    seg2.setDataValues(yerr2, UTYPE.FLUX_STAT_ERROR);
    sed2.addSegment(seg2);

    Segment seg3 = new Segment();
    seg3.setFluxAxisValues(y3);

    // convert the values in x3 to nm so I can test the unit conversions
    // too.
    int k = 0;
    for (double x : x3) {
      x3[k] = x * 0.1;
      k++;
    }
    seg3.setSpectralAxisValues(x3);
    seg3.setFluxAxisUnits("erg/s/cm2/Hz");
    seg3.setSpectralAxisUnits("nm");
    seg3.setDataValues(yerr3, UTYPE.FLUX_STAT_ERROR);
    sed3.addSegment(seg3);

    SedStack stack = new SedStack("Stack");
    stack.add(sed1);
    stack.add(sed2);
    stack.add(sed3);

    // setup the stacking configuration
    StackConfiguration config = new StackConfiguration();
    config.setBinsize(2.0);
    config.setBinsizeUnit("Angstrom");
    config.setLogbin(false);
    config.setSmooth(false);
    config.setSmoothBinsize(20.);
    config.setStatistic("avg");
    config.setYUnits("erg/s/cm2/Hz");

    // stack
    stacker = new SedStackerStacker(client, (UnitsManager) null);
    ExtSed result = stacker.stack(stack, config);

    List<double[]> xs = new ArrayList<>();
    List<double[]> ys = new ArrayList<>();
    xs.add(x1);
    xs.add(x2);
    xs.add(x3);
    ys.add(y1);
    ys.add(y2);
    ys.add(y3);

    // stack.getOrigSeds() should return original seds
    for (int j = 0; j < stack.getOrigSeds().size(); j++) {
      ExtSed origSed = stack.getOrigSeds().get(j);
      double[] x = xs.get(j);
      double[] y = ys.get(j);

      for (int i = 0; i < stack.getOrigSeds().get(j).getSegment(0).getLength(); i++) {
        double xOrigValue = origSed.getSegment(0).getSpectralAxisValues()[i];
        double yOrigValue = origSed.getSegment(0).getFluxAxisValues()[i];
        assertEquals(xOrigValue, x[i], EPSILON);
        assertEquals(yOrigValue, y[i], EPSILON);
      }
    }

    double[] controlY =
        new double[] {5.0, 5.36666667, 4.5, 2.66666667, 4.0, 6.5, 1.5, 10.5, 5.0, 10.0};
    double[] controlX = new double[] {0., 2., 4., 6., 8., 10., 16., 22., 50., 100.};
    // double[] controlYerr = new double[] {0.5, 0.501120965, 0.3640055,
    // 0.18104634, 0.4, 0.48102899, 0.15, 1.05, 0.5, 1.0}; // calculated
    // from errors [sqrt(sum(errors^2))/N]
    double[] controlYerr =
        new double[] {0, 6.82169741, 2.5, 1.64991582, 0., 5.21216526, 0., 0., 0., 0.}; // calculated
    // from
    // stddev(flux)
    double[] controlCounts = new double[] {1, 3, 2, 3, 1, 3, 1, 1, 1, 1};

    // test values of stacked Sed
    double[] yerrValues = (double[]) result.getSegment(0).getDataValues(UTYPE.FLUX_STAT_ERROR);
    double[] counts = (double[]) result.getAttachment(COUNTS);
    for (int i = 0; i < result.getSegment(0).getLength(); i++) {
      double xValue = result.getSegment(0).getSpectralAxisValues()[i];
      double yValue = result.getSegment(0).getFluxAxisValues()[i];
      assertEquals(controlX[i], xValue, EPSILON);
      assertEquals(controlY[i], yValue, EPSILON);
      assertEquals(controlYerr[i], yerrValues[i], EPSILON);
      assertEquals(controlCounts[i], counts[i], EPSILON);
    }
  }
コード例 #7
0
ファイル: IrisVisualizer.java プロジェクト: jbudynk/iris
 public void execute(Object o) {
   sed.removeAttachment(IrisDisplayManager.FIT_MODEL);
   idm.removeVisualEditor();
   display(sed);
 }
コード例 #8
0
ファイル: IrisVisualizer.java プロジェクト: jbudynk/iris
 private void remove(ExtSed source) {
   invalidateModel(source); // Might be needed in the future?
   idm.remove(source.getId());
 }
コード例 #9
0
  public void testWriteAscii() throws Exception {

    URL fileURL = SaveSedDialog.class.getResource("/test_data/3c273.xml");

    Sed s = Sed.read(fileURL.openStream(), SedFormat.VOT);
    List<Segment> segList = new ArrayList<>();
    // To assign the RA and DEC correctly, in case the pos.eq is in
    // SpatialAxis.Coverage.Location rather than Target.Pos
    for (int i = 0; i < s.getNumberOfSegments(); i++) {
      Segment seg = s.getSegment(i);
      if (s.getSegment(i).createTarget().getPos() == null) {
        if (seg.createChar().createSpatialAxis().createCoverage().getLocation() != null) {
          seg.createTarget()
              .createPos()
              .setValue(seg.getChar().getSpatialAxis().getCoverage().getLocation().getValue());
        } else {
          seg.createTarget()
              .createPos()
              .setValue(
                  new DoubleParam[] {new DoubleParam(Double.NaN), new DoubleParam(Double.NaN)});
        }
      }
      segList.add(s.getSegment(i));
    }

    ExtSed sed = new ExtSed(fileURL.getPath());
    sed.addSegment(segList);

    File output = File.createTempFile("writeAsciiTest_3c273", ".dat");

    SaveSedDialog ssd = new SaveSedDialog(SedBuilder.getWorkspace().getRootFrame(), sed, false);
    ssd.setXunit("Hz");
    ssd.setYunit("erg/s/cm2/Angstrom");
    ssd.setFilePath("file:///" + output.getPath());
    ssd.writeAscii(sed, output, false);

    URL url = new URL(ssd.getFilePath());
    SetupBean result = new AsciiConf().makeConf(url);
    Segment segment = SegmentImporter.getSegments(result).get(0);

    assertEquals(segment.getSpectralAxisUnits(), "Hz");
    assertEquals(segment.getFluxAxisUnits(), "erg/s/cm2/Angstrom");

    // Test SED created in Science window (from calculated fluxes
    File output2 = File.createTempFile("writeAsciiTest_3c273-2", ".dat");
    ssd.setFilePath("file:///" + output2.getPath());
    ssd.writeAscii(sed, output2, true);

    URL url2 = new URL(ssd.getFilePath());

    URLConnection urlConnection = url2.openConnection();
    BufferedReader bufferedReader =
        new BufferedReader(new InputStreamReader(urlConnection.getInputStream()));

    String line;
    String metadata = "";

    while ((line = bufferedReader.readLine()).startsWith("#")) {
      metadata = metadata + line;
    }

    SetupBean result2 = new AsciiConf().makeConf(url2);
    Segment segment2 = SegmentImporter.getSegments(result2).get(0);

    assertEquals(segment2.getSpectralAxisUnits(), "Hz");
    assertEquals(segment2.getFluxAxisUnits(), "erg/s/cm2/Angstrom");
    assert (metadata.contains("Iris Flux Integration output"));

    output.deleteOnExit();
    output2.deleteOnExit();
  }
コード例 #10
0
  @Test
  public void testNormalizer() throws Exception {
    ExtSed sed1 = new ExtSed("Sed1");
    ExtSed sed2 = new ExtSed("Sed2");
    ExtSed sed3 = new ExtSed("Sed3");

    Segment seg1 = new Segment();

    for (int k = 0; k < x1.length; k++) {
      y1[k] = y1[k] * 1e23;
      yerr1[k] = yerr1[k] * 1e23;
    }
    seg1.setFluxAxisValues(y1);
    seg1.setSpectralAxisValues(x1);
    seg1.setFluxAxisUnits("Jy");
    seg1.setSpectralAxisUnits("Angstrom");
    seg1.setDataValues(yerr1, UTYPE.FLUX_STAT_ERROR);
    sed1.addSegment(seg1);

    Segment seg2 = new Segment();
    seg2.setFluxAxisValues(y2);
    seg2.setSpectralAxisValues(x2);
    seg2.setFluxAxisUnits("erg/s/cm2/Hz");
    seg2.setSpectralAxisUnits("Angstrom");
    seg2.setDataValues(yerr2, UTYPE.FLUX_STAT_ERROR);
    sed2.addSegment(seg2);

    Segment seg3 = new Segment();
    seg3.setFluxAxisValues(y3);

    // convert the values in x3 to nm so I can test the unit conversions
    // too.
    for (int k = 0; k < x3.length; k++) {
      x3[k] = x3[k] * 0.1;
    }
    seg3.setSpectralAxisValues(x3);
    seg3.setFluxAxisUnits("erg/s/cm2/Hz");
    seg3.setSpectralAxisUnits("nm");
    seg3.setDataValues(yerr3, UTYPE.FLUX_STAT_ERROR);
    sed3.addSegment(seg3);

    SedStack stack = new SedStack("Stack");
    stack.add(sed1);
    stack.add(sed2);
    stack.add(sed3);

    // setup the redshift configuration
    NormalizationConfiguration config = new NormalizationConfiguration();
    config.setMultiply(true);
    config.setIntegrate(true);
    config.setStats("Average");
    config.setXUnits("Angstrom");
    config.setXmax(Double.POSITIVE_INFINITY);
    config.setXmin(Double.NEGATIVE_INFINITY);
    config.setIntegrateValueYUnits("erg/s/cm2/Hz");
    config.setYValue(1.0);

    // normalize the Stack
    SedStackerNormalizer normalizer =
        new SedStackerNormalizer(client, Default.getInstance().getUnitsManager());
    normalizer.normalize(stack, config);

    List<double[]> xs = new ArrayList<>();
    List<double[]> ys = new ArrayList<>();
    xs.add(x1);
    xs.add(x2);
    xs.add(x3);
    ys.add(y1);
    ys.add(y2);
    ys.add(y3);

    // stack.getOrigSeds() should return original seds
    for (int j = 0; j < stack.getOrigSeds().size(); j++) {
      ExtSed origSed = stack.getOrigSeds().get(j);
      double[] x = xs.get(j);
      double[] y = ys.get(j);

      for (int i = 0; i < stack.getOrigSeds().get(j).getSegment(0).getLength(); i++) {
        double xOrigValue = origSed.getSegment(0).getSpectralAxisValues()[i];
        double yOrigValue = origSed.getSegment(0).getFluxAxisValues()[i];
        assertEquals(xOrigValue, x[i], EPSILON);
        assertEquals(yOrigValue, y[i], EPSILON);
      }
    }

    for (int j = 0; j < stack.getSed(0).getSegment(0).getLength(); j++)
      assertEquals(
          0.49234923 * y1[j],
          stack.getSed(0).getSegment(0).getFluxAxisValues()[j],
          EPSILON * 0.49234923 * y1[j]);
    for (int j = 0; j < stack.getSed(1).getSegment(0).getLength(); j++)
      assertEquals(9.846 * y2[j], stack.getSed(1).getSegment(0).getFluxAxisValues()[j], EPSILON);

    assertEquals(
        1.1529274,
        Double.valueOf(stack.getSed(2).getAttachment(NORM_CONSTANT).toString()),
        EPSILON);
  }
コード例 #11
0
  @Test
  public void testNormalizerOutsideRange() throws Exception {
    ExtSed sed1 = new ExtSed("Sed1");
    ExtSed sed2 = new ExtSed("Sed2");
    ExtSed sed3 = new ExtSed("Sed3");

    Segment seg1 = new Segment();

    // for (int k=0; k<x1.length; k++) {
    // y1[k] = y1[k]*1e23;
    // yerr1[k] = yerr1[k]*1e23;
    // }
    seg1.setFluxAxisValues(y1);
    seg1.setSpectralAxisValues(x1);
    seg1.setFluxAxisUnits("erg/s/cm2/Angstrom");
    seg1.setSpectralAxisUnits("Angstrom");
    seg1.setDataValues(yerr1, UTYPE.FLUX_STAT_ERROR);
    sed1.addSegment(seg1);

    Segment seg2 = new Segment();
    seg2.setFluxAxisValues(y2);
    seg2.setSpectralAxisValues(x2);
    seg2.setFluxAxisUnits("erg/s/cm2/Angstrom");
    seg2.setSpectralAxisUnits("Angstrom");
    seg2.setDataValues(yerr2, UTYPE.FLUX_STAT_ERROR);
    sed2.addSegment(seg2);

    Segment seg3 = new Segment();
    seg3.setFluxAxisValues(y3);

    // convert the values in x3 to nm so I can test the unit conversions
    // too.
    for (int k = 0; k < x3.length; k++) {
      x3[k] = x3[k] * 0.1;
    }
    seg3.setSpectralAxisValues(x3);
    seg3.setFluxAxisUnits("erg/s/cm2/Angstrom");
    seg3.setSpectralAxisUnits("nm");
    seg3.setDataValues(yerr3, UTYPE.FLUX_STAT_ERROR);
    sed3.addSegment(seg3);

    SedStack stack = new SedStack("Stack");
    stack.add(sed1);
    stack.add(sed2);
    stack.add(sed3);

    // setup the redshift configuration
    NormalizationConfiguration config = new NormalizationConfiguration();
    config.setMultiply(true);
    config.setIntegrate(true);
    config.setStats("Value");
    config.setXUnits("Angstrom");
    config.setXmax(9.0);
    config.setXmin(1.5);
    config.setIntegrateValueYUnits("erg/s/cm2");
    config.setYValue(1.0);

    // normalize the Stack
    normalizeWithWindowInterceptor(stack, config);

    List<double[]> xs = new ArrayList<>();
    List<double[]> ys = new ArrayList<>();
    xs.add(x1);
    xs.add(x2);
    xs.add(x3);
    ys.add(y1);
    ys.add(y2);
    ys.add(y3);

    // stack.getOrigSeds() should return original seds
    for (int j = 0; j < stack.getOrigSeds().size(); j++) {
      ExtSed origSed = stack.getOrigSeds().get(j);
      double[] x = xs.get(j);
      double[] y = ys.get(j);

      for (int i = 0; i < stack.getOrigSeds().get(j).getSegment(0).getLength(); i++) {
        double xOrigValue = origSed.getSegment(0).getSpectralAxisValues()[i];
        double yOrigValue = origSed.getSegment(0).getFluxAxisValues()[i];
        assertEquals(xOrigValue, x[i], EPSILON);
        assertEquals(yOrigValue, y[i], EPSILON);
      }
    }

    for (int j = 0; j < stack.getSed(0).getSegment(0).getLength(); j++)
      assertEquals(y1[j], stack.getSed(0).getSegment(0).getFluxAxisValues()[j], EPSILON);
    for (int j = 0; j < stack.getSed(1).getSegment(0).getLength(); j++)
      assertEquals(0.0625 * y2[j], stack.getSed(1).getSegment(0).getFluxAxisValues()[j], EPSILON);

    assertEquals(
        0.035714285714,
        Double.valueOf(stack.getSed(2).getAttachment(NORM_CONSTANT).toString()),
        EPSILON);
  }