Package ubic.gemma.persistence.service.expression.experiment

Interface ExpressionExperimentService

All Superinterfaces:

BaseImmutableService<ExpressionExperiment>, BaseReadOnlyService<ExpressionExperiment>, BaseService<ExpressionExperiment>, BaseVoEnabledService<ExpressionExperiment,ExpressionExperimentValueObject>, CuratableService<ExpressionExperiment,ExpressionExperimentValueObject>, FilteringService<ExpressionExperiment>, FilteringVoEnabledService<ExpressionExperiment,ExpressionExperimentValueObject>

All Known Implementing Classes:

ExpressionExperimentServiceImpl

public interface ExpressionExperimentService
extends CuratableService<ExpressionExperiment,ExpressionExperimentValueObject>

Author:

kelsey

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static class	ExpressionExperimentService.CharacteristicWithUsageStatisticsAndOntologyTerm

Field Summary

Fields

Modifier and Type	Field	Description
static String	FREE_TEXT	Special indicator for free-text terms.
static String	UNCATEGORIZED	Special indicator for uncategorized terms.

Method Summary

Modifier and Type	Method	Description
void	addCharacteristic(ExpressionExperiment ee, Characteristic vc)	Will add the vocab characteristic to the expression experiment and persist the changes.
ExperimentalFactor	addFactor(ExpressionExperiment ee, ExperimentalFactor factor)
FactorValue	addFactorValue(ExpressionExperiment ee, FactorValue fv)
Map<BioMaterial,FactorValue>	addFactorValues(ExpressionExperiment ee, Map<BioMaterial,FactorValue> fvs)	Intended with the case of a continuous factor being added.
ExpressionExperiment	addRawVectors(ExpressionExperiment eeToUpdate, Collection<RawExpressionDataVector> newVectors)	Used when we want to add data for a quantitation type.
List<ExpressionExperiment>	browse(int start, int limit)
BatchInformationFetchingEvent	checkBatchFetchStatus(ExpressionExperiment ee)
boolean	checkHasBatchInfo(ExpressionExperiment ee)
long	countBioMaterials(Filters filters)
long	countWithCache(Filters filters, Set<Long> extraIds)
Collection<Long>	filter(String searchString)	returns ids of search results.
Collection<Long>	filterByTaxon(Collection<Long> ids, Taxon taxon)	Remove IDs of Experiments that are not from the given taxon.
Collection<ExpressionExperiment>	findByAccession(String accession)
Collection<ExpressionExperiment>	findByAccession(DatabaseEntry accession)
Collection<ExpressionExperiment>	findByBibliographicReference(BibliographicReference bibRef)
ExpressionExperiment	findByBioAssay(BioAssay ba)
ExpressionExperiment	findByBioMaterial(BioMaterial bm)
Map<ExpressionExperiment,BioMaterial>	findByBioMaterials(Collection<BioMaterial> bioMaterials)
ExpressionExperiment	findByDesign(ExperimentalDesign ed)
Collection<ExpressionExperiment>	findByExpressedGene(Gene gene, double rank)
ExpressionExperiment	findByFactor(ExperimentalFactor factor)
ExpressionExperiment	findByFactorValue(Long factorValueId)
ExpressionExperiment	findByFactorValue(FactorValue factorValue)
Map<ExpressionExperiment,FactorValue>	findByFactorValues(Collection<FactorValue> factorValues)
Collection<ExpressionExperiment>	findByGene(Gene gene)
Collection<ExpressionExperiment>	findByName(String name)
ExpressionExperiment	findByQuantitationType(QuantitationType type)
ExpressionExperiment	findByShortName(String shortName)
Collection<ExpressionExperiment>	findByTaxon(Taxon taxon)
List<ExpressionExperiment>	findByUpdatedLimit(int limit)
Collection<ExpressionExperiment>	findUpdatedAfter(Date date)
Map<Long,Long>	getAnnotationCountsByIds(Collection<Long> ids)
Set<AnnotationValueObject>	getAnnotationsById(Long eeId)
List<ExpressionExperimentService.CharacteristicWithUsageStatisticsAndOntologyTerm>	getAnnotationsUsageFrequency(Filters filters, Set<Long> extraIds, String category, Collection<String> excludedCategoryUris, Collection<String> excludedTermUris, int minFrequency, Collection<String> retainedTermUris, int maxResults)	Obtain annotation usage frequency for datasets matching the given filters.
Collection<ArrayDesign>	getArrayDesignsUsed(BioAssaySet expressionExperiment)
Map<ArrayDesign,Long>	getArrayDesignUsedOrOriginalPlatformUsageFrequency(Filters filters, Set<Long> extraIds, int maxResults)	Calculate the usage frequency of platforms by the datasets matching the provided filters.
String	getBatchConfound(ExpressionExperiment ee)	Checks the experiment for a batch confound.
BatchEffectType	getBatchEffect(ExpressionExperiment ee)	Obtain a BatchEffectType describing the batch effect state of the given experiment.
BatchEffectDetails	getBatchEffectDetails(ExpressionExperiment ee)	Obtain the full batch effect details of a given experiment.
String	getBatchEffectStatistics(ExpressionExperiment ee)	Obtain a string describing the summary statistics of a batch effect is present in the given experiment.
Collection<BioAssayDimension>	getBioAssayDimensions(ExpressionExperiment expressionExperiment)
long	getBioMaterialCount(ExpressionExperiment expressionExperiment)
Map<Characteristic,Long>	getCategoriesUsageFrequency(Filters filters, Set<Long> extraIds, Collection<String> excludedCategoryUris, Collection<String> excludedTermUris, Collection<String> retainedTermUris, int maxResults)	Obtain category usage frequency for datasets matching the given filter.
long	getDesignElementDataVectorCount(ExpressionExperiment ee)
Collection<ExpressionExperiment>	getExperimentsLackingPublications()
Collection<ExpressionExperiment>	getExperimentsWithOutliers()
Filters	getFiltersWithInferredAnnotations(Filters f, Collection<OntologyTerm> mentionedTerms, long timeout, TimeUnit timeUnit)	Apply ontological inference to augment a filter with additional terms.
Map<Long,Date>	getLastArrayDesignUpdate(Collection<ExpressionExperiment> expressionExperiments)
Date	getLastArrayDesignUpdate(ExpressionExperiment expressionExperiment)
Map<Long,AuditEvent>	getLastLinkAnalysis(Collection<Long> ids)
Map<Long,AuditEvent>	getLastMissingValueAnalysis(Collection<Long> ids)
Map<Long,AuditEvent>	getLastProcessedDataUpdate(Collection<Long> ids)
Map<Taxon,Long>	getPerTaxonCount()
Map<Long,Long>	getPopulatedFactorCounts(Collection<Long> ids)
Map<Long,Long>	getPopulatedFactorCountsExcludeBatch(Collection<Long> ids)
QuantitationType	getPreferredQuantitationType(ExpressionExperiment ee)	Iterates over the quantitation types for a given expression experiment and returns the preferred quantitation types.
Map<QuantitationType,Long>	getQuantitationTypeCount(ExpressionExperiment ee)
Collection<QuantitationType>	getQuantitationTypes(ExpressionExperiment expressionExperiment)
Collection<QuantitationTypeValueObject>	getQuantitationTypeValueObjects(ExpressionExperiment expressionExperiment)	Load all QuantitationType associated to an expression experiment as VOs.
Map<ExpressionExperiment,Collection<AuditEvent>>	getSampleRemovalEvents(Collection<ExpressionExperiment> expressionExperiments)
Collection<ExpressionExperimentSubSet>	getSubSets(ExpressionExperiment expressionExperiment)
<T extends BioAssaySet> Map<T,Taxon>	getTaxa(Collection<T> bioAssaySets)
Map<Taxon,Long>	getTaxaUsageFrequency(Filters filters, Set<Long> extraIds)	Calculate the usage frequency of taxa by the datasets matching the provided filters.
Taxon	getTaxon(BioAssaySet bioAssaySet)	Returns the taxon of the given expressionExperiment.
Map<TechnologyType,Long>	getTechnologyTypeUsageFrequency(Filters filters, Set<Long> extraIds)
boolean	hasProcessedExpressionData(ExpressionExperiment ee)	Test if the given experiment has processed data vectors.
boolean	isBlackListed(String geoAccession)
boolean	isRNASeq(ExpressionExperiment expressionExperiment)
Boolean	isSuitableForDEA(ExpressionExperiment ee)
boolean	isTroubled(ExpressionExperiment expressionExperiment)	Check if the dataset is either troubled or uses a troubled platform.
ExpressionExperiment	loadAndThaw(Long id)	Load an experiment and thaw it as per thaw(ExpressionExperiment).
<T extends Exception> ExpressionExperiment	loadAndThawLiteOrFail(Long id, Function<String,T> exceptionSupplier, String message)	Load an experiment and thaw it as per thawLite(ExpressionExperiment) or fail with the supplied exception and message.
<T extends Exception> ExpressionExperiment	loadAndThawOrFail(Long id, Function<String,T> exceptionSupplier, String message)	Load an experiment and thaw it as per thawLite(ExpressionExperiment) or fail with the supplied exception and message.
BioAssaySet	loadBioAssaySet(Long id)	Load a BioAssaySet by ID which can be either a ExpressionExperiment or a ExpressionExperimentSubSet.
Slice<ExpressionExperimentValueObject>	loadBlacklistedValueObjects(Filters filters, Sort sort, int offset, int limit)
Slice<ExpressionExperimentDetailsValueObject>	loadDetailsValueObjects(Collection<Long> ids, Taxon taxon, Sort sort, int offset, int limit)
List<ExpressionExperimentDetailsValueObject>	loadDetailsValueObjectsByIds(Collection<Long> ids)
List<ExpressionExperimentDetailsValueObject>	loadDetailsValueObjectsByIdsWithCache(Collection<Long> ids)
Slice<ExpressionExperimentDetailsValueObject>	loadDetailsValueObjectsWithCache(Collection<Long> ids, Taxon taxon, Sort sort, int offset, int limit)
List<Long>	loadIdsWithCache(Filters filters, Sort sort)
Collection<ExpressionExperiment>	loadLackingFactors()
Collection<ExpressionExperiment>	loadLackingTags()
List<ExpressionExperimentValueObject>	loadValueObjectsByIds(List<Long> ids, boolean maintainOrder)	Variant of CuratableService.loadValueObjectsByIds(Collection) that preserve its input order.
List<ExpressionExperimentValueObject>	loadValueObjectsByIdsWithRelationsAndCache(List<Long> ids)	Load VOs for the given dataset IDs and initialize their relations like CuratableService.load(Filters, Sort).
Slice<ExpressionExperimentValueObject>	loadValueObjectsWithCache(Filters filters, Sort sort, int offset, int limit)
ExpressionExperiment	loadWithCharacteristics(Long id)
ExpressionExperiment	loadWithMeanVarianceRelation(Long id)
ExpressionExperiment	loadWithPrimaryPublication(Long id)
ExpressionExperiment	replaceRawVectors(ExpressionExperiment ee, Collection<RawExpressionDataVector> vectors)	Used when we are replacing data, such as when converting an experiment from one platform to another.
ExpressionExperiment	thaw(ExpressionExperiment expressionExperiment)
ExpressionExperiment	thawBioAssays(ExpressionExperiment expressionExperiment)
ExpressionExperiment	thawLite(ExpressionExperiment expressionExperiment)	Partially thaw the expression experiment given - do not thaw the raw data.
ExpressionExperiment	thawLiter(ExpressionExperiment expressionExperiment)
MeanVarianceRelation	updateMeanVarianceRelation(ExpressionExperiment ee, MeanVarianceRelation mvr)

Methods inherited from interface ubic.gemma.persistence.service.BaseImmutableService

remove

Methods inherited from interface ubic.gemma.persistence.service.BaseReadOnlyService

countAll, findOrFail, getElementClass

Methods inherited from interface ubic.gemma.persistence.service.expression.arrayDesign.CuratableService

create, create, find, findOrCreate, load, load, load, load, loadAll, loadAllValueObjects, loadIds, loadOrFail, loadOrFail, loadOrFail, loadOrFail, loadValueObject, loadValueObjectById, loadValueObjects, loadValueObjects, loadValueObjects, loadValueObjectsByIds, remove, remove, save, save, update, update

Methods inherited from interface ubic.gemma.persistence.service.FilteringService

count, getFilter, getFilter, getFilter, getFilter, getFilterableProperties, getFilterablePropertyAllowedValues, getFilterablePropertyConfigAttributes, getFilterablePropertyDescription, getFilterablePropertyIsUsingSubquery, getFilterablePropertyResolvableAllowedValuesLabels, getFilterablePropertyType, getIdentifierPropertyName, getSort

Field Detail

FREE_TEXT

static final String FREE_TEXT

Special indicator for free-text terms.

See Also:

ExpressionExperimentDao.FREE_TEXT

UNCATEGORIZED

static final String UNCATEGORIZED

Special indicator for uncategorized terms.

See Also:

ExpressionExperimentDao.UNCATEGORIZED

Method Detail

addFactor

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
ExperimentalFactor addFactor(ExpressionExperiment ee,
                             ExperimentalFactor factor)

addFactorValue

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
FactorValue addFactorValue(ExpressionExperiment ee,
                           FactorValue fv)

Parameters:

ee - experiment.

fv - must already have the experimental factor filled in.

addFactorValues

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
Map<BioMaterial,FactorValue> addFactorValues(ExpressionExperiment ee,
                                                   Map<BioMaterial,FactorValue> fvs)

Intended with the case of a continuous factor being added.

Parameters:

ee -

fvs -

Returns:

addRawVectors

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
ExpressionExperiment addRawVectors(ExpressionExperiment eeToUpdate,
                                   Collection<RawExpressionDataVector> newVectors)

Used when we want to add data for a quantitation type. Does not remove any existing vectors.

Parameters:

eeToUpdate - experiment to be updated.

newVectors - vectors to be added.

Returns:

updated experiment.

browse

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_COLLECTION_READ"})
List<ExpressionExperiment> browse(int start,
                                  int limit)

checkBatchFetchStatus

@Nullable
BatchInformationFetchingEvent checkBatchFetchStatus(ExpressionExperiment ee)

checkHasBatchInfo

boolean checkHasBatchInfo(ExpressionExperiment ee)

filter

Collection<Long> filter(String searchString)
                 throws SearchException

returns ids of search results.

Parameters:

searchString - search string

Returns:

collection of ids or an empty collection.

Throws:

SearchException

filterByTaxon

Collection<Long> filterByTaxon(Collection<Long> ids,
                               Taxon taxon)

Remove IDs of Experiments that are not from the given taxon.

Parameters:

ids - collection to purge.

taxon - taxon to retain.

Returns:

purged IDs.

loadWithCharacteristics

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_READ_QUIET"})
ExpressionExperiment loadWithCharacteristics(Long id)

loadBioAssaySet

@Nullable
BioAssaySet loadBioAssaySet(Long id)

Load a BioAssaySet by ID which can be either a ExpressionExperiment or a ExpressionExperimentSubSet.

loadAndThawLiteOrFail

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_READ"})
<T extends Exception> ExpressionExperiment loadAndThawLiteOrFail(Long id,
                                                                 Function<String,T> exceptionSupplier,
                                                                 String message)
                                                          throws T extends Exception

Load an experiment and thaw it as per thawLite(ExpressionExperiment) or fail with the supplied exception and message.

Throws:

T extends Exception

loadAndThaw

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_READ"})
ExpressionExperiment loadAndThaw(Long id)

Load an experiment and thaw it as per thaw(ExpressionExperiment).

loadAndThawOrFail

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_READ"})
<T extends Exception> ExpressionExperiment loadAndThawOrFail(Long id,
                                                             Function<String,T> exceptionSupplier,
                                                             String message)
                                                      throws T extends Exception

Load an experiment and thaw it as per thawLite(ExpressionExperiment) or fail with the supplied exception and message.

Throws:

T extends Exception

loadIdsWithCache

List<Long> loadIdsWithCache(@Nullable
                            Filters filters,
                            @Nullable
                            Sort sort)

countWithCache

long countWithCache(@Nullable
                    Filters filters,
                    @Nullable
                    Set<Long> extraIds)

loadValueObjectsWithCache

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_VALUE_OBJECT_COLLECTION_READ"})
Slice<ExpressionExperimentValueObject> loadValueObjectsWithCache(@Nullable
                                                                 Filters filters,
                                                                 @Nullable
                                                                 Sort sort,
                                                                 int offset,
                                                                 int limit)

loadWithPrimaryPublication

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_READ_QUIET"})
ExpressionExperiment loadWithPrimaryPublication(Long id)

loadWithMeanVarianceRelation

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_READ_QUIET"})
ExpressionExperiment loadWithMeanVarianceRelation(Long id)

findByAccession

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_COLLECTION_READ"})
Collection<ExpressionExperiment> findByAccession(DatabaseEntry accession)

Parameters:

accession - accession

Returns:

Experiments which have the given accession. There can be more than one, because one GEO accession can result in multiple experiments in Gemma.

findByAccession

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_COLLECTION_READ"})
Collection<ExpressionExperiment> findByAccession(String accession)

findByBibliographicReference

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_COLLECTION_READ"})
Collection<ExpressionExperiment> findByBibliographicReference(BibliographicReference bibRef)

Parameters:

bibRef - bibliographic reference

Returns:

a collection of EE that have that reference that BibliographicReference

findByBioAssay

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_READ"})
ExpressionExperiment findByBioAssay(BioAssay ba)

Parameters:

ba - bio material

Returns:

experiment the given bioassay is associated with

findByBioMaterial

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_READ"})
ExpressionExperiment findByBioMaterial(BioMaterial bm)

Parameters:

bm - bio material

Returns:

experiment the given biomaterial is associated with

findByBioMaterials

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_MAP_READ"})
Map<ExpressionExperiment,BioMaterial> findByBioMaterials(Collection<BioMaterial> bioMaterials)

findByExpressedGene

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_COLLECTION_READ"})
Collection<ExpressionExperiment> findByExpressedGene(Gene gene,
                                                     double rank)

Parameters:

gene - gene

rank - rank

Returns:

a collection of expression experiment ids that express the given gene above the given expression level

findByDesign

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_READ"})
ExpressionExperiment findByDesign(ExperimentalDesign ed)

findByFactor

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_READ"})
ExpressionExperiment findByFactor(ExperimentalFactor factor)

findByFactorValue

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_READ"})
ExpressionExperiment findByFactorValue(FactorValue factorValue)

findByFactorValue

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_READ"})
ExpressionExperiment findByFactorValue(Long factorValueId)

findByFactorValues

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_MAP_READ"})
Map<ExpressionExperiment,FactorValue> findByFactorValues(Collection<FactorValue> factorValues)

findByGene

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_COLLECTION_READ"})
Collection<ExpressionExperiment> findByGene(Gene gene)

Parameters:

gene - gene

Returns:

a collection of expression experiments that have an AD that detects the given Gene (ie a probe on the AD hybridizes to the given Gene)

findByName

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_COLLECTION_READ"})
Collection<ExpressionExperiment> findByName(String name)

findByQuantitationType

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_READ"})
ExpressionExperiment findByQuantitationType(QuantitationType type)

findByShortName

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_READ_QUIET"})
ExpressionExperiment findByShortName(String shortName)

findByTaxon

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_COLLECTION_READ"})
Collection<ExpressionExperiment> findByTaxon(Taxon taxon)

findByUpdatedLimit

@Secured({"GROUP_AGENT","AFTER_ACL_COLLECTION_READ"})
List<ExpressionExperiment> findByUpdatedLimit(int limit)

findUpdatedAfter

@Secured({"GROUP_AGENT","AFTER_ACL_COLLECTION_READ"})
Collection<ExpressionExperiment> findUpdatedAfter(Date date)

getAnnotationCountsByIds

Map<Long,Long> getAnnotationCountsByIds(Collection<Long> ids)

Parameters:

ids - ids

Returns:

the map of ids to number of terms associated with each expression experiment.

getAnnotationsById

Set<AnnotationValueObject> getAnnotationsById(Long eeId)

Parameters:

eeId - experiment id.

Returns:

the terms associated this expression experiment.

getFiltersWithInferredAnnotations

Filters getFiltersWithInferredAnnotations(Filters f,
                                          @Nullable
                                          Collection<OntologyTerm> mentionedTerms,
                                          long timeout,
                                          TimeUnit timeUnit)
                                   throws TimeoutException

Apply ontological inference to augment a filter with additional terms.

Parameters:

mentionedTerms - if non-null, all the terms explicitly mentioned in the filters are added to the collection. The returned filter might contain terms that have been inferred.

Throws:

TimeoutException

getCategoriesUsageFrequency

Map<Characteristic,Long> getCategoriesUsageFrequency(@Nullable
                                                           Filters filters,
                                                           @Nullable
                                                           Set<Long> extraIds,
                                                           @Nullable
                                                           Collection<String> excludedCategoryUris,
                                                           @Nullable
                                                           Collection<String> excludedTermUris,
                                                           @Nullable
                                                           Collection<String> retainedTermUris,
                                                           int maxResults)
                                                    throws SearchException

Obtain category usage frequency for datasets matching the given filter.

Parameters:

filters - filters restricting the terms to a given set of datasets

excludedCategoryUris - ensure that the given category URIs are excluded

excludedTermUris - ensure that the given term URIs and their sub-terms (as per subClassOf relation) are excluded; this requires relevant ontologies to be loaded in OntologyService.

retainedTermUris - ensure that the given terms are retained (overrides any exclusion from minFrequency and excludedTermUris)

maxResults - maximum number of results to return

Throws:

SearchException

getAnnotationsUsageFrequency

List<ExpressionExperimentService.CharacteristicWithUsageStatisticsAndOntologyTerm> getAnnotationsUsageFrequency(@Nullable
                                                                                                                Filters filters,
                                                                                                                @Nullable
                                                                                                                Set<Long> extraIds,
                                                                                                                @Nullable
                                                                                                                String category,
                                                                                                                @Nullable
                                                                                                                Collection<String> excludedCategoryUris,
                                                                                                                @Nullable
                                                                                                                Collection<String> excludedTermUris,
                                                                                                                int minFrequency,
                                                                                                                @Nullable
                                                                                                                Collection<String> retainedTermUris,
                                                                                                                int maxResults)

Obtain annotation usage frequency for datasets matching the given filters.

Terms may originate from the experiment tags, experimental design or samples.

The implementation uses a denormalized table for associating EEs to characteristics which is not always in sync if new terms are attached.

Parameters:

filters - filters restricting the terms to a given set of datasets

category - a category to restrict annotations to, or null to include all categories

excludedCategoryUris - ensure that the given category URIs are excluded

excludedTermUris - ensure that the given term URIs and their sub-terms (as per subClassOf relation) are excluded; this requires relevant ontologies to be loaded in OntologyService.

minFrequency - minimum occurrences of a term to be included in the results

retainedTermUris - ensure that the given terms are retained (overrides any exclusion from minFrequency and excludedTermUris)

maxResults - maximum number of results to return

Returns:

mapping annotations grouped by category and term (URI or value if null) to their number of occurrences in the matched datasets and ordered in descending number of associated experiments

See Also:

ExpressionExperimentDao.getAnnotationsUsageFrequency(Collection, Class, int, int, String, Collection, Collection, Collection)

getArrayDesignsUsed

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<ArrayDesign> getArrayDesignsUsed(BioAssaySet expressionExperiment)

Parameters:

expressionExperiment - experiment

Returns:

a collection of ArrayDesigns referenced by any of the BioAssays that make up the given ExpressionExperiment.

getTechnologyTypeUsageFrequency

Map<TechnologyType,Long> getTechnologyTypeUsageFrequency(@Nullable
                                                               Filters filters,
                                                               @Nullable
                                                               Set<Long> extraIds)

getArrayDesignUsedOrOriginalPlatformUsageFrequency

Map<ArrayDesign,Long> getArrayDesignUsedOrOriginalPlatformUsageFrequency(@Nullable
                                                                               Filters filters,
                                                                               @Nullable
                                                                               Set<Long> extraIds,
                                                                               int maxResults)

Calculate the usage frequency of platforms by the datasets matching the provided filters.

Parameters:

filters - a set of filters to be applied as per CuratableService.load(Filters, Sort, int, int)

extraIds -

maxResults - the maximum of results, or unlimited if less than 1

getTaxaUsageFrequency

Map<Taxon,Long> getTaxaUsageFrequency(@Nullable
                                            Filters filters,
                                            @Nullable
                                            Set<Long> extraIds)

Calculate the usage frequency of taxa by the datasets matching the provided filters.

If no filters are supplied (either being null or empty), the getPerTaxonCount() fast path is used.

See Also:

getPerTaxonCount()

getBatchConfound

@Nullable
String getBatchConfound(ExpressionExperiment ee)

Checks the experiment for a batch confound.

Parameters:

ee - the experiment to check.

Returns:

a string describing the batch confound, or null if there was no batch confound.[FIXME: String return value is unsafe]

getBatchEffectDetails

BatchEffectDetails getBatchEffectDetails(ExpressionExperiment ee)

Obtain the full batch effect details of a given experiment.

Parameters:

ee - experiment

Returns:

details for the principal component most associated with batches (even if it isn't "significant"). Note that we don't look at every component, just the first few.

getBatchEffect

BatchEffectType getBatchEffect(ExpressionExperiment ee)

Obtain a BatchEffectType describing the batch effect state of the given experiment.

Parameters:

ee - the experiment to get the batch effect for.

getBatchEffectStatistics

@Nullable
String getBatchEffectStatistics(ExpressionExperiment ee)

Obtain a string describing the summary statistics of a batch effect is present in the given experiment.

Returns:

summary statistics or null if there is no batch effect

getBioAssayDimensions

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<BioAssayDimension> getBioAssayDimensions(ExpressionExperiment expressionExperiment)

Parameters:

expressionExperiment - experiment

Returns:

the BioAssayDimensions for the study.

getBioMaterialCount

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
long getBioMaterialCount(ExpressionExperiment expressionExperiment)

Parameters:

expressionExperiment - experiment

Returns:

the amount of biomaterials associated with the given expression experiment.

getDesignElementDataVectorCount

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
long getDesignElementDataVectorCount(ExpressionExperiment ee)

getExperimentsWithOutliers

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_COLLECTION_READ"})
Collection<ExpressionExperiment> getExperimentsWithOutliers()

getLastArrayDesignUpdate

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
Map<Long,Date> getLastArrayDesignUpdate(Collection<ExpressionExperiment> expressionExperiments)

getLastArrayDesignUpdate

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Date getLastArrayDesignUpdate(ExpressionExperiment expressionExperiment)

Parameters:

expressionExperiment - experiment

Returns:

the date of the last time any of the array designs associated with this experiment were updated.

getLastLinkAnalysis

Map<Long,AuditEvent> getLastLinkAnalysis(Collection<Long> ids)

Parameters:

ids - ids

Returns:

AuditEvents of the latest link analyses for the specified expression experiment ids. This returns a map of id -> AuditEvent. If the events do not exist, the map entry will point to null.

getLastMissingValueAnalysis

Map<Long,AuditEvent> getLastMissingValueAnalysis(Collection<Long> ids)

Parameters:

ids - ids

Returns:

AuditEvents of the latest missing value analysis for the specified expression experiment ids. This returns a map of id -> AuditEvent. If the events do not exist, the map entry will point to null.

getLastProcessedDataUpdate

Map<Long,AuditEvent> getLastProcessedDataUpdate(Collection<Long> ids)

Parameters:

ids - ids

Returns:

AuditEvents of the latest rank computation for the specified expression experiment ids. This returns a map of id -> AuditEvent. If the events do not exist, the map entry will point to null.

getPerTaxonCount

Map<Taxon,Long> getPerTaxonCount()

Returns:

a count of expression experiments, grouped by Taxon

getPopulatedFactorCounts

Map<Long,Long> getPopulatedFactorCounts(Collection<Long> ids)

Parameters:

ids - ids

Returns:

map of ids to how many factor values the experiment has, counting only factor values which are associated with biomaterials.

getPopulatedFactorCountsExcludeBatch

Map<Long,Long> getPopulatedFactorCountsExcludeBatch(Collection<Long> ids)

Parameters:

ids - ids

Returns:

map of ids to how many factor values the experiment has, counting only factor values which are associated with biomaterials and only factors that aren't batch

getPreferredQuantitationType

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
QuantitationType getPreferredQuantitationType(ExpressionExperiment ee)

Iterates over the quantitation types for a given expression experiment and returns the preferred quantitation types.

Parameters:

ee - experiment

Returns:

quantitation types

hasProcessedExpressionData

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
boolean hasProcessedExpressionData(ExpressionExperiment ee)

Test if the given experiment has processed data vectors.

getQuantitationTypeCount

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Map<QuantitationType,Long> getQuantitationTypeCount(ExpressionExperiment ee)

Returns:

count of an expressionExperiment's design element data vectors, grouped by quantitation type

getQuantitationTypes

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<QuantitationType> getQuantitationTypes(ExpressionExperiment expressionExperiment)

Parameters:

expressionExperiment - experiment

Returns:

all the quantitation types used by the given expression experiment

getQuantitationTypeValueObjects

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<QuantitationTypeValueObject> getQuantitationTypeValueObjects(ExpressionExperiment expressionExperiment)

Load all QuantitationType associated to an expression experiment as VOs.

See Also:

getQuantitationTypes(ExpressionExperiment)

getSampleRemovalEvents

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_MAP_READ"})
Map<ExpressionExperiment,Collection<AuditEvent>> getSampleRemovalEvents(Collection<ExpressionExperiment> expressionExperiments)

getSubSets

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_COLLECTION_READ"})
Collection<ExpressionExperimentSubSet> getSubSets(ExpressionExperiment expressionExperiment)

Parameters:

expressionExperiment - experiment

Returns:

any ExpressionExperimentSubSets this Experiment might have.

getTaxa

<T extends BioAssaySet> Map<T,Taxon> getTaxa(Collection<T> bioAssaySets)

getTaxon

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Taxon getTaxon(BioAssaySet bioAssaySet)

Returns the taxon of the given expressionExperiment.

Parameters:

bioAssaySet - bioAssaySet.

Returns:

taxon, or null if the experiment taxon cannot be determined (i.e., if it has no samples).

isRNASeq

boolean isRNASeq(ExpressionExperiment expressionExperiment)

Parameters:

expressionExperiment - ee

Returns:

true if this experiment was run on a sequencing-based platform.

isTroubled

boolean isTroubled(ExpressionExperiment expressionExperiment)

Check if the dataset is either troubled or uses a troubled platform.

loadDetailsValueObjects

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_VALUE_OBJECT_COLLECTION_READ"})
Slice<ExpressionExperimentDetailsValueObject> loadDetailsValueObjects(Collection<Long> ids,
                                                                      @Nullable
                                                                      Taxon taxon,
                                                                      @Nullable
                                                                      Sort sort,
                                                                      int offset,
                                                                      int limit)

See Also:

ExpressionExperimentDao.loadDetailsValueObjects(Collection, Taxon, Sort, int, int)

loadDetailsValueObjectsWithCache

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_VALUE_OBJECT_COLLECTION_READ"})
Slice<ExpressionExperimentDetailsValueObject> loadDetailsValueObjectsWithCache(Collection<Long> ids,
                                                                               @Nullable
                                                                               Taxon taxon,
                                                                               @Nullable
                                                                               Sort sort,
                                                                               int offset,
                                                                               int limit)

loadDetailsValueObjectsByIds

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_VALUE_OBJECT_COLLECTION_READ"})
List<ExpressionExperimentDetailsValueObject> loadDetailsValueObjectsByIds(Collection<Long> ids)

loadDetailsValueObjectsByIdsWithCache

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_VALUE_OBJECT_COLLECTION_READ"})
List<ExpressionExperimentDetailsValueObject> loadDetailsValueObjectsByIdsWithCache(Collection<Long> ids)

loadBlacklistedValueObjects

@Secured({"GROUP_ADMIN","AFTER_ACL_VALUE_OBJECT_COLLECTION_READ"})
Slice<ExpressionExperimentValueObject> loadBlacklistedValueObjects(@Nullable
                                                                   Filters filters,
                                                                   @Nullable
                                                                   Sort sort,
                                                                   int offset,
                                                                   int limit)

loadLackingFactors

@Secured({"GROUP_USER","AFTER_ACL_COLLECTION_READ"})
Collection<ExpressionExperiment> loadLackingFactors()

loadLackingTags

@Secured({"GROUP_USER","AFTER_ACL_COLLECTION_READ"})
Collection<ExpressionExperiment> loadLackingTags()

loadValueObjectsByIdsWithRelationsAndCache

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_VALUE_OBJECT_COLLECTION_READ"})
List<ExpressionExperimentValueObject> loadValueObjectsByIdsWithRelationsAndCache(List<Long> ids)

Load VOs for the given dataset IDs and initialize their relations like CuratableService.load(Filters, Sort).

The order of VOs is preserved.

loadValueObjectsByIds

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_VALUE_OBJECT_COLLECTION_READ"})
List<ExpressionExperimentValueObject> loadValueObjectsByIds(List<Long> ids,
                                                            boolean maintainOrder)

Variant of CuratableService.loadValueObjectsByIds(Collection) that preserve its input order.

Parameters:

ids - ids to load

maintainOrder - If true, order of valueObjects returned will correspond to order of ids passed in.

Returns:

value objects

replaceRawVectors

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
ExpressionExperiment replaceRawVectors(ExpressionExperiment ee,
                                       Collection<RawExpressionDataVector> vectors)

Used when we are replacing data, such as when converting an experiment from one platform to another. Examples would be exon array or RNA-seq data sets, or other situations where we are replacing data. Does not take care of computing the processed data vectors, but it does clear them out.

Parameters:

ee - experiment

vectors - If they are from more than one platform, that will be dealt with.

Returns:

the updated Experiment

addCharacteristic

void addCharacteristic(ExpressionExperiment ee,
                       Characteristic vc)

Will add the vocab characteristic to the expression experiment and persist the changes.

Parameters:

ee - the experiment to add the characteristics to.

vc - If the evidence code is null, it will be filled in with IC. A category and value must be provided.

thaw

@CheckReturnValue
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
ExpressionExperiment thaw(ExpressionExperiment expressionExperiment)

thawBioAssays

@CheckReturnValue
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
ExpressionExperiment thawBioAssays(ExpressionExperiment expressionExperiment)

thawLite

@CheckReturnValue
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
ExpressionExperiment thawLite(ExpressionExperiment expressionExperiment)

Partially thaw the expression experiment given - do not thaw the raw data.

Parameters:

expressionExperiment - experiment

Returns:

thawed experiment

thawLiter

@CheckReturnValue
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
ExpressionExperiment thawLiter(ExpressionExperiment expressionExperiment)

isBlackListed

boolean isBlackListed(String geoAccession)

isSuitableForDEA

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Boolean isSuitableForDEA(ExpressionExperiment ee)

Returns:

true if the experiment is not explicitly marked as unsuitable for DEA; false otherwise.

getExperimentsLackingPublications

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<ExpressionExperiment> getExperimentsLackingPublications()

Returns:

collection of GEO experiments which lack an association with a publication (non-GEO experiments will be ignored)

updateMeanVarianceRelation

@Secured("GROUP_USER")
MeanVarianceRelation updateMeanVarianceRelation(ExpressionExperiment ee,
                                                MeanVarianceRelation mvr)

countBioMaterials

long countBioMaterials(@Nullable
                       Filters filters)

See Also:

ExpressionExperimentDao.countBioMaterials(Filters)