JetWebPlotMLReader.java

Go to the documentation of this file.

package cedar.jetweb.xml;

//import java.io.*;

import org.jdom.Element;
import org.jdom.Document;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;

import java.util.List;
import java.util.Iterator;
import java.util.StringTokenizer;
import java.util.Vector;
import java.util.Collection;

import cedar.jetweb.model.plots.DataPoint;
import cedar.jetweb.model.plots.DataPlot;
import cedar.jetweb.model.plots.PredictedPlot;
import cedar.jetweb.JetWebException;


public class JetWebPlotMLReader extends JetWebXMLReader implements JetWebPlotReader{

    private String filename;
    private Element soloPlot;
    private String title;
    private String xlabel;
    private String ylabel;
    private boolean isLogarithmic = false;
    private Vector<DataPoint> dataPoints = new Vector<DataPoint>();

    public static void main(String args[]){
    try {
        JetWebPlotMLReader tester = new JetWebPlotMLReader(args[0]);
        System.out.println("test title " + tester.getTitle());
        System.out.println("x label " + tester.getXLabel());
        System.out.println("y label " + tester.getYLabel());
        Collection<DataPoint> points=tester.getDataPoints();
        int i=0;
        for (DataPoint point : points) {
        i++;
        System.out.println("point"+i+ point.toString());
        }
    } catch (Throwable t) {
        System.out.println("Error reading XML");
    }
    }
    public JetWebPlotMLReader(String filename) throws JetWebXMLException {
    super(filename);
    populateSoloPlot();
    }
    private void populateSoloPlot(){
    Document doc = getDocument();
    if (soloPlot==null){
        soloPlot = doc.getRootElement().getChild("plot");
    }
    if (soloPlot==null){
        System.out.println("Error reading plotfile - no plot");
    } else {
        //extract plot title
        title=soloPlot.getChild("title").getChild("label").getAttributeValue("text");
        //extract axes titles
        List<Element> axesList=soloPlot.getChild("dataArea").getChildren("axis");
        Iterator<Element> axes = axesList.iterator();
        while (axes.hasNext()){
        Element axis = axes.next();
        String axisLabel=axis.getChild("label").getAttributeValue("text");
        String axisType=axis.getAttributeValue("location");
        if (axisType.equals("x0")){
            xlabel=axisLabel;
        } else {
            ylabel=axisLabel;
                    String isLog = axis.getAttributeValue("logarithmic");
                    if(isLog.compareTo("true")==0) {
                        isLogarithmic = true;
                    }else {
                        isLogarithmic = false;
                    }
        }
        }
        //populate a vector of data points for the plot
        populateDataPoints();

    }
    }
    private void populateDataPoints(){
    List<Element> pointsList = soloPlot.getChild("dataArea").getChildren("data1d");
    Iterator<Element> points = pointsList.iterator();
    try {
    while (points.hasNext()){
        Element point = points.next();
        Element axisAttr = point.getChild("binnedDataAxisAttributes");
        double numberOfBins = Double.parseDouble(axisAttr.getAttributeValue("numberOfBins"));
        double min = Double.parseDouble(axisAttr.getAttributeValue("min"));
        double max = Double.parseDouble(axisAttr.getAttributeValue("max"));
        double binwidth = (max - min) / numberOfBins;

        //have to decode this string into points and errors
        String[][] hdata = decodeData(point.getChildTextTrim
("bins1d"));
        for (int i=0;i<hdata[0].length;i++){

        DataPoint pointA = new DataPoint();
        pointA.setX(binwidth*i + 0.5*binwidth + min);
        pointA.setY(Double.parseDouble(hdata[0][i]));
        pointA.setYUp(Double.parseDouble(hdata[1][i]));
        pointA.setYDown(pointA.getYDown());
        pointA.setBinWidth(binwidth);
        /*
        double[] pointA = new double[6];
            pointA[DataPoint.X]=binwidth*i +  binwidth/2.0 +min;
        pointA[DataPoint.Y]=Double.parseDouble(hdata[0][i]);
        pointA[DataPoint.YUP]=Double.parseDouble(hdata[1][i]);      
        pointA[DataPoint.YDOWN]=pointA[2];
        pointA[DataPoint.BINWIDTH]=binwidth;
        
        dataPoints.add(new DataPoint(pointA));
        */
        dataPoints.add(pointA);
        }
    }
        } catch (Exception e){
        System.out.println("Exception in populate data points " + e);
        e.printStackTrace(System.out);
    }
    }
    private String[][]  decodeData(String data){
    
    StringTokenizer tokLines = new StringTokenizer(data,"\n");
    String[][] pointsA = new String[3][tokLines.countTokens()];
    int i = 0;
    while (tokLines.hasMoreTokens()){
        StringTokenizer tokCommas = new StringTokenizer(tokLines.nextToken(),",");
            pointsA[0][i]=tokCommas.nextToken();
        pointsA[1][i]=tokCommas.nextToken();
        if (tokCommas.countTokens()==3){
        pointsA[2][i]=tokCommas.nextToken();
        }
        i++;
    }
    return pointsA;
    }
    public String getTitle(){
        return title;
    }
    public String getXLabel(){
    return xlabel;
    }
    public String getYLabel(){
    return ylabel;
    }
    private Collection<DataPoint> getDataPoints(){
    return dataPoints;
    }
    public void fillPlot(DataPlot plot) throws JetWebException { 
    //System.out.println("fillplot called. title= " + title);
    plot.setTitle(title);
    plot.setXLabel(xlabel);
    plot.setYLabel(ylabel);
        plot.setLogarithmic(isLogarithmic);
    plot.setDataPoints(dataPoints);
    if (plot instanceof PredictedPlot){
        PredictedPlot.adjustErrors((PredictedPlot)plot);
    }
    plot.setHasData(true);
    }

    public void setDirectory(String dir) throws JetWebException {
    throw new JetWebException("JetWebPlotMLReader","setDirectory not implemented");
    }

}

Generated Wed Jan 17 09:14:27 GMT 2007