Unit.java

Go to the documentation of this file.

package cedar.hepdata.util;

import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.util.Collection;
import java.util.List;
import java.util.Vector;

import org.apache.log4j.*;

public class Unit {
    static Logger log = Logger.getLogger(Unit.class);

    private List<UnitTerm> unitTerms = new Vector<UnitTerm>();




    public Unit() {}

    public Unit(String unitstr) throws HDUnitException {
        this.fromString(unitstr);
    }

    public Unit(Unit other) {
        for (UnitTerm term : other.getUnitTerms()) {
            this.addUnitTerm(new UnitTerm(term.baseunit, term.prefix, term.power));
        }
    }

    public Unit(UnitTerm term) {
        this.addUnitTerm(term);
    }

    public Unit(Collection<UnitTerm> terms) {
        for (UnitTerm term : terms) {
            this.addUnitTerm(term);
        }
    }

    public Unit(UnitTerm terms[]) {
        for (UnitTerm term : terms) {
            this.addUnitTerm(term);
        }
    }




    // Static methods for making common units
    public static Unit makeGeV() {
        return new Unit(new UnitTerm(BaseUnit.EV, SiPrefix.GIGA, 1));
    }
    public static Unit makeGeVc() {
        Unit gevc = makeGeV();
        gevc.addUnitTerm(new UnitTerm(BaseUnit.CLIGHT, SiPrefix.UNIT, -1));
        return gevc;
    }
    public static Unit makeGeVcsq() {
        Unit gevcsq = makeGeV();
        gevcsq.addUnitTerm(new UnitTerm(BaseUnit.CLIGHT, SiPrefix.UNIT, -2));
        return gevcsq;
    }




    public List<UnitTerm> getUnitTerms() {
        return unitTerms;
    }


    public void setUnitTerms(List<UnitTerm> unitTerms) {
        this.unitTerms = unitTerms;
    }

    public void addUnitTerm(UnitTerm unitTerm) {
        this.unitTerms.add(unitTerm);
    }

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

        Unit test = (Unit) obj;
        List<UnitTerm> terms1 = getUnitTerms();
        List<UnitTerm> terms2 = test.getUnitTerms();
        if (terms1.size() != terms2.size()) return false;

        for (int i = 0; i < terms1.size(); ++i) {
            if (! terms1.get(i).equals(terms2.get(i)) ) return false;
        }
        return true;
    }

    public Unit canonicalUnit() {
        Unit cu = new Unit();
        for (UnitTerm term : getUnitTerms()) {
            UnitTerm cterm = new UnitTerm(term.baseunit, term.prefix, term.power);
            cterm.prefix = SiPrefix.UNIT;
            cu.addUnitTerm(cterm);
        }
        return cu;
    }

    public Double convFactorToCanonical() {
        Double cf = 1.0;
        for (UnitTerm term : getUnitTerms()) {
            cf *= term.convFactor();
        }
        return cf;
    }

    public Double convFactorFromCanonical() {
        return 1.0 / convFactorToCanonical();
    }

    public boolean isCompatible(Unit unit) {
        Unit myCU = canonicalUnit();
        Unit otherCU = unit.canonicalUnit();

        // First test if their canonical representations are the same: it
        // makes things a lot easier if they are!
        if ( myCU.equals(otherCU) ) return true;

        // If they aren't exactly equal, eliminate matching elements from each
        // list and then see what's left over. First we have to make independent
        // copies of the term lists which we can mangle:
        List<UnitTerm> terms1 = new Vector<UnitTerm>();
        List<UnitTerm> terms2 = new Vector<UnitTerm>();
        for (UnitTerm term : myCU.getUnitTerms()) { terms1.add(new UnitTerm(term)); }
        for (UnitTerm term : otherCU.getUnitTerms()) { terms2.add(new UnitTerm(term)); }

        // Now strip out the stuff that matches from terms1
        for (UnitTerm term2 : otherCU.getUnitTerms()) {
            for (UnitTerm term1 : terms1) {
                log.debug(term1 + "-" + term2 + ": " + term2.equals(term1));
                if (term2.equals(term1)) {
                    terms1.remove(term1);
                    break;
                }
            }
        }
        // Now strip out the stuff that matches from terms2
        for (UnitTerm term1 : myCU.getUnitTerms()) {
            for (UnitTerm term2 : terms2) {
                log.debug(term2 + "-" + term1 + ": " + term1.equals(term2));
                if (term1.equals(term2)) {
                    terms2.remove(term2);
                    break;
                }
            }
        }
        log.info("T1: " + myCU.getUnitTerms() + " -> " + terms1);
        log.info("T2: " + otherCU.getUnitTerms() + " -> " + terms2);

        // Seeing what's left over: if it isn't a c_light, number or rad/deg
        // then it's incompatible. We also remove c_light and number on this pass,
        // so that we can match up rad/deg elements next...
        for (UnitTerm term : terms1) {
            if (term.baseunit.equals(BaseUnit.NUMBER) || term.baseunit.equals(BaseUnit.CLIGHT)) {
                terms1.remove(term);
            } else if (term.baseunit.equals(BaseUnit.RADIAN) || term.baseunit.equals(BaseUnit.DEGREE)) {
                log.info("Found a remaining angular unit: " + term.toString());
            } else {
                return false;
            }
        }
        for (UnitTerm term : terms2) {
            if (term.baseunit.equals(BaseUnit.NUMBER) || term.baseunit.equals(BaseUnit.CLIGHT)) {
                terms2.remove(term);
            } else if (term.baseunit.equals(BaseUnit.RADIAN) || term.baseunit.equals(BaseUnit.DEGREE)) {
                log.info("Found a remaining angular unit: " + term.toString());
            } else {
                return false;
            }
        }
        if (terms1.size() == 0 && terms2.size() == 0) return true;
        if (terms1.size() != terms2.size()) return false;

        // Try to match up remaining elements: check that the summed powers of angular
        // units are the same for both units
        int angPower1 = 0;
        int angPower2 = 0;
        for (UnitTerm t : terms1) angPower1 += t.power;
        for (UnitTerm t : terms2) angPower2 += t.power;
        if (angPower1 != angPower2) return false;

        // Finally, the units must be compatible (at last!)
        return true;
    }

    public Double convFactorTo(Unit unit) throws HDUnitException {
        if (isCompatible(unit)) {
            Double sifactor = convFactorToCanonical() * unit.convFactorFromCanonical();
            if (canonicalUnit().equals(unit.canonicalUnit())) {
                return sifactor;
            } else {
                int degPower1 = 0;
                for (UnitTerm t : this.getUnitTerms()) {
                    if (t.baseunit == BaseUnit.DEGREE) degPower1 += 1;
                    if (t.baseunit == BaseUnit.RADIAN) degPower1 -= 1;
                }
                int degPower2 = 0;
                for (UnitTerm t : unit.getUnitTerms()) {
                    if (t.baseunit == BaseUnit.DEGREE) degPower2 += 1;
                    if (t.baseunit == BaseUnit.RADIAN) degPower2 -= 1;
                }
                int deltaDegPower = degPower2 - degPower1;
                assert deltaDegPower % 2 == 0 : "Shift in number of powers of degree is not even. How?!?";
                log.debug(degPower1 + " -> " + degPower2 + " so shift is " + deltaDegPower);
                Double angfactor = Math.pow(180.0/Math.PI, deltaDegPower/2.0);
                return sifactor * angfactor;
            }
        } else {
            throw new HDUnitException("Units " + toString() + " and " + unit.toString() + " are not compatible");
        }
    }

    public Double convFactorFrom(Unit unit) throws HDUnitException {
        return 1.0/ convFactorTo(unit);
    }

    public String toString() {
        StringBuffer s = new StringBuffer();
        for (UnitTerm term : getUnitTerms()) {
            s.append(term.toString());
            s.append(" ");
        }
        return s.toString().trim();
    }

    public Unit fromString(String unitstr) throws HDUnitException {
        unitTerms.clear();
        String myunitstr = unitstr;
        if (myunitstr.length() == 0) {
            return this;
        }

        // Replace ** with ^, replace " *\* *" with " ", replace " */ *" with " /"
        myunitstr = myunitstr.replaceAll("\\*\\*", "^");
        log.debug("1. " + unitstr + " vs. " + myunitstr);
        myunitstr = myunitstr.replaceAll("\\ *\\*\\ *", " ");
        log.debug("2. " + unitstr + " vs. " + myunitstr);
        myunitstr = myunitstr.replaceAll("\\ */\\ *", " /");
        log.debug("3. " + unitstr + " vs. " + myunitstr);

        String[] unitatoms = myunitstr.split(" ");
        for (String atom : unitatoms) {
            UnitTerm term = new UnitTerm(atom);
            addUnitTerm(term);
        }
        return this;
    }

}

---