Interface ExpressionExperimentService

All Superinterfaces:

BaseImmutableService<ExpressionExperiment>, BaseReadOnlyService<ExpressionExperiment>, BaseService<ExpressionExperiment>, BaseVoEnabledService<ExpressionExperiment, ExpressionExperimentValueObject>, FilteringService<ExpressionExperiment>, FilteringVoEnabledService<ExpressionExperiment, ExpressionExperimentValueObject>, SecurableBaseImmutableService<ExpressionExperiment>, SecurableBaseReadOnlyService<ExpressionExperiment>, SecurableBaseService<ExpressionExperiment>, SecurableBaseVoEnabledService<ExpressionExperiment, ExpressionExperimentValueObject>, SecurableFilteringVoEnabledService<ExpressionExperiment, ExpressionExperimentValueObject>

All Known Implementing Classes:

ExpressionExperimentServiceImpl

public interface ExpressionExperimentService
extends SecurableBaseService<ExpressionExperiment>, SecurableFilteringVoEnabledService<ExpressionExperiment, ExpressionExperimentValueObject>

Author:

kelsey

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static final class	ExpressionExperimentService.CharacteristicWithUsageStatisticsAndOntologyTerm

Field Summary

Fields

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

Method Summary

Modifier and Type	Method	Description
Characteristic	addAnnotation(ExpressionExperiment ee, Characteristic vc)	Add a single experiment-level tag to ee as part of the per-tag REST write flow.
Characteristic	addAnnotation(ExpressionExperiment ee, Characteristic vc, String reason)	As addAnnotation(ExpressionExperiment, Characteristic), with a caller-supplied reason appended to the audit note after the server's own 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)
void	addFactorValues(ExpressionExperiment ee, Map<BioMaterial, FactorValue> fvs)	Intended with the case of a continuous factor being added.
int	addRawDataVectors(ExpressionExperiment eeToUpdate, QuantitationType quantitationType, Collection<RawExpressionDataVector> newVectors)	Used when we want to add data for a quantitation type.
DesignApplyOutcome	applyDesignChange(ExpressionExperiment ee, ExperimentalDesignValueObject proposed)	Apply proposed as the experiment's new ExperimentalDesign.
List<ExpressionExperiment>	browse(int start, int limit)
CurationCommitResult	commitCuration(ExpressionExperiment ee, CurationCommitRequest request, boolean dryRun)	Apply an all-or-none curation commit to ee, reconciling the sections carried in request in a single transaction (phase 1: basics + publications).
long	countBioMaterials(Filters filters)
long	countWithCache(Filters filters, Set<Long> extraIds)	Count the number of experiments that match the given filters.
int	createProcessedDataVectors(ExpressionExperiment ee, Collection<ProcessedExpressionDataVector> vectors)	Create a new set of processed vectors for an experiment.
boolean	existsByShortName(String datasetShortName)	Check if a dataset with a given short name.
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	findByBioAssay(BioAssay ba, boolean includeSubSets)
Collection<ExpressionExperiment>	findByBioMaterial(BioMaterial bm)
Collection<ExpressionExperiment>	findByBioMaterial(BioMaterial bm, boolean includeSubSets)
Map<ExpressionExperiment, Collection<BioMaterial>>	findByBioMaterials(Collection<BioMaterial> biomaterials)
ExpressionExperiment	findByDesign(ExperimentalDesign ed)
ExpressionExperiment	findByDesignId(Long designId)
Collection<ExpressionExperiment>	findByExpressedGene(Gene gene, double rank)
ExpressionExperiment	findByFactor(ExperimentalFactor factor)
Collection<ExpressionExperiment>	findByFactors(Collection<ExperimentalFactor> factors)
ExpressionExperiment	findByFactorValue(FactorValue factorValue)
ExpressionExperiment	findByFactorValueId(Long factorValueId)
Collection<ExpressionExperiment>	findByFactorValueIds(Collection<Long> factorValueIds)
Collection<ExpressionExperiment>	findByFactorValues(Collection<FactorValue> factorValues)
Collection<ExpressionExperiment>	findByGene(Gene gene)
ExpressionExperiment	findByMeanVarianceRelation(MeanVarianceRelation mvr)
Collection<ExpressionExperiment>	findByName(String name)
ExpressionExperiment	findByQuantitationType(QuantitationType type)
ExpressionExperiment	findByShortName(String shortName)
ExpressionExperiment	findByShortNameAndThawLite(String shortName)
ExpressionExperiment	findByShortNameWithPrimaryPublication(String shortName)
Collection<ExpressionExperiment>	findByTaxon(Taxon taxon)
List<ExpressionExperiment>	findByUpdatedLimit(int limit)
Long	findIdByBioAssay(BioAssay ba, boolean b)
Long	findIdByDesign(ExperimentalDesign design)
Long	findIdByFactor(ExperimentalFactor factor)
Long	findIdByFactorValue(FactorValue factor)
Long	findIdByMeanVarianceRelation(MeanVarianceRelation mvr)
Collection<Long>	findIdsByBioMaterial(BioMaterial bm, boolean includeSubSets)
ExpressionExperiment	findOneByAccession(String accession)
ExpressionExperiment	findOneByName(String name)
Collection<ExpressionExperiment>	findUpdatedAfter(Date date)
Map<Long,Long>	getAnnotationCountsByIds(Collection<Long> ids)
Set<AnnotationValueObject>	getAnnotations(ExpressionExperiment ee)	Retrieve annotations for a given experiment.
Set<AnnotationValueObject>	getAnnotations(ExpressionExperiment ee, boolean includeFreeText)	Retrieve annotations for a given experiment, optionally including unmapped ones.
Set<AnnotationValueObject>	getAnnotations(ExpressionExperimentSubSet ee)	Retrieve annotations for a given experiment subset.
Set<AnnotationValueObject>	getAnnotations(ExpressionExperimentSubSet ee, boolean includeFreeText)	Retrieve annotations for a given experiment subset, optionally including unmapped ones.
List<ExpressionExperimentService.CharacteristicWithUsageStatisticsAndOntologyTerm>	getAnnotationsUsageFrequency(Filters filters, Set<Long> extraIds, String category, Collection<String> excludedCategoryUris, Collection<String> excludedTermUris, int minFrequency, Collection<String> retainedTermUris, int maxResults, boolean includePredicates, boolean includeObjects, long timeout, TimeUnit timeUnit)	Obtain annotation usage frequency for datasets matching the given filters.
Collection<ArrayDesign>	getArrayDesignsUsed(ExpressionExperiment expressionExperiment)
Collection<ArrayDesign>	getArrayDesignsUsed(ExpressionExperiment ee, QuantitationType qt)	Obtain a collection of ArrayDesign used by a specific set of vectors.
Collection<ArrayDesign>	getArrayDesignsUsed(ExpressionExperiment ee, QuantitationType qt, Class<? extends DataVector> vectorType)	Obtain a collection of ArrayDesign used by a specific set of vectors.
Map<ExpressionExperiment, Collection<ArrayDesign>>	getArrayDesignsUsedByExperiment(Collection<ExpressionExperiment> expressionExperiments)	Per-experiment map of array designs used: one HQL covers all supplied EEs and the result preserves which platform belongs to which EE.
Map<ArrayDesign, Long>	getArrayDesignUsedOrOriginalPlatformUsageFrequency(Filters filters, Set<Long> extraIds, int maxResults)	Calculate the usage frequency of platforms by the datasets matching the provided filters.
BioAssayDimension	getBioAssayDimension(ExpressionExperiment ee, QuantitationType qt)	Obtain the dimension associated to the given quantitation type for the given experiment.
BioAssayDimension	getBioAssayDimension(ExpressionExperiment ee, QuantitationType qt, Class<? extends BulkExpressionDataVector> dataVectorType)
BioAssayDimension	getBioAssayDimensionById(ExpressionExperiment ee, Long dimensionId)	Find a BioAssayDimension by ID.
BioAssayDimension	getBioAssayDimensionById(ExpressionExperiment ee, Long dimensionId, Class<? extends BulkExpressionDataVector> dataVectorType)
Collection<BioAssayDimension>	getBioAssayDimensionsWithAssays(ExpressionExperiment expressionExperiment)	Obtain all the dimensions associated to the given experiment.
Collection<BioAssayDimension>	getBioAssayDimensionsWithAssays(ExpressionExperiment ee, QuantitationType qt)	Obtain all BioAssayDimensions associated to a particular QuantitationType.
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.
Filters	getEnhancedFilters(Filters f, Collection<OntologyTerm> mentionedTerms, Collection<OntologyTerm> inferredTerms, long timeout, TimeUnit timeUnit)	Perform various transformation to the provided filters to enhance it.
ExperimentalDesignValueObject	getExperimentalDesignValueObject(ExpressionExperiment ee)	Build a full structured representation of an experiment's ExperimentalDesign: factors, factor values (with statements carrying stable database IDs), and per-biomaterial factor-value assignments.
Collection<ExpressionExperiment>	getExperimentsLackingPublications(int maxResults)
Collection<ExpressionExperiment>	getExperimentsWithOutliers()
Collection<Gene>	getGenesUsedByPreferredVectors(ExpressionExperiment experimentConstraint)	Retrieve the genes used by the preferred vectors of this experiment.
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<QuantitationType, Collection<RawExpressionDataVector>>	getMissingValuesVectors(ExpressionExperiment ee)
Map<BioAssay,Long>	getNumberOfDesignElementsPerSample(ExpressionExperiment expressionExperiment)	Obtain the number of design elements for the platform of each bioassay in the given experiment.
Map<Taxon,Long>	getPerTaxonCount()
Map<Long,Long>	getPopulatedFactorCounts(Collection<Long> ids)
Map<Long,Long>	getPopulatedFactorCountsExcludeBatch(Collection<Long> ids)
Optional<QuantitationType>	getPreferredQuantitationType(ExpressionExperiment ee)	Iterates over the quantitation types for a given expression experiment and returns the preferred quantitation types.
Collection<RawExpressionDataVector>	getPreferredRawDataVectors(ExpressionExperiment expressionExperiment)
BioAssayDimension	getProcessedBioAssayDimension(ExpressionExperiment ee)	Obtain the dimension associated to the processed data for the given experiment.
Collection<BioAssayDimension>	getProcessedBioAssayDimensionsWithAssays(ExpressionExperiment ee)	Obtain the dimension associated to the processed data for the given experiment.
Optional<Collection<ProcessedExpressionDataVector>>	getProcessedDataVectors(ExpressionExperiment ee)
Optional<Collection<ProcessedExpressionDataVector>>	getProcessedDataVectors(ExpressionExperiment ee, List<BioAssay> assays)
Optional<QuantitationType>	getProcessedQuantitationType(ExpressionExperiment ee)
Map<QuantitationType, Long>	getQuantitationTypeCount(ExpressionExperiment ee)
Collection<QuantitationType>	getQuantitationTypes(ExpressionExperiment expressionExperiment)	Retrieve all the quantitation types used by the given expression experiment.
Collection<QuantitationType>	getQuantitationTypes(ExpressionExperiment expressionExperiment, BioAssayDimension dimension)	Retrieve all the quantitation types used by the given experiment and dimension.
Collection<QuantitationType>	getQuantitationTypes(ExpressionExperiment expressionExperiment, BioAssayDimension dimension, Class<? extends BulkExpressionDataVector> dataVectorType)
Map<Class<? extends DataVector>, Set<QuantitationType>>	getQuantitationTypesByVectorType(ExpressionExperiment ee)
Collection<QuantitationTypeValueObject>	getQuantitationTypeValueObjects(ExpressionExperiment expressionExperiment)	Load all QuantitationType associated to an expression experiment as VOs.
long	getRawDataVectorCount(ExpressionExperiment ee)
Collection<RawExpressionDataVector>	getRawDataVectors(ExpressionExperiment ee, List<BioAssay> samples, QuantitationType qt)
Collection<RawExpressionDataVector>	getRawDataVectors(ExpressionExperiment ee, QuantitationType qt)
Map<ExpressionExperiment, Collection<AuditEvent>>	getSampleRemovalEvents(Collection<ExpressionExperiment> expressionExperiments)
String	getSourceMetadata(ExpressionExperiment ee)
ExpressionExperimentSubSet	getSubSetByIdWithCharacteristics(ExpressionExperiment ee, Long subSetId)
ExpressionExperimentSubSet	getSubSetByIdWithCharacteristicsAndBioAssays(ExpressionExperiment ee, Long subSetId)	Obtain a particular subset by ID.
Collection<ExpressionExperimentSubSet>	getSubSets(ExpressionExperiment expressionExperiment, BioAssayDimension dimension)	Obtain the subsets for a particular dimension.
Map<BioAssayDimension, Set<ExpressionExperimentSubSet>>	getSubSetsByDimension(ExpressionExperiment expressionExperiment)	Obtain all the subsets organized by dimension for a given dataset.
Map<BioAssayDimension, Set<ExpressionExperimentSubSet>>	getSubSetsByDimensionWithBioAssays(ExpressionExperiment expressionExperiment)	Obtain all the subsets organized by dimension for a given dataset.
Map<ExperimentalFactor, Map<FactorValue, ExpressionExperimentSubSet>>	getSubSetsByFactorValue(ExpressionExperiment expressionExperiment, BioAssayDimension dimension)	Reconstitute the FV to subset mapping for a given experiment.
Map<FactorValue, ExpressionExperimentSubSet>	getSubSetsByFactorValue(ExpressionExperiment expressionExperiment, ExperimentalFactor experimentalFactor, BioAssayDimension dimension)	Reconstitute the FV to subset mapping for a given experiment and factor.
Map<FactorValue, ExpressionExperimentSubSet>	getSubSetsByFactorValueWithCharacteristicsAndBioAssays(ExpressionExperiment expressionExperiment, ExperimentalFactor experimentalFactor, BioAssayDimension dimension)	Reconstitute the FV to subset mapping for a given experiment and factor.
Map<ExpressionExperiment, Collection<ExpressionExperimentSubSet>>	getSubSetsWithBioAssays(Collection<ExpressionExperiment> expressionExperiments)	Batched variant of getSubSetsWithBioAssays(ExpressionExperiment): obtain subsets for every experiment in the input collection in a single query, keyed by source experiment.
Collection<ExpressionExperimentSubSet>	getSubSetsWithBioAssays(ExpressionExperiment expressionExperiment)	Obtain all the subsets for a given dataset.
Collection<ExpressionExperimentSubSet>	getSubSetsWithBioAssays(ExpressionExperiment expressionExperiment, BioAssayDimension dimension)	Obtain the subsets for a particular dimension.
Collection<ExpressionExperimentSubSet>	getSubSetsWithCharacteristics(ExpressionExperiment ee)	Obtain all the subsets for a given dataset.
Map<ExpressionExperiment, Taxon>	getTaxa(Collection<ExpressionExperiment> ees)	Return the taxon for each of the given experiments.
Map<Taxon,Long>	getTaxaUsageFrequency(Filters filters, Set<Long> extraIds)	Calculate the usage frequency of taxa by the datasets matching the provided filters.
Taxon	getTaxon(ExpressionExperiment expressionExperiment)	Returns the taxon of the given experiment.
Map<TechnologyType, Long>	getTechnologyTypeUsageFrequency(Filters filters, Set<Long> extraIds)
boolean	hasProcessedExpressionData(ExpressionExperiment ee)	Test if the given experiment has processed data vectors.
boolean	hasSourceMetadata(ExpressionExperiment ee)
boolean	isBlackListed(String geoAccession)
boolean	isRNASeq(ExpressionExperiment expressionExperiment)
boolean	isSingleCell(ExpressionExperiment ee)	Indicate if the given experiment is a single-cell experiment.
Boolean	isSuitableForDEA(ExpressionExperiment ee)
boolean	isTroubled(ExpressionExperiment expressionExperiment)	Check if the dataset is either troubled or uses a troubled platform.
boolean	isTwoChannel(ExpressionExperiment expressionExperiment)	Deprecated. Two-colour arrays are no longer supported for new data; kept so existing two-colour datasets still load and reprocess.
SortedMap<String,String>	loadAllIdentifiersAndName(boolean includeNames)	Load all possible identifiers for experiments.
Collection<ExpressionExperiment>	loadAllReferences()	Load references for all experiments.
ExpressionExperiment	loadAndThaw(Long id)	Load an experiment and thaw it as per thaw(ExpressionExperiment).
ExpressionExperiment	loadAndThawLite(Long id)
<T extends Exception> ExpressionExperiment	loadAndThawLiteOrFail(Long id, Function<String,T> exceptionSupplier)
<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	loadAndThawLiterOrFail(Long id, Function<String,T> exceptionSupplier)
ExpressionExperiment	loadAndThawLiteWithRefreshCacheMode(Long id)	Load an experiment without cache and thaw it as per thaw(ExpressionExperiment) with CacheMode.REFRESH.
<T extends Exception> ExpressionExperiment	loadAndThawOrFail(Long id, Function<String,T> exceptionSupplier)	Load an experiment and thaw it as per thawLite(ExpressionExperiment) or fail with the supplied exception and message.
Slice<ExpressionExperimentValueObject>	loadBlacklistedValueObjects(Filters filters, Sort sort, int offset, int limit)
CursorPage<ExpressionExperimentValueObject>	loadBlacklistedValueObjectsByCursor(Filters filters, Sort sort, Cursor cursor, int limit)	Cursor-mode counterpart to loadBlacklistedValueObjects(Filters, Sort, int, int).
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<ExpressionExperimentDao.Identifiers>	loadIdentifiers(Collection<Long> ids)
List<Long>	loadIdsWithCache(Filters filters, Sort sort)
Collection<ExpressionExperiment>	loadLackingFactors()
Collection<ExpressionExperiment>	loadLackingTags()
ExpressionExperiment	loadReference(Long id)
Collection<ExpressionExperiment>	loadReferences(Collection<Long> ids)	Load references for the given experiment IDs.
List<Long>	loadTroubledIds()	Load troubled experiment IDs.
List<ExpressionExperimentValueObject>	loadValueObjectsByIds(List<Long> ids, boolean maintainOrder)	Variant of BaseVoEnabledService.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 SecurableFilteringVoEnabledService.load(Filters, Sort).
Slice<ExpressionExperimentValueObject>	loadValueObjectsWithCache(Filters filters, Sort sort, int offset, int limit)
ExpressionExperiment	loadWithAuditTrail(Long id)	Load an experiment with its audit trail initialized.
ExpressionExperiment	loadWithCharacteristics(Long id)
ExpressionExperiment	loadWithMeanVarianceRelation(Long id)
ExpressionExperiment	loadWithPrimaryPublication(Long id)
ExpressionExperiment	loadWithPrimaryPublicationAndOtherRelevantPublications(Long id)
DesignPreflightReport	previewDesignChange(ExpressionExperiment ee, ExperimentalDesignValueObject proposed)	Predict what would happen if proposed were applied as the experiment's new design via PUT.
DesignPreflightReport	previewDesignChange(ExpressionExperiment ee, ExperimentalDesignValueObject proposed, DesignCommitPlan plan)	Predict what would happen if proposed were applied, including the bindings a DesignCommitPlan defers to a second apply pass.
ExpressionExperiment	reload(ExpressionExperiment ee)
int	removeAllRawDataVectors(ExpressionExperiment ee)
Characteristic	removeAnnotation(ExpressionExperiment ee, Long annotationId)	Remove a single experiment-level tag from ee by characteristic id.
Characteristic	removeAnnotation(ExpressionExperiment ee, Long annotationId, String reason)	As removeAnnotation(ExpressionExperiment, Long), with a caller-supplied reason appended to the audit note.
void	removeCharacteristics(ExpressionExperiment ee, Collection<Characteristic> characteristicsToRemove)
int	removeProcessedDataVectors(ExpressionExperiment ee)	Remove the processed data vectors for the given experiment.
int	removeRawDataVectors(ExpressionExperiment ee, QuantitationType qt)
int	removeRawDataVectors(ExpressionExperiment ee, QuantitationType qt, boolean keepDimension)
int	replaceAllRawDataVectors(ExpressionExperiment ee, Collection<RawExpressionDataVector> vectors)	Used when we are replacing data, such as when converting an experiment from one platform to another.
int	replaceProcessedDataVectors(ExpressionExperiment ee, Collection<ProcessedExpressionDataVector> vectors)	Replace the processed data vectors for the given experiment.
int	replaceRawDataVectors(ExpressionExperiment ee, QuantitationType quantitationType, Collection<RawExpressionDataVector> vectors)
ExpressionExperiment	thaw(ExpressionExperiment expressionExperiment)
ExpressionExperiment	thawBioAssays(ExpressionExperiment expressionExperiment)
ExpressionExperiment	thawLite(ExpressionExperiment expressionExperiment)
ExpressionExperiment	thawLiter(ExpressionExperiment expressionExperiment)
int	updateAnnotations(ExpressionExperiment ee, Collection<Characteristic> desired)	Replace the experiment-level characteristic set on ee with the supplied desired collection (idempotent set semantics).
MeanVarianceRelation	updateMeanVarianceRelation(ExpressionExperiment ee, MeanVarianceRelation mvr)
boolean	updateNameAndDescription(ExpressionExperiment ee, String name, String description)	Update the curator-editable "basics" of ee: its name (title) and/or description.
void	updatePublications(ExpressionExperiment ee, BibliographicReference primaryPublication, Collection<BibliographicReference> otherRelevantPublications)	Replace the publications associated with ee: set (or clear) its primary publication and replace its other-relevant-publication set in one shot (idempotent set semantics).
void	updatePublications(ExpressionExperiment ee, PublicationAssertion primaryPublication, Collection<PublicationAssertion> otherRelevantPublications, Collection<PublicationAssertion> rejectedPublications)	Replace ee's publications and the evidence behind them in one transaction, including the record of which publications have been ruled out.
void	updateQuantitationType(ExpressionExperiment ee, QuantitationType qt, QuantitationType previousPreferredQt)	Update a quantitation type.

Methods inherited from interface BaseReadOnlyService

countAll, getElementClass, loadOrFail, loadOrFail

Methods inherited from interface FilteringService

count, getFilter, getFilter, getFilter, getFilter, getFilter, getFilter, getFilter, getFilterableProperties, getFilterablePropertyAllowedValues, getFilterablePropertyConfigAttributes, getFilterablePropertyDescription, getFilterablePropertyResolvableAllowedValuesLabels, getFilterablePropertyType, getSort, isFilterablePropertyDeprecated, isFilterablePropertyUsingSubquery

Methods inherited from interface FilteringVoEnabledService

loadValueObjectsByCursor

Methods inherited from interface SecurableBaseImmutableService

create, create, findOrCreate, remove, remove

Methods inherited from interface SecurableBaseReadOnlyService

find, findOrFail, load, load, loadAll, loadOrFail, loadOrFail, loadOrFail, loadOrFail, streamAll, streamAll

Methods inherited from interface SecurableBaseService

save, save, update, update

Methods inherited from interface SecurableBaseVoEnabledService

loadAllValueObjects, loadValueObject, loadValueObjectById, loadValueObjects, loadValueObjectsByIds

Methods inherited from interface SecurableFilteringVoEnabledService

load, load, loadIds, loadValueObjects, loadValueObjects

Field Details

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 Details

loadReference

@NonNull
ExpressionExperiment loadReference(Long id)

loadReferences

Collection<ExpressionExperiment> loadReferences(Collection<Long> ids)

Load references for the given experiment IDs.

loadAllReferences

Collection<ExpressionExperiment> loadAllReferences()

Load references for all experiments.

References are pre-filtered for ACLs as per SecurableFilteringVoEnabledService.loadIds(Filters, Sort).

loadWithAuditTrail

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

Load an experiment with its audit trail initialized.

loadTroubledIds

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
List<Long> loadTroubledIds()

Load troubled experiment IDs.

See Also:

• CuratableDao.loadTroubledIds()

loadAllIdentifiersAndName

SortedMap<String,String> loadAllIdentifiersAndName(boolean includeNames)

Load all possible identifiers for experiments.

Parameters:

includeNames - if true, include experiment names as possible identifier

Returns:

a mapping of candidate identifier to experiment name

loadIdentifiers

List<ExpressionExperimentDao.Identifiers> loadIdentifiers(Collection<Long> ids)

See Also:

• ExpressionExperimentReadService.loadIdentifiers(Collection)

reload

ExpressionExperiment reload(ExpressionExperiment ee)

See Also:

• BaseDao.reload(Identifiable)

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"})
void addFactorValues(ExpressionExperiment ee,
 Map<BioMaterial, FactorValue> fvs)

Intended with the case of a continuous factor being added.

getRawDataVectors

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<RawExpressionDataVector> getRawDataVectors(ExpressionExperiment ee,
 QuantitationType qt)

See Also:

• ExpressionExperimentDao.getRawDataVectors(ExpressionExperiment, QuantitationType)

getRawDataVectors

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<RawExpressionDataVector> getRawDataVectors(ExpressionExperiment ee,
 List<BioAssay> samples,
 QuantitationType qt)

See Also:

• ExpressionExperimentDao.getRawDataVectors(ExpressionExperiment, List, QuantitationType)

getPreferredRawDataVectors

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<RawExpressionDataVector> getPreferredRawDataVectors(ExpressionExperiment expressionExperiment)

See Also:

• ExpressionExperimentDao.getPreferredRawDataVectors(ExpressionExperiment)

getMissingValuesVectors

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Map<QuantitationType, Collection<RawExpressionDataVector>> getMissingValuesVectors(ExpressionExperiment ee)

See Also:

• ExpressionExperimentDao.getMissingValuesVectors(ExpressionExperiment)

addRawDataVectors

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
int addRawDataVectors(ExpressionExperiment eeToUpdate,
 QuantitationType quantitationType,
 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:

the number of added vectors

replaceRawDataVectors

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
int replaceRawDataVectors(ExpressionExperiment ee,
 QuantitationType quantitationType,
 Collection<RawExpressionDataVector> vectors)

See Also:

• ExpressionExperimentDao.replaceRawDataVectors(ExpressionExperiment, QuantitationType, Collection)

replaceAllRawDataVectors

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
int replaceAllRawDataVectors(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 number of vectors replaced

removeAllRawDataVectors

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
int removeAllRawDataVectors(ExpressionExperiment ee)

See Also:

• ExpressionExperimentDao.removeAllRawDataVectors(ExpressionExperiment)

removeRawDataVectors

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
int removeRawDataVectors(ExpressionExperiment ee,
 QuantitationType qt)

See Also:

• ExpressionExperimentDao.removeRawDataVectors(ExpressionExperiment, QuantitationType, boolean)

removeRawDataVectors

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
int removeRawDataVectors(ExpressionExperiment ee,
 QuantitationType qt,
 boolean keepDimension)

See Also:

• ExpressionExperimentDao.removeRawDataVectors(ExpressionExperiment, QuantitationType, boolean)

getProcessedDataVectors

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Optional<Collection<ProcessedExpressionDataVector>> getProcessedDataVectors(ExpressionExperiment ee)

Returns:

a collection of processed data vectors for the given experiment and list of assays, or Optional.empty() if there are no processed vectors

See Also:

• ExpressionExperimentDao.getProcessedDataVectors(ExpressionExperiment)

getProcessedDataVectors

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Optional<Collection<ProcessedExpressionDataVector>> getProcessedDataVectors(ExpressionExperiment ee,
 List<BioAssay> assays)

Returns:

a collection of processed data vectors for the given experiment and list of assays, or Optional.empty() if there are no processed vectors

See Also:

• ExpressionExperimentDao.getProcessedDataVectors(ExpressionExperiment, List)

createProcessedDataVectors

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
int createProcessedDataVectors(ExpressionExperiment ee,
 Collection<ProcessedExpressionDataVector> vectors)

Create a new set of processed vectors for an experiment.

You might actually want to use ProcessedExpressionDataVectorService.createProcessedDataVectors(ExpressionExperiment, boolean, boolean) as this method is fairly low-level.

See Also:

• ExpressionExperimentDao.createProcessedDataVectors(ExpressionExperiment, Collection)

replaceProcessedDataVectors

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
int replaceProcessedDataVectors(ExpressionExperiment ee,
 Collection<ProcessedExpressionDataVector> vectors)

Replace the processed data vectors for the given experiment.

You might actually want to use ProcessedExpressionDataVectorService.replaceProcessedDataVectors(ExpressionExperiment, Collection, boolean) (ExpressionExperiment)}. as this method is fairly low-level.

See Also:

• ExpressionExperimentDao.replaceProcessedDataVectors(ExpressionExperiment, Collection)

removeProcessedDataVectors

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
int removeProcessedDataVectors(ExpressionExperiment ee)

Remove the processed data vectors for the given experiment.

You might actually want to use ProcessedExpressionDataVectorService.removeProcessedDataVectors(ExpressionExperiment). as this method is fairly low-level.

See Also:

• ExpressionExperimentDao.removeProcessedDataVectors(ExpressionExperiment)

browse

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
List<ExpressionExperiment> browse(int start,
 int limit)

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)

loadAndThawLiteOrFail

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostAuthorize("returnObject == null or hasPermission(returnObject, 'READ') or hasPermission(returnObject, 'ADMINISTRATION')")
<T extends Exception> ExpressionExperiment loadAndThawLiteOrFail(Long id,
 Function<String,T> exceptionSupplier,
 String message)
                                                          throws T

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

Throws:

T

loadAndThawLiteOrFail

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostAuthorize("returnObject == null or hasPermission(returnObject, 'READ') or hasPermission(returnObject, 'ADMINISTRATION')")
<T extends Exception> ExpressionExperiment loadAndThawLiteOrFail(Long id,
 Function<String,T> exceptionSupplier)
                                                          throws T

Throws:

T

loadAndThawLiterOrFail

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostAuthorize("returnObject == null or hasPermission(returnObject, 'READ') or hasPermission(returnObject, 'ADMINISTRATION')")
<T extends Exception> ExpressionExperiment loadAndThawLiterOrFail(Long id,
 Function<String,T> exceptionSupplier)
                                                           throws T

Throws:

T

loadAndThaw

@Nullable
@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostAuthorize("returnObject == null or hasPermission(returnObject, 'READ') or hasPermission(returnObject, 'ADMINISTRATION')")
ExpressionExperiment loadAndThaw(Long id)

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

loadAndThawLite

@Nullable
@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostAuthorize("returnObject == null or hasPermission(returnObject, 'READ') or hasPermission(returnObject, 'ADMINISTRATION')")
ExpressionExperiment loadAndThawLite(Long id)

loadAndThawLiteWithRefreshCacheMode

@Nullable
@Secured("GROUP_ADMIN")
@PostAuthorize("returnObject == null or hasPermission(returnObject, 'READ') or hasPermission(returnObject, 'ADMINISTRATION')")
ExpressionExperiment loadAndThawLiteWithRefreshCacheMode(Long id)

Load an experiment without cache and thaw it as per thaw(ExpressionExperiment) with CacheMode.REFRESH.

This has the side effect of refreshing the cache with the latest data. Since this can be expensive, only administrators are allowed to do this.

loadAndThawOrFail

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostAuthorize("returnObject == null or hasPermission(returnObject, 'READ') or hasPermission(returnObject, 'ADMINISTRATION')")
<T extends Exception> ExpressionExperiment loadAndThawOrFail(Long id,
 Function<String,T> exceptionSupplier)
                                                      throws T

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

Throws:

T

loadIdsWithCache

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

countWithCache

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

Count the number of experiments that match the given filters.

Parameters:

filters - a set of filters to be applied as per SecurableFilteringVoEnabledService.loadIds(Filters, Sort)

extraIds - a set of extra IDs to be intersected with the IDs retrieved by the filters

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)

loadWithPrimaryPublicationAndOtherRelevantPublications

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

loadWithMeanVarianceRelation

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

findByAccession

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
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")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
Collection<ExpressionExperiment> findByAccession(String accession)

findOneByAccession

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_READ_QUIET"})
ExpressionExperiment findOneByAccession(String accession)

findByBibliographicReference

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
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")
@PostAuthorize("returnObject == null or hasPermission(returnObject, 'READ') or hasPermission(returnObject, 'ADMINISTRATION')")
ExpressionExperiment findByBioAssay(BioAssay ba)

Parameters:

ba - bio material

Returns:

experiment the given bioassay is associated with

findByBioAssay

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostAuthorize("returnObject == null or hasPermission(returnObject, 'READ') or hasPermission(returnObject, 'ADMINISTRATION')")
ExpressionExperiment findByBioAssay(BioAssay ba,
 boolean includeSubSets)

Parameters:

includeSubSets - include assays that belong to subsets of the experiment

findIdByBioAssay

@Nullable
Long findIdByBioAssay(BioAssay ba,
 boolean b)

findByBioMaterial

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
Collection<ExpressionExperiment> findByBioMaterial(BioMaterial bm)

Parameters:

bm - bio material

Returns:

experiment the given biomaterial is associated with

findByBioMaterial

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
Collection<ExpressionExperiment> findByBioMaterial(BioMaterial bm,
 boolean includeSubSets)

Parameters:

includeSubSets - include samples that are associated to assays that belong to subsets of the experiment

findIdsByBioMaterial

Collection<Long> findIdsByBioMaterial(BioMaterial bm,
 boolean includeSubSets)

findByBioMaterials

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
Map<ExpressionExperiment, Collection<BioMaterial>> findByBioMaterials(Collection<BioMaterial> biomaterials)

findByExpressedGene

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
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

@Nullable
@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostAuthorize("returnObject == null or hasPermission(returnObject, 'READ') or hasPermission(returnObject, 'ADMINISTRATION')")
ExpressionExperiment findByDesign(ExperimentalDesign ed)

findIdByDesign

@Nullable
Long findIdByDesign(ExperimentalDesign design)

findByDesignId

@Nullable
@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostAuthorize("returnObject == null or hasPermission(returnObject, 'READ') or hasPermission(returnObject, 'ADMINISTRATION')")
ExpressionExperiment findByDesignId(Long designId)

findByFactor

@Nullable
@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostAuthorize("returnObject == null or hasPermission(returnObject, 'READ') or hasPermission(returnObject, 'ADMINISTRATION')")
ExpressionExperiment findByFactor(ExperimentalFactor factor)

findIdByFactor

@Nullable
Long findIdByFactor(ExperimentalFactor factor)

findByFactors

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
Collection<ExpressionExperiment> findByFactors(Collection<ExperimentalFactor> factors)

findByFactorValue

@Nullable
@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostAuthorize("returnObject == null or hasPermission(returnObject, 'READ') or hasPermission(returnObject, 'ADMINISTRATION')")
ExpressionExperiment findByFactorValue(FactorValue factorValue)

findIdByFactorValue

@Nullable
Long findIdByFactorValue(FactorValue factor)

findByFactorValueId

@Nullable
@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostAuthorize("returnObject == null or hasPermission(returnObject, 'READ') or hasPermission(returnObject, 'ADMINISTRATION')")
ExpressionExperiment findByFactorValueId(Long factorValueId)

findByFactorValues

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
Collection<ExpressionExperiment> findByFactorValues(Collection<FactorValue> factorValues)

findByFactorValueIds

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
Collection<ExpressionExperiment> findByFactorValueIds(Collection<Long> factorValueIds)

findByGene

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
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")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
Collection<ExpressionExperiment> findByName(String name)

findOneByName

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_READ_QUIET"})
ExpressionExperiment findOneByName(String name)

findByQuantitationType

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostAuthorize("returnObject == null or hasPermission(returnObject, 'READ') or hasPermission(returnObject, 'ADMINISTRATION')")
ExpressionExperiment findByQuantitationType(QuantitationType type)

findByShortName

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

findByShortNameWithPrimaryPublication

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

findByShortNameAndThawLite

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

findByTaxon

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
Collection<ExpressionExperiment> findByTaxon(Taxon taxon)

findByUpdatedLimit

@Secured("GROUP_AGENT")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
List<ExpressionExperiment> findByUpdatedLimit(int limit)

findUpdatedAfter

@Secured("GROUP_AGENT")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
Collection<ExpressionExperiment> findUpdatedAfter(Date date)

findByMeanVarianceRelation

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_READ_QUIET"})
ExpressionExperiment findByMeanVarianceRelation(MeanVarianceRelation mvr)

findIdByMeanVarianceRelation

@Nullable
Long findIdByMeanVarianceRelation(MeanVarianceRelation mvr)

existsByShortName

boolean existsByShortName(String datasetShortName)

Check if a dataset with a given short name.

No ACL checks are performed.

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.

getAnnotations

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Set<AnnotationValueObject> getAnnotations(ExpressionExperiment ee)

Retrieve annotations for a given experiment.

The following are included:

• Experiment-level tags
• Experimental design tags
• Sample-level tags

getAnnotations

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Set<AnnotationValueObject> getAnnotations(ExpressionExperiment ee,
 boolean includeFreeText)

Retrieve annotations for a given experiment, optionally including unmapped ones.

See Also:

• ExpressionExperimentReadService.getAnnotations(ExpressionExperiment, boolean)

getAnnotations

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Set<AnnotationValueObject> getAnnotations(ExpressionExperimentSubSet ee)

Retrieve annotations for a given experiment subset.

The following are included:

• Experiment-level tags
• Subset-level tags
• Experimental design tags minus the subset factor
• Sample-level tags for the samples within the subset

getAnnotations

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Set<AnnotationValueObject> getAnnotations(ExpressionExperimentSubSet ee,
 boolean includeFreeText)

Retrieve annotations for a given experiment subset, optionally including unmapped ones.

See Also:

• ExpressionExperimentReadService.getAnnotations(ExpressionExperiment, boolean)

getExperimentalDesignValueObject

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
ExperimentalDesignValueObject getExperimentalDesignValueObject(ExpressionExperiment ee)

Build a full structured representation of an experiment's ExperimentalDesign: factors, factor values (with statements carrying stable database IDs), and per-biomaterial factor-value assignments. Returns null if the experiment has no design attached.

previewDesignChange

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
DesignPreflightReport previewDesignChange(ExpressionExperiment ee,
 ExperimentalDesignValueObject proposed)

Predict what would happen if proposed were applied as the experiment's new design via PUT. Performs both validation (blockers) and impact analysis (deletions, dependent analyses, affected subsets). Never mutates state.

Parameters:

ee - the target experiment

proposed - the candidate design as it would be sent to PUT /datasets/{id}/design

Returns:

a DesignPreflightReport describing the diff and its consequences

previewDesignChange

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
DesignPreflightReport previewDesignChange(ExpressionExperiment ee,
 ExperimentalDesignValueObject proposed,
 @Nullable
 DesignCommitPlan plan)

Predict what would happen if proposed were applied, including the bindings a DesignCommitPlan defers to a second apply pass.

Why the plan is needed to get the count right

A ExperimentalDesignValueObject.BioMaterialFactorValueAssignment carries factor value IDs, so a biomaterial being bound to a factor value the commit CREATES cannot be expressed in proposed at all — the factor value has no ID until the first apply pass makes it. Those bindings live in DesignCommitPlan.getPendingAssignments(). Preflighting without them reports biomaterialsWithChangedAssignments = 0 for a pure create whose bindings do land.

Parameters:

plan - the commit plan whose deferred assignments should be counted, or null when the caller has none — a plain PUT /datasets/{id}/design payload, which can only name factor values that already exist

See Also:

• previewDesignChange(ExpressionExperiment, ExperimentalDesignValueObject)

applyDesignChange

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
DesignApplyOutcome applyDesignChange(ExpressionExperiment ee,
 ExperimentalDesignValueObject proposed)

Apply proposed as the experiment's new ExperimentalDesign.

Performs the same validation as previewDesignChange(ExpressionExperiment, ExperimentalDesignValueObject) and throws IllegalArgumentException when blockers are present; the caller is expected to surface preflight feedback before invoking this method. Statements on kept factor values are replaced wholesale (any statement not echoed in the payload is deleted); factor values and factors not echoed are deleted. Differential expression analyses whose factors or factor values are affected are cascaded.

Idempotent: when the apply-time preflight reports zero factor / factor value / biomaterial / design-metadata changes, the method short-circuits and returns a DesignApplyOutcome with applied=false without emitting an audit event. Repeated PUTs of an already-applied design therefore produce one DesignChangeEvent, not many.

On a real change, emits a single DesignChangeEvent via @AuditedConditional (Phase C declarative-audit pattern).

Parameters:

ee - the target experiment

proposed - the new design

Returns:

a DesignApplyOutcome carrying the rebuilt VO, the applied flag, and the apply-time preflight report.

getEnhancedFilters

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

Perform various transformation to the provided filters to enhance it.

• rewrite clauses over objects and predicates to include second/third, etc... predicates/objects
• 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.

inferredTerms - if non-null, all the terms inferred from those mentioned in the filters are added to the collection

Throws:

TimeoutException

getNumberOfDesignElementsPerSample

Map<BioAssay,Long> getNumberOfDesignElementsPerSample(ExpressionExperiment expressionExperiment)

Obtain the number of design elements for the platform of each bioassay in the given experiment.

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)

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

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,
 boolean includePredicates,
 boolean includeObjects,
 long timeout,
 TimeUnit timeUnit)
                                                                                                         throws TimeoutException

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

includePredicates - include usage frequencies of predicates in the results

includeObjects - include usage frequencies of objects in the results

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

Throws:

TimeoutException

See Also:

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

getArrayDesignsUsed

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

Parameters:

expressionExperiment - experiment

Returns:

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

getArrayDesignsUsedByExperiment

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_COLLECTION_READ"})
Map<ExpressionExperiment, Collection<ArrayDesign>> getArrayDesignsUsedByExperiment(Collection<ExpressionExperiment> expressionExperiments)

Per-experiment map of array designs used: one HQL covers all supplied EEs and the result preserves which platform belongs to which EE.

Use this when N EEs need their platforms inspected as part of one assembly step (e.g. bulk pipeline-status), where calling getArrayDesignsUsed(ExpressionExperiment) once per EE would serialize a query per dataset. EEs with no resolved bio-assays are absent from the map; the caller should default to "no platforms" in that case.

The "ACL_SECURABLE_COLLECTION_READ" guard mirrors the bulk read pattern used by other collection-shaped APIs in this service.

getArrayDesignsUsed

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<ArrayDesign> getArrayDesignsUsed(ExpressionExperiment ee,
 QuantitationType qt)

Obtain a collection of ArrayDesign used by a specific set of vectors.

The type of vectors is inferred.

See Also:

• getArrayDesignsUsed(ExpressionExperiment, QuantitationType, Class)

getArrayDesignsUsed

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<ArrayDesign> getArrayDesignsUsed(ExpressionExperiment ee,
 QuantitationType qt,
 Class<? extends DataVector> vectorType)

Obtain a collection of ArrayDesign used by a specific set of vectors.

getGenesUsedByPreferredVectors

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<Gene> getGenesUsedByPreferredVectors(ExpressionExperiment experimentConstraint)

Retrieve the genes used by the preferred vectors of this experiment.

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 SecurableFilteringVoEnabledService.loadIds(Filters, Sort)

extraIds - a set of extra IDs to be intersected with the IDs retrieved by the filters

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.

Parameters:

filters - a set of filters to be applied as per SecurableFilteringVoEnabledService.loadIds(Filters, Sort)

extraIds - a set of extra IDs to be intersected with the IDs retrieved by the filters

See Also:

• getPerTaxonCount()

getBioAssayDimensionsWithAssays

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

Obtain all the dimensions associated to the given experiment.

Assays are initialized as per Thaws.thawBioAssay(BioAssay).

getBioAssayDimension

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
BioAssayDimension getBioAssayDimension(ExpressionExperiment ee,
 QuantitationType qt,
 Class<? extends BulkExpressionDataVector> dataVectorType)

getBioAssayDimension

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
BioAssayDimension getBioAssayDimension(ExpressionExperiment ee,
 QuantitationType qt)

Obtain the dimension associated to the given quantitation type for the given experiment.

This fails if there happens to be more than one dimension for the given QT.

getProcessedBioAssayDimension

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
BioAssayDimension getProcessedBioAssayDimension(ExpressionExperiment ee)

Obtain the dimension associated to the processed data for the given experiment.

getProcessedBioAssayDimensionsWithAssays

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<BioAssayDimension> getProcessedBioAssayDimensionsWithAssays(ExpressionExperiment ee)

Obtain the dimension associated to the processed data for the given experiment.

Assays are initialized as per Thaws.thawBioAssay(BioAssay).

In some special edge cases, a QuantitationType may have more than one BioAssayDimension. If you cannot handle this, use getProcessedBioAssayDimension(ExpressionExperiment) instead.

getBioAssayDimensionsWithAssays

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<BioAssayDimension> getBioAssayDimensionsWithAssays(ExpressionExperiment ee,
 QuantitationType qt)

Obtain all BioAssayDimensions associated to a particular QuantitationType.

Assays initialized as per Thaws.thawBioAssay(BioAssay)

In some special edge cases, a QuantitationType may have more than one BioAssayDimension.

getBioAssayDimensionById

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
BioAssayDimension getBioAssayDimensionById(ExpressionExperiment ee,
 Long dimensionId,
 Class<? extends BulkExpressionDataVector> dataVectorType)

getBioAssayDimensionById

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
BioAssayDimension getBioAssayDimensionById(ExpressionExperiment ee,
 Long dimensionId)

Find a BioAssayDimension by ID.

This is less efficient than getBioAssayDimensionById(ExpressionExperiment, Long, Class) because all bulk vector types need to be inspected.

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.

getRawDataVectorCount

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

getExperimentsWithOutliers

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
Collection<ExpressionExperiment> getExperimentsWithOutliers()

getLastArrayDesignUpdate

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

getLastArrayDesignUpdate

@Nullable
@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:

counts 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

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Optional<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

getProcessedQuantitationType

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Optional<QuantitationType> getProcessedQuantitationType(ExpressionExperiment ee)

hasProcessedExpressionData

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

Test if the given experiment has processed data vectors.

hasSourceMetadata

boolean hasSourceMetadata(ExpressionExperiment ee)

See Also:

• ExpressionExperimentDao.hasSourceMetadata(ExpressionExperiment)

getSourceMetadata

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
String getSourceMetadata(ExpressionExperiment ee)

See Also:

• ExpressionExperimentDao.getSourceMetadata(ExpressionExperiment)

getQuantitationTypeCount

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

Returns:

counts design element data vectors grouped by quantitation type

getQuantitationTypes

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

Retrieve all the quantitation types used by the given expression experiment.

See Also:

• QuantitationTypeDao.findByExpressionExperiment(ExpressionExperiment)

getQuantitationTypesByVectorType

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Map<Class<? extends DataVector>, Set<QuantitationType>> getQuantitationTypesByVectorType(ExpressionExperiment ee)

getQuantitationTypes

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

Retrieve all the quantitation types used by the given experiment and dimension.

getQuantitationTypes

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<QuantitationType> getQuantitationTypes(ExpressionExperiment expressionExperiment,
 BioAssayDimension dimension,
 Class<? extends BulkExpressionDataVector> dataVectorType)

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")
@PostFilter("hasPermission(filterObject.key, 'READ') or hasPermission(filterObject.key, 'ADMINISTRATION')")
Map<ExpressionExperiment, Collection<AuditEvent>> getSampleRemovalEvents(Collection<ExpressionExperiment> expressionExperiments)

getSubSetsWithBioAssays

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<ExpressionExperimentSubSet> getSubSetsWithBioAssays(ExpressionExperiment expressionExperiment)

Obtain all the subsets for a given dataset.

getSubSetsWithBioAssays

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_COLLECTION_READ"})
Map<ExpressionExperiment, Collection<ExpressionExperimentSubSet>> getSubSetsWithBioAssays(Collection<ExpressionExperiment> expressionExperiments)

Batched variant of getSubSetsWithBioAssays(ExpressionExperiment): obtain subsets for every experiment in the input collection in a single query, keyed by source experiment.

Replaces the for ee : ees -> getSubSetsWithBioAssays(ee) N+1 pattern with one round-trip. Experiments without subsets are present in the result map with an empty collection so callers can iterate without null-checks. ACL_SECURABLE_COLLECTION_READ validates every input experiment is readable; the returned subsets inherit ACL semantics from their source experiment (they are not themselves separately ACL'd).

Parameters:

expressionExperiments - experiments to fetch subsets for; may be empty

Returns:

a map from each input experiment to its subsets (empty collection if none)

getSubSetsWithCharacteristics

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<ExpressionExperimentSubSet> getSubSetsWithCharacteristics(ExpressionExperiment ee)

Obtain all the subsets for a given dataset.

Subsets characteristics are initialized and assays are thawed as per Thaws.thawBioAssay(BioAssay).

getSubSetsByDimension

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Map<BioAssayDimension, Set<ExpressionExperimentSubSet>> getSubSetsByDimension(ExpressionExperiment expressionExperiment)

Obtain all the subsets organized by dimension for a given dataset.

getSubSetsByDimensionWithBioAssays

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Map<BioAssayDimension, Set<ExpressionExperimentSubSet>> getSubSetsByDimensionWithBioAssays(ExpressionExperiment expressionExperiment)

Obtain all the subsets organized by dimension for a given dataset.

Assays are thawed as per Thaws.thawBioAssay(BioAssay).

getSubSets

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

Obtain the subsets for a particular dimension.

getSubSetsWithBioAssays

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

Obtain the subsets for a particular dimension.

Assays are lightly thawed.

getSubSetsByFactorValue

@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Map<ExperimentalFactor, Map<FactorValue, ExpressionExperimentSubSet>> getSubSetsByFactorValue(ExpressionExperiment expressionExperiment,
 BioAssayDimension dimension)

Reconstitute the FV to subset mapping for a given experiment.

This will generally return a single factor that was used for splitting the dataset. However, if there are confounding factors, those will be returned as well.

getSubSetsByFactorValue

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Map<FactorValue, ExpressionExperimentSubSet> getSubSetsByFactorValue(ExpressionExperiment expressionExperiment,
 ExperimentalFactor experimentalFactor,
 BioAssayDimension dimension)

Reconstitute the FV to subset mapping for a given experiment and factor.

getSubSetsByFactorValueWithCharacteristicsAndBioAssays

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Map<FactorValue, ExpressionExperimentSubSet> getSubSetsByFactorValueWithCharacteristicsAndBioAssays(ExpressionExperiment expressionExperiment,
 ExperimentalFactor experimentalFactor,
 BioAssayDimension dimension)

Reconstitute the FV to subset mapping for a given experiment and factor.

Subsets characteristics are initialized and assays are thawed as per Thaws.thawBioAssay(BioAssay).

getSubSetByIdWithCharacteristics

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
ExpressionExperimentSubSet getSubSetByIdWithCharacteristics(ExpressionExperiment ee,
 Long subSetId)

getSubSetByIdWithCharacteristicsAndBioAssays

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
ExpressionExperimentSubSet getSubSetByIdWithCharacteristicsAndBioAssays(ExpressionExperiment ee,
 Long subSetId)

Obtain a particular subset by ID.

Subsets characteristics are initialized and assays are thawed as per Thaws.thawBioAssay(BioAssay).

getTaxa

Map<ExpressionExperiment, Taxon> getTaxa(Collection<ExpressionExperiment> ees)

Return the taxon for each of the given experiments.

getTaxon

@Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Taxon getTaxon(ExpressionExperiment expressionExperiment)

Returns the taxon of the given experiment.

Returns:

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

isSingleCell

boolean isSingleCell(ExpressionExperiment ee)

Indicate if the given experiment is a single-cell experiment.

Gemma does not treat single-cell experiments differently from other experiments, so we need to rely on various aspect of the dataset to determine if it is a single-cell experiment.

isRNASeq

boolean isRNASeq(ExpressionExperiment expressionExperiment)

Parameters:

expressionExperiment - ee

Returns:

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

isTwoChannel

@Deprecated
boolean isTwoChannel(ExpressionExperiment expressionExperiment)

Deprecated.

Two-colour arrays are no longer supported for new data; kept so existing two-colour datasets still load and reprocess.

Test if this experiment was run on a two-color microarray 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)

loadBlacklistedValueObjectsByCursor

@Secured({"GROUP_ADMIN","AFTER_ACL_VALUE_OBJECT_COLLECTION_READ"})
CursorPage<ExpressionExperimentValueObject> loadBlacklistedValueObjectsByCursor(@Nullable
 Filters filters,
 Sort sort,
 @Nullable
 Cursor cursor,
 int limit)

Cursor-mode counterpart to loadBlacklistedValueObjects(Filters, Sort, int, int). Same GROUP_ADMIN gate; the cursor DAO currently forces a single-component +id sort (recce §3.4) until the index audit lands.

See Also:

• ExpressionExperimentDao.loadBlacklistedValueObjectsByCursor(Filters, Sort, Cursor, int)

loadLackingFactors

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
Collection<ExpressionExperiment> loadLackingFactors()

loadLackingTags

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
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 SecurableFilteringVoEnabledService.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 BaseVoEnabledService.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

addCharacteristic

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
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.

removeCharacteristics

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
void removeCharacteristics(ExpressionExperiment ee,
 Collection<Characteristic> characteristicsToRemove)

updateAnnotations

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
int updateAnnotations(ExpressionExperiment ee,
 Collection<Characteristic> desired)

Replace the experiment-level characteristic set on ee with the supplied desired collection (idempotent set semantics).

Operates only on characteristics held directly by the ExpressionExperiment (i.e. its ExperimentTag set). Characteristics on subsets, factor values, and biomaterials are left untouched. The diff is computed by (category, categoryUri, value, valueUri) — characteristics that appear in both the current and desired sets are preserved with their existing identity; new ones are created (evidence code defaulted to IC if not supplied) and dropped ones are removed. A single ManualAnnotationEvent is emitted when the call actually changes the set; if the desired set already matches the current set, no audit event is recorded.

Parameters:

ee - the experiment whose characteristic set is being replaced

desired - the desired characteristic set. Each member must have a non-blank category and value (URIs optional). The collection itself may be empty (to clear all tags).

Returns:

total number of characteristic changes applied (added + removed). Zero means the desired set already matched the current set (no-op, no audit event written). Callers that don't care about the count can safely ignore the value. The non-void return is what lets @AuditedConditional(when = "#result > 0", ...) fire the audit event only on actual change branches — see AUDIT_PHASE_C_RECCE.md candidate #2 and AuditedConditional javadoc.

updatePublications

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
void updatePublications(ExpressionExperiment ee,
 @Nullable
 BibliographicReference primaryPublication,
 Collection<BibliographicReference> otherRelevantPublications)

Replace the publications associated with ee: set (or clear) its primary publication and replace its other-relevant-publication set in one shot (idempotent set semantics).

Mirrors the retired gemma-web ExpressionExperimentController.updatePubMed / removePrimaryPublication pair and the pubmedAssociateToExperiments CLI, which both open-coded setPrimaryPublication(...) + update(ee). The caller resolves PubMed ids to persistent references first (see BibliographicReferenceService.findOrCreateByPubMedId(String)). Evidence-free form of updatePublications(ExpressionExperiment, PublicationAssertion, Collection, Collection): every publication is recorded as asserted by PublicationAssociationSource.CURATOR with no stated basis, which is what reaching this method through an ACL_SECURABLE_EDIT write amounts to. Prefer the four-argument form wherever the caller knows why.

Parameters:

ee - the experiment whose publications are being replaced.

primaryPublication - the desired primary publication, or null to clear it.

otherRelevantPublications - the desired other-relevant-publication set (may be empty). Any reference equal to primaryPublication is ignored so the primary is not duplicated into the other-relevant set.

updatePublications

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
void updatePublications(ExpressionExperiment ee,
 @Nullable
 PublicationAssertion primaryPublication,
 Collection<PublicationAssertion> otherRelevantPublications,
 @Nullable
 Collection<PublicationAssertion> rejectedPublications)

Replace ee's publications and the evidence behind them in one transaction, including the record of which publications have been ruled out.

The links and the assertions describing them are two halves of one record — Gemma 1.32.x shares this database and reads only the links, so the assertions live in their own table — and this is the method that keeps them in step. It writes the links (ExpressionExperiment.getPrimaryPublication() / ExpressionExperiment.getOtherRelevantPublications()) and delegates the assertions to PublicationAssociationService.reconcile(Investigation, PublicationAssertion, Collection, Collection), so neither can be updated without the other.

rejectedPublications is the addition that lets a "not this one, because…" be recorded at all. A rejected publication is not linked, and a lower authority — a nightly GEO refresh, a publication finder — cannot subsequently link it: precedence is enforced by rank at write time, so the ruling holds without anyone maintaining a list of exceptions. Dropping a publication from the accepted sets without naming it here retracts its assertion instead, which records that the link is gone but not why.

Parameters:

ee - the experiment whose publications are being replaced.

primaryPublication - the desired primary publication and its evidence, or null to clear it.

otherRelevantPublications - the desired other-relevant set with evidence (may be empty). Any entry naming the primary's reference is ignored.

rejectedPublications - publications to record as ruled out for this experiment, replacing the standing set — an empty collection clears every rejection. Pass null to leave the standing rejections alone, which is what a caller that does not manage them wants: a rejection is not returned by the plain publications read, so a client that writes back what it read has not seen them and its silence must not delete them. A reference given both here and as accepted is an IllegalArgumentException.

Throws:

PublicationAssociationConflictException - if an accepted publication stands rejected by an authority the asserting source does not outrank.

updateNameAndDescription

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
boolean updateNameAndDescription(ExpressionExperiment ee,
 @Nullable
 String name,
 @Nullable
 String description)

Update the curator-editable "basics" of ee: its name (title) and/or description. A null argument leaves that field untouched (partial update); a non-null argument replaces it. Closes the name/description half of the retired gemma-web updateBasics (short_name has its own path; publications moved to updatePublications(ExpressionExperiment, BibliographicReference, Collection)).

Parameters:

ee - the experiment.

name - the new name, or null to leave it unchanged. Must not be blank if provided.

description - the new description, or null to leave it unchanged.

Returns:

true if any field actually changed (so the caller writes an audit event only on a real change), false if the supplied values already matched.

commitCuration

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT","RUN_AS_AGENT"})
CurationCommitResult commitCuration(ExpressionExperiment ee,
 CurationCommitRequest request,
 boolean dryRun)

Apply an all-or-none curation commit to ee, reconciling the sections carried in request in a single transaction (phase 1: basics + publications). This is the transactional core of the composite PUT /datasets/{id}/curation endpoint — either every section applies or, on any failure, nothing does.

When dryRun is true the change tally is computed without writing anything (backs /curation/preflight). Optimistic concurrency is enforced against CurationCommitRequest.getExpectedLastUpdated(): a stale baseline throws OptimisticLockingFailureException (the web layer maps it to 409). A short-name change without CurationCommitRequest.isShortNameChangeAllowed() throws AccessDeniedException, rolling the whole commit back.

RUN_AS_AGENT is what lets an applied commit refresh this experiment's EXPRESSION_EXPERIMENT2CHARACTERISTIC rows before returning: TableMaintenanceUtil is @Secured("GROUP_AGENT") and a curator holds GROUP_USER, so without the elevation the call fails on authorization, not on timing. RunAsManagerImpl swaps in a token carrying the caller's own authorities plus GROUP_RUN_AS_AGENT for the duration of this invocation, and the role hierarchy escalates that to GROUP_AGENT — the same mechanism UserManager and ExpressionExperimentReportService already use.

What that opens up, stated plainly: for the length of this call every @Secured("GROUP_AGENT") method reachable from the commit becomes callable. It grants no ACL permission (the ACL authorization strategy keys on GROUP_ADMIN, and the hierarchy runs GROUP_ADMIN > GROUP_AGENT, not the reverse), does not change the principal, and ends when the method returns.

Returns:

per-section change counts (identical whether applied or dry-run).

addAnnotation

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
Characteristic addAnnotation(ExpressionExperiment ee,
 Characteristic vc)

Add a single experiment-level tag to ee as part of the per-tag REST write flow.

Distinct from addCharacteristic(ExpressionExperiment, Characteristic) in two ways: (1) emits a TagAddedEvent per call (via @Audited on the facade impl) so the audit trail records one row per added tag; (2) rejects duplicates by (categoryUri, valueUri) with an IllegalArgumentException the REST layer maps to 409 Conflict. addCharacteristic preserves its existing audit-silent / dup-tolerant semantics for legacy gemma-web callers.

Parameters:

ee - the experiment to add the tag to.

vc - the characteristic to add. Must have a non-blank category and value; if the evidence code is null it defaults to GOEvidenceCode.IC.

Returns:

the persistent Characteristic with its assigned id.

Throws:

IllegalArgumentException - if a characteristic with the same (categoryUri, valueUri) already exists on the EE.

addAnnotation

Characteristic addAnnotation(ExpressionExperiment ee,
 Characteristic vc,
 @Nullable
 String reason)

As addAnnotation(ExpressionExperiment, Characteristic), with a caller-supplied reason appended to the audit note after the server's own description.

removeAnnotation

@Nullable
@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
Characteristic removeAnnotation(ExpressionExperiment ee,
 Long annotationId)

Remove a single experiment-level tag from ee by characteristic id. Counterpart to addAnnotation(ExpressionExperiment, Characteristic).

Emits a TagRemovedEvent per call (via @Audited on the facade impl). The REST layer maps the null return to 404 Not Found.

Parameters:

ee - the experiment.

annotationId - the id of the Characteristic to remove.

Returns:

the removed characteristic, or null if no characteristic with that id is currently attached to ee.

removeAnnotation

Characteristic removeAnnotation(ExpressionExperiment ee,
 Long annotationId,
 @Nullable
 String reason)

As removeAnnotation(ExpressionExperiment, Long), with a caller-supplied reason appended to the audit note. A deletion has no surviving annotation to carry evidence, so this is the only place its reason can be recorded.

thaw

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

See Also:

• ExpressionExperimentDao.thaw(ExpressionExperiment)

thawLiter

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

See Also:

• ExpressionExperimentDao.thawLiter(ExpressionExperiment)

thawLite

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

See Also:

• ExpressionExperimentDao.thawLite(ExpressionExperiment)

thawBioAssays

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

See Also:

• ExpressionExperimentReadService.thawBioAssays(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")
@PostFilter("hasPermission(filterObject, 'READ') or hasPermission(filterObject, 'ADMINISTRATION')")
Collection<ExpressionExperiment> getExperimentsLackingPublications(int maxResults)

Parameters:

maxResults - maximum number of rows to return; pass Integer.MAX_VALUE for unbounded (use with care on prod, where this set is in the thousands).

Returns:

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

updateQuantitationType

@Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
void updateQuantitationType(ExpressionExperiment ee,
 QuantitationType qt,
 @Nullable
 QuantitationType previousPreferredQt)

Update a quantitation type.

If the provided QT is preferred (i.e. either single-cell, raw or processed), all other QTs in the experiment for that type of vectors will be set to non-preferred.

Parameters:

previousPreferredQt - if the QuantitationType.getIsPreferred() (or QuantitationType.getIsSingleCellPreferred() for single-cell data) status is changing, this indicates which QT was previously preferred. If null, it is assumed that no QT was previously preferred. This only affects the event added to the audit trail, all other QTs will have their preferred status updated regardless.

See Also:

• QuantitationTypeService.update(QuantitationType)

updateMeanVarianceRelation

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

countBioMaterials

long countBioMaterials(@Nullable
 Filters filters)

See Also:

• ExpressionExperimentDao.countBioMaterials(Filters)