Bin.java

Go to the documentation of this file.

package cedar.hepdata.model;

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

import javax.persistence.*;

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

    @Column(name="Focus", nullable=true)
    private Double _focus = null;


    @Column(name="Width", nullable=true)
    private Double _width = null;

    @Column(name="LowValue", nullable=true)
    private Double _lowValue = null;

    @Column(name="HighValue", nullable=true)
    private Double _highValue = null;

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

    @ManyToOne
    private XAxis _xAxis;






    public Bin() {
        super();
    }

    public Bin(Double centralValue) {
        setFocus(centralValue);
    }

    public Bin(Double lowValue, Double highValue) {
        setLowValue(lowValue);
        setHighValue(highValue);
    }

    public Bin(Double lowValue, Double highValue, Double focus) {
        this(lowValue, highValue);
        setFocus(focus);
    }

    public Bin(XAxis xAxis) {
        setXAxis(xAxis);
    }

    public Bin(XAxis xAxis, Double centralValue) {
        this(centralValue);
        setXAxis(xAxis);
    }

    public Bin(XAxis xAxis, Double lowValue, Double highValue) {
        this(lowValue, highValue);
        setXAxis(xAxis);
    }

    public Bin(XAxis xAxis, Double lowValue, Double highValue, Double focus) {
        this(lowValue, highValue, focus);
        setXAxis(xAxis);
    }




    public Integer getId() {
        return _localId;
    }
    public Bin setId(Integer binId) {
        _localId = binId;
        return this;
    }


    public Double getFocus() {
        if (_focus != null) return _focus;

        // Fall back to calculating the geometric centre
        log().debug("Asked for focus, but focus is null.");
        if (getLowValue() != null && getHighValue() != null) {
            log().info("Calculating central value from high and low edges");
            return (getLowValue() + getHighValue()) / 2.0;
        } else {
            log().warn("Could neither retrieve nor calculate bin focus.");
            return null;
        }
    }

    public Bin setFocus(Double focus) {
        _focus = focus;
        return this;
    }


    public Relation getRelation() {
        return _relation;
    }

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


    public Double getLowValue() {
        return _lowValue;
    }
    public Bin setLowValue(Double lowValue) {
        _lowValue = lowValue;
        return this;
    }


    public Double getHighValue() {
        return _highValue;
    }
    public Bin setHighValue(Double highValue) {
        _highValue = highValue;
        return this;
    }



    public Double getWidth() {
        if (_width == null) {
            log().info("Asked for width, but Width is null.");
            if (getHighValue() != null && getLowValue() != null) {
                log().info("Calculating width from high and low edges");
                return Math.abs(getHighValue() - getLowValue());
            }
        }
        return _width;
    }


    public Bin setWidth(Double width) {
        _width = width;
        return this;
    }


    public XAxis getXAxis() {
        return _xAxis;
    }
    public Bin setXAxis(XAxis xAxis) {
        _xAxis = xAxis;
        if (getXAxis() != null) getXAxis().getBins().add(this);
        return this;
    }




    public SortedSet<Bin> getBins() {
        SortedSet<Bin> matchingBins = null;
        XAxis x = getXAxis();
        if (x != null) {
            Dataset d = x.getDataset();
            if (d != null) {
                matchingBins = d.getBins(getId());
            }
        }
        return matchingBins;
    }

    public SortedSet<Point> getPoints() {
        SortedSet<Point> matchingPoints = null;
        XAxis x = getXAxis();
        if (x != null) {
            Dataset d = x.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 x-axis as a string");
        StringBuffer s = new StringBuffer();
        String indent = "";
        for (int i  = 0; i < indentBy; ++i) indent += " ";

        s.append(indent + "Bin " + getId() + ": ");
        if (getLowValue() != null && getHighValue() != null) {
            s.append(getLowValue() + " - " + getHighValue());
        } else if (getFocus() != null) {
            s.append(getFocus());
            if (getWidth() != null) {
                s.append(" (width = " + getWidth() + ")");
            }
        }
        return s.toString();
    }




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

        final Bin test = (Bin) other;
        if (test.getXAxis() != null && !test.getXAxis().equals(getXAxis()) ) return false;
        if (test.getFocus() != null && getFocus() != null &&
            (test.getFocus() - getFocus())/getFocus() > 1e-6 ) return false;

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


    public int hashCode() {
        int code = 0;
        if (getXAxis() != null) code += 100000 * getXAxis().hashCode();
        if (getFocus() != null) code += (int) (1000 * getFocus());
        code *= 2; ++code; // ensure this is odd
        return code;
    }




    public int compareTo(Bin other) {
        log().debug("Comparing bins...");
        if (getId() == null) {
            log().warn("Null Bin ID");
            return 1; // Sort null bins 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("Bin IDs are equal");
            if (getXAxis() != null && other.getXAxis() != null) {
                return getXAxis().compareTo(other.getXAxis());
            } else {
                return 0;
            }
        }
    }

}

---