Point.java

Go to the documentation of this file.

package cedar.hepdata.model;

import java.util.Collection;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.HashSet;
import java.util.Arrays;

import javax.persistence.*;

import cedar.hepdata.util.HDException;

@Entity
@Table(name="Points")
public class Point extends Value implements Comparable<Point> {
    @Column(name="LocalId", nullable=false)
    private Integer _localId;

    @Column(name="Value", nullable=false)
    private Double _value;

    @org.hibernate.annotations.CollectionOfElements
    @JoinTable(name="PointErrors", joinColumns=@JoinColumn(name="VALUE_ID"))
    @org.hibernate.annotations.CollectionId(columns=@Column(name="PointErrorId"),
                                            type=@org.hibernate.annotations.Type(type="long"),
                                            generator="sequence")
    @org.hibernate.annotations.Sort(type=org.hibernate.annotations.SortType.NATURAL)
    @org.hibernate.annotations.BatchSize(size=5)
    private SortedSet<PointError> _errors = new TreeSet<PointError>();

    @ManyToOne
    private YAxis _yAxis;

    @Column(name="Relation", nullable=false)
    @Enumerated(EnumType.STRING)
    private Relation _relation = Relation.EQUALS;

    @Column(name="ConfLevel", nullable=true)
    private Double _confidenceLevel = null;






    public Point() {}

    public Point(Double value) {
        setValue(value);
    }

    public Point(Double value, Relation relation, Double confidenceLevel) throws HDException {
        setLimit(relation, value, confidenceLevel);
    }

    public Point(YAxis yAxis) {
        setYAxis(yAxis);
    }

    public Point(YAxis yAxis, Double value) {
        this(yAxis);
        setValue(value);
    }

    public Point(YAxis yAxis, Double value, Relation relation, Double confidenceLevel) throws HDException {
        this(yAxis);
        setLimit(relation, value, confidenceLevel);
    }




    public Point setLimit(Relation relation, Double value, Double confidenceLevel) throws HDException {
        setRelation(relation); // Need to do this first
        setValue(value);
        setConfidenceLevel(confidenceLevel);
        return this;
    }




    // Point ID
    public Integer getId() {
        return _localId;
    }
    public Point setId(Integer pointId) {
        _localId = pointId;
        return this;
    }


    // Value
    public Double getValue() {
        return _value;
    }
    public Point setValue(Double value) {
        _value = value;
        return this;
    }


    public Relation getRelation() {
        return _relation;
    }
    public Point setRelation(Relation relation) {
        _relation = relation;
        return this;
    }


    // Confidence level
    public Double getConfidenceLevel() {
        return _confidenceLevel;
    }
    public Point setConfidenceLevel(Double confidenceLevel) throws HDException {
        if (getRelation() != Relation.EQUALS) {
            _confidenceLevel = confidenceLevel;
        } else {
            _confidenceLevel = null;
        }
        return this;
    }


    // Errors
    public SortedSet<PointError> getErrors() {
        return _errors;
    }
    public Point setErrors(SortedSet<PointError> errors) {
        getErrors().clear();
        for (PointError e : errors) addError(e);
        return this;
    }
    public Point setErrors(Collection<PointError> errors) {
        log().debug("Calling setErrors(Collection<PointError>)");
        getErrors().clear();
        for (PointError e : errors) addError(e);
        return this;
    }
    public Point setErrors(PointError[] errors) {
        setErrors(Arrays.asList(errors));
        return this;
    }
    public Point addError(PointError error) {
        if (error != null) {
            if (error.getId() == null) {
                int highestId = 0;
                if (getErrors().size() > 0) {
                    highestId = getErrors().last().getId();
                }
                log().debug("Incrementing point error ID: " + (highestId + 1));
                error.setId(highestId + 1);
            }
            log().debug("Adding point error: ID = " + error.getId());
            _errors.add(error);
        } else {
            log().warn("Tried to add a null point error to a point");
        }
        return this;
    }
    public Point removeError(PointError error) {
        if (error != null) {
            _errors.remove(error);
        } else {
            log().warn("Tried to remove a null point error from a point");
        }
        return this;
    }


    public YAxis getYAxis() {
        return _yAxis;
    }
    public Point setYAxis(YAxis yAxis) {
        _yAxis = yAxis;
        if (yAxis != null) yAxis.getPoints().add(this);
        return this;
    }




    public Set<Uncertainty> getDatasetErrors() {
        if (getYAxis() != null) {
            return getYAxis().getDatasetErrors();
        } else {
            return new HashSet<Uncertainty>();
        }
    }
    public SortedSet<Uncertainty> getAxisErrors() {
        SortedSet<Uncertainty> axisErrors = new TreeSet<Uncertainty>();
        if (getYAxis() != null) {
            axisErrors.addAll( getYAxis().getErrors() );
        }
        return axisErrors;
    }
    public Set<Uncertainty> getPointErrors() {
        return new HashSet<Uncertainty>(getErrors());
    }
    public SortedSet<Uncertainty> getAllErrors() {
        SortedSet<Uncertainty> allErrors = new TreeSet<Uncertainty>();
        allErrors.addAll(getErrors());
        allErrors.addAll(getAxisErrors());
        allErrors.addAll(getDatasetErrors());
        return allErrors;
    }




    public SortedSet<Bin> getBins() {
        SortedSet<Bin> matchingBins = null;
        YAxis y = getYAxis();
        if (y != null) {
            Dataset d = y.getDataset();
            if (d != null) {
                matchingBins = d.getBins(getId());
            }
        }
        return matchingBins;
    }

    public SortedSet<Point> getPoints() {
        SortedSet<Point> matchingPoints = null;
        YAxis y = getYAxis();
        if (y != null) {
            Dataset d = y.getDataset();
            if (d != null) {
                matchingPoints = d.getPoints(getId());
            }
        }
        return matchingPoints;
    }




    public String toString() {
        return toString(0);
    }

    public String toString(Integer indentBy) {
        log().debug("Writing out point as a string");
        StringBuffer s = new StringBuffer();
        String indent = "";
        for (int i  = 0; i < indentBy; ++i) indent += " ";

        s.append(indent + "Point " + getId() + ": ");
        if (getAllErrors().size() > 0) s.append("( ");
        s.append(getValue());
        for (Uncertainty e : getAllErrors()) {
            s.append(" " + e.toString());
        }
        if (getAllErrors().size() > 0) s.append(" )");
        if (getYAxis() != null) {
            s.append(" " + getYAxis().getUnit().toString());
        }
        return s.toString();
    }




    public boolean equals(Object other) {
        if (this == other) return true;
        if (! (other instanceof Point)) return false;

        final Point test = (Point) other;
        if (test.getYAxis() != null && !test.getYAxis().equals(getYAxis()) ) return false;
        if (test.getValue() != null && getValue() != null &&
            Math.abs((test.getValue() - getValue())/getValue()) > 1e-6 ) return false;

        // If not proven guilty...
        return true;
    }

    public int hashCode() {
        int code = 0;
        if (getYAxis() != null) code += 100000 * getYAxis().hashCode();
        if (getValue() != null) code += getValue().hashCode();
        code *= 2; // ensure this is even
        return code;
    }




    public int compareTo(Point other) {
        log().debug("Comparing points...");
        if (getId() == null) {
            log().warn("Null Point ID");
            return 1; // Sort null points at the end
        } else if (getId() > other.getId()) {
            log().debug("Greater than");
            return 1;
        } else if (getId() < other.getId()) {
            log().debug("Less than");
            return -1;
        } else {
            log().debug("Point IDs are equal");
            if (getYAxis() != null && other.getYAxis() != null) {
                return getYAxis().compareTo(other.getYAxis());
            } else {
                return 0;
            }
        }
    }

}

---