Uncertainty.java

Go to the documentation of this file.

package cedar.hepdata.model;

import java.text.DecimalFormat;
import cedar.hepdata.util.*;

import javax.persistence.*;

@MappedSuperclass
public class Uncertainty extends Storeable implements Comparable<Uncertainty> {

    @Column(name="PlusError", nullable=false)
    private Double _plus;

    @Column(name="MinusError", nullable=false)
    private Double _minus;

    @Column(name="Comment", nullable=true, length=10000)
    private String _comment = "";

    @Column(name="Source", nullable=false)
    @Enumerated(EnumType.STRING)
    private ErrorSource _sourcetype;

    @Column(name="Norm", nullable=false)
    @Enumerated(EnumType.STRING)
    private ErrorNorm _normtype;






    public Uncertainty() {}


    public Uncertainty(Double plus, Double minus, ErrorSource sourcetype, ErrorNorm normtype) {
        setPlus( (plus != null)  ? plus  : 0.0 );
        setMinus( (minus != null) ? minus : 0.0 );
        setSourceType(sourcetype);
        setNormType(normtype);
    }


    public Uncertainty(Double plusminus, ErrorSource sourcetype, ErrorNorm normtype) {
        this(plusminus, plusminus, sourcetype, normtype);
    }






    public boolean isSymmetric() {
        return (getPlus().equals(getMinus()));
    }


    public boolean hasZeroSize() {
        return (getPlus().equals(0.0) && getMinus().equals(0.0));
    }






    public Uncertainty getAbsoluteError(Point p) throws HDException {
        if (getNormType() == ErrorNorm.UNKNOWN) {
            throw new HDException("Attempted to get the absolute error from an unknown error type.");
        }

        Double absplus = getPlus();
        Double absminus = getMinus();
        if (getNormType() != ErrorNorm.ABS) {
            if (getNormType() == ErrorNorm.FRAC) {
                absplus *= p.getValue();
                absminus *= p.getValue();
            } else if (getNormType() == ErrorNorm.PCT) {
                absplus *= (p.getValue() / 100.0);
                absminus *= (p.getValue() / 100.0);
            }
        }
        Uncertainty err = new Uncertainty(absplus, absminus, getSourceType(), ErrorNorm.ABS);
        return err;
    }






    public Double getPlus() {
        return _plus;
    }

    public Uncertainty setPlus(Double plus) {
        _plus = plus;
        return this;
    }



    public Double getMinus() {
        return _minus;
    }

    public Uncertainty setMinus(Double minus) {
        _minus = minus;
        return this;
    }



    public ErrorSource getSourceType() {
        return _sourcetype;
    }

    public Uncertainty setSourceType(ErrorSource sourcetype) {
        _sourcetype = sourcetype;
        return this;
    }


    public ErrorNorm getNormType() {
        return _normtype;
    }
    public Uncertainty setNormType(ErrorNorm normtype) {
        _normtype = normtype;
        return this;
    }


    public String getComment() {
        return _comment;
    }
    public Uncertainty setComment(String comment) {
        _comment = comment;
        return this;
    }




    public int compareTo(Uncertainty other) {
        log().debug("Comparing errors...");

        // For point errors
        if (this instanceof PointError) {
            if (other instanceof PointError) {
                PointError test = (PointError) this;
                int result = test.compareTo((PointError) other);
                if (result != 0) return result;
            } else return 1;
        }

        // For axis errors
        if (this instanceof AxisError) {
            if (other instanceof AxisError) {
                AxisError test = (AxisError) this;
                int result = test.compareTo((AxisError) other);
                if (result != 0) return result;
            } else return (other instanceof PointError) ? -1 : 1;
        }

        // For dataset errors
        if (this instanceof DatasetError) {
            if (other instanceof DatasetError) {
                DatasetError test = (DatasetError) this;
                int result = test.compareTo((DatasetError) other);
                if (result != 0) return result;
            } else return 1;
        }

        return 0;
    }





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


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

        //if (! hasZeroSize()) {
        s.append(indent);
        Double plusval = getPlus();
        Double minusval = getMinus();

        String numFormat = "###.##";
        // Use the number formatter to recalculate and display everything as a percentage
        if (getNormType() == ErrorNorm.PCT) {
            plusval /= 100;
            minusval /= 100;
        }
        if (getNormType() == ErrorNorm.FRAC || getNormType() == ErrorNorm.PCT) {
            numFormat += "%"; // multiplies by 100 and sticks "%" on the end
        }
        DecimalFormat numFormatter = new DecimalFormat(numFormat);
        if (isSymmetric()) {
            s.append("+- " + numFormatter.format(plusval));
        } else {
            s.append("+ " + numFormatter.format(plusval));
            s.append(" - " + numFormatter.format(minusval));
        }
        s.append(" (");
        //s.append(getNormType().toString());
        //s.append(", ");
        s.append(getSourceType().toString());
        s.append(")");
        if (getComment() != null && getComment().length() != 0) {
            s.append(" [" + getComment() + "]");
        }
        //}
        return s.toString();
    }

}

---