ubic.erminej.data

Class GeneAnnotations

java.lang.Object

ubic.erminej.data.GeneAnnotations

public class GeneAnnotations
extends Object

Maintains gene annotations. Be clear on the distinction between a GeneSetTerm (just a term) and a GeneSet (the set of genes associated with a GeneSetTerm)

This is initialized by providing a set of 'probes' with 'gene' and 'geneset' associations. When ErmineJ is started, the annotation file provided determines the set of probes/genes that are available.

At later stages, when the user's analysis results are read in, they might not have all the probes/genes used. A copy of the GeneAnnotations should be made that references just the subset of probes/genes that are relevant.

Version:

$Id: GeneAnnotations.java,v 1.49 2013/05/05 20:08:47 paul Exp $, Extensively rewritten for 2.2 (PP)

Author:

Paul Pavlidis, Shamhil Merchant, Homin Lee

Field Summary

Fields

Modifier and Type	Field and Description
static boolean	DEFAULT_FILTER_NONSPECIFIC Whether to filter out probes that hit more than one gene

Constructor Summary

Constructors

Constructor and Description
GeneAnnotations(Collection<Gene> genes, GeneSetTerms geneSetTerms, SettingsHolder settings, StatusViewer messenger)
GeneAnnotations(GeneAnnotations start, Collection<Probe> probes) Create a read-only new annotation set based on an existing one, for selected probes, removing probes with no annotations.
GeneAnnotations(GeneAnnotations start, Collection<Probe> probes, boolean pruneUnannotated) Create a read-only new annotation set based on an existing one, for selected probes, optionally removing unannotated probes.
GeneAnnotations(List<Gene> geneSymbols, List<Collection<GeneSetTerm>> goTerms, StatusViewer m) Constructor designed for use when a file is not the immediate input of the data.
GeneAnnotations(List<String> probes, List<String> genes, List<Collection<String>> goTerms)

Method Summary

Methods

Modifier and Type	Method and Description
int	addAnnotation(Gene gene, Collection<GeneSetTerm> terms)
void	addGeneSet(GeneSet set)
void	addGeneSet(GeneSetTerm geneSetId, Collection<Gene> gs)
GeneSet	addGeneSet(GeneSetTerm geneSetId, Collection<Gene> gs, String sourceFile) Add a user-defined gene set.
void	deleteGeneSet(GeneSetTerm id) Remove a gene set (class) from all the maps that reference it.
void	deleteSubClone(GeneAnnotations a) Remove a no-longer-needed subclone.
boolean	deleteUserGeneSet(GeneSetTerm classID)
Gene	findGene(String symbol) Case insensitive
GeneSet	findGeneSet(GeneSetTerm term)
GeneSet	findGeneSet(String name)
Probe	findProbe(String probe) Case insensitive
Set<Probe>	findProbes(String searchOn) Create a selected probes list based on a search string.
Set<GeneSetTerm>	findSetsByGene(String searchOn) Identify gene sets that contain a particular gene or probe.
Set<GeneSetTerm>	findSetsByName(String searchOn)
GeneSetTerm	findTerm(String id)
boolean	geneSetExists(String id) Returns true if the class is in the classToProbe map
Set<GeneSetTerm>	getAllTerms() Get all gene sets, including ones that might be empty or redundant.
Set<GeneSetTerm>	getChildren(GeneSetTerm id)
Collection<Gene>	getGenes() Return all genes, including those that are 'inactive'.
GeneSet	getGeneSet(GeneSetTerm classid)
Set<Gene>	getGeneSetGenes(GeneSetTerm goset)
DirectedGraph<String,GeneSetTerm>	getGeneSetGraph()
Set<Probe>	getGeneSetProbes(GeneSetTerm geneSetId)
Set<GeneSet>	getGeneSets()
Collection<GeneSet>	getGeneSets(Collection<GeneSetTerm> terms)
Set<GeneSetTerm>	getGeneSetTerms()
GeneSetTerms	getGeneSetTermsHolder()
int	getMinimumGeneSetSize()
Multifunctionality	getMultifunctionality()
Set<Probe>	getProbes()
SettingsHolder	getSettings()
Set<GeneSet>	getUserDefinedGeneSets()
Set<GeneSetTerm>	getUserDefinedTerms() Get the gene sets that are user-defined.
boolean	hasGene(Gene g)
boolean	hasGeneSet(GeneSetTerm id)
boolean	hasProbe(Probe probeId)
boolean	hasRedundancy(GeneSetTerm id) Check if a group has any redundancies.
boolean	hasUsableAspect(GeneSetTerm geneSetTerm, boolean missingAspectTreatedAsUsable)
boolean	isReadOnly() Test whether this was constructed 'subcloning' style.
Collection<Gene>	loadPlainGeneList(String loadFile)
int	numActiveGeneSets() Count how many gene sets will be analyzed given the user's current settings (min and max size and aspects)
int	numActiveGeneSets(int minSize, int maxSize) Count how many gene sets will be analyzed given the user's current selected aspects and the provided minimum and maximum sizes.
int	numAnnotatedGenes() Compute how many genes have Gene set annotations.
int	numGenes() How many genes are currently available
int	numGeneSets() Get the number of gene sets currently available.
int	numGenesInGeneSet(GeneSetTerm id) Get the number of genes in a gene set, identified by id.
int	numProbes()
int	numProbesForGene(Gene g) Get how many probes point to the same gene.
int	numProbesInGeneSet(GeneSetTerm id) Get the number of probes in a gene set, identified by id.
void	print(Writer out) Print out the gene annotations in the same format we got them in, but if the gene sets have been modified, this will be reflected.
void	saveGeneSet(GeneSet toSave) Save changes to a user-defined gene set.
Collection<GeneSetTerm>	selectUserDefined() Make the selection the user-defined sets only.
void	setMessenger(StatusViewer m)
GeneAnnotations	subClone(Collection<Probe> probesToRetain) Create a new annotation set based on an existing one, for selected probes, removing probes with no annotations.
TableModel	toTableModel()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

DEFAULT_FILTER_NONSPECIFIC

public static final boolean DEFAULT_FILTER_NONSPECIFIC

Whether to filter out probes that hit more than one gene

See Also:

Constant Field Values

Constructor Detail

GeneAnnotations

public GeneAnnotations(Collection<Gene> genes,
               GeneSetTerms geneSetTerms,
               SettingsHolder settings,
               StatusViewer messenger)

Parameters:

genes -

geneSetTerms -

messenger -

GeneAnnotations

public GeneAnnotations(GeneAnnotations start,
               Collection<Probe> probes)

Create a read-only new annotation set based on an existing one, for selected probes, removing probes with no annotations.

Parameters:

start -

probes -

See Also:

GeneAnnotations(start, probes, pruneUnannotated)

GeneAnnotations

public GeneAnnotations(GeneAnnotations start,
               Collection<Probe> probes,
               boolean pruneUnannotated)

Create a read-only new annotation set based on an existing one, for selected probes, optionally removing unannotated probes. This involves making new GeneSets, but the GeneSetTerms, Genes and Probes themselves are 'reused'. Multifunctionality is recomputed based on the restricted set. However, you should use subClone() to avoid excessive duplication of annotation sets.

Parameters:

start -

probes - which must be a subset of those in start (others will be ignored)

pruneUnannotated - if true (normally!), probes lacking annotations are removed. This then becomes unmutable in the sense that adding annotations is not allowed.

GeneAnnotations

public GeneAnnotations(List<Gene> geneSymbols,
               List<Collection<GeneSetTerm>> goTerms,
               StatusViewer m)

Constructor designed for use when a file is not the immediate input of the data.

Parameters:

probes - A List of probes

geneSymbols - A List of gene symbols (e.g., ACTB), corresponding to the probes (in the same order)

geneNames - A List of gene names (e.g., "Actin"), corresponding to the probes (in the same order). This can be null.

goTerms - A List of Collections of Strings corresponding to the GO terms for each probe.

Throws:

IllegaArgumentException - if any of the required arguments are null, don't have sizes that match, etc.

GeneAnnotations

public GeneAnnotations(List<String> probes,
               List<String> genes,
               List<Collection<String>> goTerms)

Parameters:

genes -

goTerms -

Method Detail

addAnnotation

public int addAnnotation(Gene gene,
                Collection<GeneSetTerm> terms)

Parameters:

gene -

terms -

Returns:

how many annotations were added (i.e., were not already there)

addGeneSet

public void addGeneSet(GeneSet set)

Parameters:

set -

addGeneSet

public void addGeneSet(GeneSetTerm geneSetId,
              Collection<Gene> gs)

Parameters:

geneSetId -

gs -

addGeneSet

public GeneSet addGeneSet(GeneSetTerm geneSetId,
                 Collection<Gene> gs,
                 String sourceFile)

Add a user-defined gene set.

Parameters:

geneSetId -

gs - -- these should already be checked for compatibility (don't add new genes here, might be okay but considered undefined)

sourceFile - used for tracking sources and later modification/persistence.

Returns:

deleteGeneSet

public void deleteGeneSet(GeneSetTerm id)

Remove a gene set (class) from all the maps that reference it. This basically completely removes the class, and it cannot be restored unless there is a backup. If it is user-defined it is deleted entirely from the GeneSetTerms tree.

Parameters:

id -

deleteSubClone

public void deleteSubClone(GeneAnnotations a)

Remove a no-longer-needed subclone. This only removes the reference from this, if other objects maintain a reference it will obviously not be freed.

Parameters:

a -

deleteUserGeneSet

public boolean deleteUserGeneSet(GeneSetTerm classID)

Parameters:

classID -

Returns:

findGene

public Gene findGene(String symbol)

Case insensitive

Parameters:

symbol -

Returns:

findGeneSet

public GeneSet findGeneSet(GeneSetTerm term)

Parameters:

term -

Returns:

findGeneSet

public GeneSet findGeneSet(String name)

Parameters:

name -

Returns:

findProbe

public Probe findProbe(String probe)

Case insensitive

Parameters:

probe -

Returns:

findProbes

public Set<Probe> findProbes(String searchOn)

Create a selected probes list based on a search string.

Parameters:

searchOn - A string to be searched.

findSetsByGene

public Set<GeneSetTerm> findSetsByGene(String searchOn)

Identify gene sets that contain a particular gene or probe.

Parameters:

searchOn -

findSetsByName

public Set<GeneSetTerm> findSetsByName(String searchOn)

Parameters:

searchOn -

findTerm

public GeneSetTerm findTerm(String id)

Parameters:

id -

Returns:

geneSetExists

public boolean geneSetExists(String id)

Returns true if the class is in the classToProbe map

Parameters:

id - String a class id

Returns:

boolean

getAllTerms

public Set<GeneSetTerm> getAllTerms()

Get all gene sets, including ones that might be empty or redundant. Use for displaying lists that can then be filtered.

Returns:

getChildren

public Set<GeneSetTerm> getChildren(GeneSetTerm id)

Parameters:

id -

Returns:

immediate children of the term

getGenes

public Collection<Gene> getGenes()

Return all genes, including those that are 'inactive'.

Returns:

getGeneSet

public GeneSet getGeneSet(GeneSetTerm classid)

getGeneSetGenes

public Set<Gene> getGeneSetGenes(GeneSetTerm goset)

Parameters:

goset -

Returns:

set of genes in the given gene set (if any), based on the currently active probes

getGeneSetGraph

public DirectedGraph<String,GeneSetTerm> getGeneSetGraph()

Returns:

getGeneSetProbes

public Set<Probe> getGeneSetProbes(GeneSetTerm geneSetId)

Parameters:

geneSetId -

Returns:

active probes for the given gene set

getGeneSets

public Set<GeneSet> getGeneSets()

Returns:

view of all gene sets, NOT including empty ones - at least minimumGeneSetSize genes (i.e., 2).

getGeneSets

public Collection<GeneSet> getGeneSets(Collection<GeneSetTerm> terms)

Parameters:

terms -

Returns:

getGeneSetTerms

public Set<GeneSetTerm> getGeneSetTerms()

Returns:

view of all gene set terms, NOT including empty ones - at least minimumGeneSetSize genes (i.e., 2).

getGeneSetTermsHolder

public GeneSetTerms getGeneSetTermsHolder()

Returns:

getMinimumGeneSetSize

public int getMinimumGeneSetSize()

getMultifunctionality

public Multifunctionality getMultifunctionality()

getProbes

public Set<Probe> getProbes()

Returns:

the list of probes.

getSettings

public SettingsHolder getSettings()

Returns:

getUserDefinedGeneSets

public Set<GeneSet> getUserDefinedGeneSets()

Returns:

getUserDefinedTerms

public Set<GeneSetTerm> getUserDefinedTerms()

Get the gene sets that are user-defined.

Returns:

hasGene

public boolean hasGene(Gene g)

hasGeneSet

public boolean hasGeneSet(GeneSetTerm id)

Parameters:

id -

Returns:

hasProbe

public boolean hasProbe(Probe probeId)

Parameters:

probeId -

Returns:

hasRedundancy

public boolean hasRedundancy(GeneSetTerm id)

Check if a group has any redundancies.

Parameters:

id -

Returns:

hasUsableAspect

public boolean hasUsableAspect(GeneSetTerm geneSetTerm,
                      boolean missingAspectTreatedAsUsable)

Parameters:

geneSetTerm -

missingAspectTreatedAsUsable - What to do if the aspect is missing. User-defined groups (which don't have an aspect) aren't affected by this

Returns:

true if the gene set would be included in the analysis.

isReadOnly

public boolean isReadOnly()

Test whether this was constructed 'subcloning' style. This should usually be true in the context of analyses, which focus on analyzed subsets of the annotated genes. I recommend testing this in your code to make sure you aren't forgetting to do that step.

Returns:

loadPlainGeneList

public Collection<Gene> loadPlainGeneList(String loadFile)
                                   throws IOException

Throws:

IOException

numActiveGeneSets

public int numActiveGeneSets()

Count how many gene sets will be analyzed given the user's current settings (min and max size and aspects)

Returns:

numActiveGeneSets

public int numActiveGeneSets(int minSize,
                    int maxSize)

Count how many gene sets will be analyzed given the user's current selected aspects and the provided minimum and maximum sizes.

Parameters:

minSize -

maxSize -

Returns:

numAnnotatedGenes

public int numAnnotatedGenes()

Compute how many genes have Gene set annotations.

Returns:

numGenes

public int numGenes()

How many genes are currently available

numGeneSets

public int numGeneSets()

Get the number of gene sets currently available.

Returns:

numGenesInGeneSet

public int numGenesInGeneSet(GeneSetTerm id)

Get the number of genes in a gene set, identified by id.

Parameters:

id - String a class id

Returns:

int number of genes in the class

numProbes

public int numProbes()

Returns:

numProbesForGene

public int numProbesForGene(Gene g)

Get how many probes point to the same gene. This is like the old "numReplicates".

Parameters:

g -

Returns:

numProbesInGeneSet

public int numProbesInGeneSet(GeneSetTerm id)

Get the number of probes in a gene set, identified by id.

Parameters:

id - String a class id

Returns:

int number of probes in the class

print

public void print(Writer out)
           throws IOException

Print out the gene annotations in the same format we got them in, but if the gene sets have been modified, this will be reflected.

Parameters:

out -

Throws:

IOException

saveGeneSet

public void saveGeneSet(GeneSet toSave)
                 throws IOException

Save changes to a user-defined gene set.

Parameters:

toSave -

Throws:

IOException

selectUserDefined

public Collection<GeneSetTerm> selectUserDefined()

Make the selection the user-defined sets only.

setMessenger

public void setMessenger(StatusViewer m)

Parameters:

m -

subClone

public GeneAnnotations subClone(Collection<Probe> probesToRetain)

Create a new annotation set based on an existing one, for selected probes, removing probes with no annotations. Subclones should be treated as unmodifiable (though we don't enforce that strongly as it would greatly increase memory requirements)

Note that this could be changed in the future to consider the annotation aspect (BP, MF etc) not just the probes to retain. See comment in the Multifunctionality javadoc.

Parameters:

probesToRetain -

Returns:

toTableModel

public TableModel toTableModel()

Returns: