Data.java

Go to the documentation of this file.

package cedar.hepdata.model;

import java.util.Collection;
import java.util.List;
import java.util.Vector;
import java.util.Date;

import cedar.hepdata.util.*;

import javax.persistence.*;

import org.apache.log4j.*;

public class Data extends Storeable {
    private List<Paper> _papers = new Vector<Paper>();
    private Date _timestamp = new Date();




    public Data() {}

    public Data(Paper paper) {
        addPaper(paper);
    }

    public Data(Collection<Paper> papers) {
        setPapers(papers);
    }




    public List<Paper> getPapers() {
        return _papers;
    }
    public Paper getFirstPaper() {
        Paper p = null;
        if (!getPapers().isEmpty()) p = getPapers().get(0);
        return p;
    }
    public Data setPapers(Collection<Paper> papers) {
        getPapers().clear();
        for (Paper p : papers) {
            getPapers().add(p);
        }
        return this;
    }
    public Data addPaper(Paper paper) {
        getPapers().add(paper);
        return this;
    }
    public Data removePaper(Paper paper) {
        getPapers().remove(paper);
        return this;
    }


    public Date getTimestamp() {
        return _timestamp;
    }
    public Data setTimestamp(Date timestamp) {
        _timestamp = timestamp;
        return this;
    }




    public String toString() {
        StringBuffer s = new StringBuffer();
        for (Paper p : getPapers()) {
            s.append(p.toString());
        }
        return s.toString();
    }




    public static Data makeExample() {
        // Have to get a different logger from the inherited one,
        // since this is a static method
        Logger log = Logger.getLogger(Data.class);

        log.debug("Making data structure...");
        Experiment ex = Data.makeExampleExperiment();
        Paper p = Data.makeExamplePaper();
        Dataset d = Data.makeExampleDataset();
        p.addDataset(d);
        for (XAxis x : Data.makeExampleXAxes()) d.addXAxis(x);
        for (YAxis y : Data.makeExampleYAxes()) d.addYAxis(y);

        log.debug("Making data container...");
        Data data = new Data();
        data.addPaper(p);

        return data;
    }

    public static Experiment makeExampleExperiment() {
        Logger log = Logger.getLogger(Data.class);
        log.info("Making experiments");
        Experiment ex = new Experiment("CDF1").setInformalName("CDF");
        ex.setComment("CDF r00ls, D0 sux!");
        return ex;
    }

    public static Paper makeExamplePaper() {
        Logger log = Logger.getLogger(Data.class);
        log.info("Making paper");
        Paper p = new Paper("My paper", 54635774);
        p.addAuthor("Andy");
        log.debug("Making reference");
        Reference ref = new Reference(RefType.ARXIV, "hep-ph/foobar");
        return p;
    }

    public static Dataset makeExampleDataset() {
        Logger log = Logger.getLogger(Data.class);
        log.info("Making dataset");
        Dataset d = new Dataset();
        d.addComment("My dataset of physics stuff");
        return d;
    }

    public static Collection<XAxis> makeExampleXAxes() {
        Logger log = Logger.getLogger(Data.class);
        log.info("Making x-axes");

        log.debug("Making unit for x-axis");
        Unit ux1 = Unit.makeGeV();
        log.debug("Making x-axis");
        XAxis x1 = new XAxis("X1", ux1).setId(1);

        log.info("Adding bins to x-axis");
        x1.addBin(new Bin(0.0));
        x1.addBin(new Bin(0.2));
        x1.addBin(new Bin(0.4));
        x1.addBin(new Bin(0.6));
        x1.addBin(new Bin(0.8));

        List<XAxis> xAxes = new Vector<XAxis>();
        xAxes.add(x1);
        return xAxes;
    }

    public static Collection<YAxis> makeExampleYAxes() {
        Logger log = Logger.getLogger(Data.class);
        log.info("Making y-axes");

        log.debug("Making units for y-axes");
        Unit uy1a = new Unit(new UnitTerm(BaseUnit.BARN, SiPrefix.NANO, -1));
        Unit uy1b = new Unit(new UnitTerm(BaseUnit.RADIAN, SiPrefix.MILLI, 1));
        log.debug("Making observables for y-axes");
        Observable o1a = new Observable("Random 1", uy1a.canonicalUnit());
        Observable o1b = new Observable("Random 2", uy1b);
        log.debug("Making y-axis 1");
        YAxis y1a = new YAxis(o1a, "Y1a", uy1a).setId(2);
        log.debug("Making y-axis 2");
        YAxis y1b = new YAxis(o1b, "Y1b", uy1b).setId(1);

        log.info("Adding points to the y-axes");
        log.debug("Adding points to y-axis 1");
        y1a.addPoint(new Point(1.0));
        y1a.addPoint(new Point(2.0));
        y1a.addPoint(new Point(4.0));
        y1a.addPoint(new Point(2.0));
        y1a.addPoint(new Point(1.0));
        log.debug("Adding points to y-axis 2");
        y1b.addPoint(new Point(1.0));
        y1b.addPoint(new Point(2.0));
        y1b.addPoint(new Point(3.0));
        y1b.addPoint(new Point(4.0));
        y1b.addPoint(new Point(5.0));

        y1a.addError(new AxisError(Math.random(), ErrorSource.SYS, ErrorNorm.FRAC));
        y1b.addError(new AxisError(100 * Math.random(), ErrorSource.UNKNOWN, ErrorNorm.PCT));

        for (Point p : y1a.getPoints()) {
            PointError pe = new PointError(p, Math.random(), ErrorSource.STAT, ErrorNorm.FRAC);
        }
        for (Point p : y1b.getPoints()) {
            PointError pe = new PointError(p, 100 * Math.random(), 100 * Math.random(), ErrorSource.STAT, ErrorNorm.PCT);
        }

        List<YAxis> yAxes = new Vector<YAxis>();
        yAxes.add(y1a);
        yAxes.add(y1b);
        return yAxes;
    }


}

---