Reaction.java

Go to the documentation of this file.

package cedar.hepdata.model;

import java.util.Set;
import java.util.HashSet;

import javax.persistence.*;

import cedar.hepdata.util.*;

@Entity
@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)
@Table(name="BaseReactions")
public class Reaction extends Storeable {
    @Id @GeneratedValue(strategy=GenerationType.TABLE)
    @Column(name="REACTION_ID")
    private Long _id;

    @org.hibernate.annotations.CollectionOfElements
    @JoinTable(name="InitialStates", joinColumns=@JoinColumn(name="REACTION_ID"))
    @org.hibernate.annotations.CollectionId(columns=@Column(name="InitialStateId"),
                                            type=@org.hibernate.annotations.Type(type="long"),
                                            generator="sequence")
    private Set<Particle> initialState = new HashSet<Particle>();

    @org.hibernate.annotations.CollectionOfElements
    @JoinTable(name="FinalStates", joinColumns=@JoinColumn(name="REACTION_ID"))
    @org.hibernate.annotations.CollectionId(columns=@Column(name="FinalStateId"),
                                            type=@org.hibernate.annotations.Type(type="long"),
                                            generator="sequence")
    private Set<Particle> finalState = new HashSet<Particle>();

    @ManyToMany
    private Set<ReactionGroup> reactionGroups = new HashSet<ReactionGroup>();




    public Reaction() {}




    public Set<Particle> getInitialState() {
        return initialState;
    }
    public Reaction setInitialState(Set<Particle> initialState) {
        this.initialState = initialState;
        return this;
    }
    public Reaction addToInitialState(Particle particle) {
        boolean foundType = false;
        for (Particle p : this.initialState) {
            if (Particle.sameType(p, particle)) {
                foundType = true;
                p.setMultiplicity(p.getMultiplicity() + particle.getMultiplicity());
                break;
            }
        }
        if (!foundType) this.initialState.add(particle);
        return this;
    }
    public Reaction removeFromInitialState(Particle particle) {
        for (Particle p : this.initialState) {
            if (Particle.sameType(p, particle)) {
                int newMult = p.getMultiplicity() - particle.getMultiplicity();
                if (newMult <= 0) {
                    this.initialState.remove(p);
                } else {
                    p.setMultiplicity(newMult);
                }
                break;
            }
        }
        return this;
    }
    public Reaction purgeFromInitialState(Particle particle) {
        for (Particle p : this.initialState) {
            if (Particle.sameType(p, particle)) {
                this.initialState.remove(p);
            }
        }
        return this;
    }


    public Set<Particle> getFinalState() {
        return finalState;
    }
    public Reaction setFinalState(Set<Particle> finalState) {
        this.finalState = finalState;
        return this;
    }
    public Reaction addToFinalState(Particle particle) {
        boolean foundType = false;
        for (Particle p : this.finalState) {
            if (Particle.sameType(p, particle)) {
                foundType = true;
                p.setMultiplicity(p.getMultiplicity() + particle.getMultiplicity());
                break;
            }
        }
        if (!foundType) this.finalState.add(particle);
        return this;
    }
    public Reaction removeFromFinalState(Particle particle) {
        for (Particle p : this.finalState) {
            if (Particle.sameType(p, particle)) {
                int newMult = p.getMultiplicity() - particle.getMultiplicity();
                if (newMult <= 0) {
                    this.finalState.remove(p);
                } else {
                    p.setMultiplicity(newMult);
                }
                break;
            }
        }
        return this;
    }
    public Reaction purgeFromFinalState(Particle particle) {
        for (Particle p : this.finalState) {
            if (Particle.sameType(p, particle)) {
                this.finalState.remove(p);
            }
        }
        return this;
    }



    public Set<ReactionGroup> getReactionGroups() {
        return reactionGroups;
    }
    public Reaction setReactionGroups(Set<ReactionGroup> reactionGroups) {
        this.reactionGroups = reactionGroups;
        Set<ReactionGroup> toAdd = new HashSet<ReactionGroup>();
        Set<ReactionGroup> toRemove = new HashSet<ReactionGroup>();
        for (ReactionGroup r : this.reactionGroups) {
            if (! reactionGroups.contains(r)) toRemove.add(r);
        }
        for (ReactionGroup r : reactionGroups) {
            if (! this.reactionGroups.contains(r)) toAdd.add(r);
        }
        for (ReactionGroup r : toRemove) removeReactionGroup(r);
        for (ReactionGroup r : toAdd) addReactionGroup(r);
        return this;
    }
    public Reaction addReactionGroup(ReactionGroup reactionGroup) {
        if (reactionGroup != null) {
            reactionGroup.getReactions().add(this);
            this.reactionGroups.add(reactionGroup);
        } else {
            log().warn("Tried to add a null reaction group to a reaction");
        }
        return this;
    }
    public Reaction removeReactionGroup(ReactionGroup reactionGroup) {
        if (reactionGroup != null) {
            reactionGroup.getReactions().remove(this);
            this.reactionGroups.remove(reactionGroup);
        } else {
            log().warn("Tried to remove a null reaction group from a reaction");
        }
        return this;
    }




    public boolean equals(Object other) {
        log().debug("Comparing reactions...");
        if (this == other) return true;
        if (! (other instanceof Reaction)) return false;
        final Reaction test = (Reaction) other;

        if (! this.getInitialState().equals( test.getInitialState() )) return false;
        if (test.getInitialState() != null && this.getInitialState() != null) {
            Set<Particle> is1 = this.getInitialState();
            Set<Particle> is2 = test.getInitialState();
            if (is1.size() != is2.size()) return false;
            for (Particle p : is1) {
                if (! is2.contains(p)) return false;
            }
        }

        if (! this.getFinalState().equals( test.getFinalState() )) return false;
        if (test.getFinalState() != null && this.getFinalState() != null) {
            Set<Particle> fs1 = this.getFinalState();
            Set<Particle> fs2 = test.getFinalState();
            if (fs1.size() != fs2.size()) return false;
            for (Particle p : fs1) {
                if (! fs2.contains(p)) return false;
            }
        }




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






    public String initialStateToString() {
        StringBuffer s = new StringBuffer();
        for (Particle ispart : getInitialState()) {
            s.append(" " + ispart.toString());
        }
        return s.toString().trim();
    }


    public String finalStateToString() {
        StringBuffer s = new StringBuffer();
        for (Particle fspart : getFinalState()) {
            s.append(" " + fspart.toString());
        }
        return s.toString().trim();
    }


    public String toString() {
        StringBuffer s = new StringBuffer();
        s.append(initialStateToString());
        s.append(" -> ");
        s.append(finalStateToString());
        return s.toString().trim();
    }

}

---