Class ExpressionExperimentServiceImpl

java.lang.Object

ubic.gemma.persistence.service.AbstractService<ExpressionExperiment>

ubic.gemma.persistence.service.AbstractFilteringVoEnabledService<ExpressionExperiment, ExpressionExperimentValueObject>

ubic.gemma.persistence.service.expression.experiment.ExpressionExperimentServiceImpl

All Implemented Interfaces:

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

@Service("expressionExperimentService")
public class ExpressionExperimentServiceImpl
extends AbstractFilteringVoEnabledService<ExpressionExperiment, ExpressionExperimentValueObject>
implements ExpressionExperimentService

Author:

pavlidis, keshav

See Also:

• ExpressionExperimentService

Nested Class Summary

Nested classes/interfaces inherited from interface ExpressionExperimentService

ExpressionExperimentService.CharacteristicWithUsageStatisticsAndOntologyTerm

Field Summary

Fields inherited from class AbstractService

log

Fields inherited from interface ExpressionExperimentService

FREE_TEXT, UNCATEGORIZED

Constructor Summary

Constructors

Constructor	Description
ExpressionExperimentServiceImpl(ExpressionExperimentDao expressionExperimentDao)

Method Summary

Modifier and Type	Method	Description
Characteristic	addAnnotation(ExpressionExperiment ee, Characteristic vc)	Per-tag REST-write counterpart to addCharacteristic(ExpressionExperiment, Characteristic).
Characteristic	addAnnotation(ExpressionExperiment ee, Characteristic vc, String reason)	Reason-carrying overload.
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 ee, 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 shortName)	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 includeSubSets)
Long	findIdByDesign(ExperimentalDesign design)
Long	findIdByFactor(ExperimentalFactor factor)
Long	findIdByFactorValue(FactorValue factorValue)
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 expressionExperiment)	Retrieve annotations for a given experiment.
Set<AnnotationValueObject>	getAnnotations(ExpressionExperiment expressionExperiment, 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()
String	getFilterablePropertyDescription(String property)	Augments the base service description with a note about ontology inference.
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 ee)
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 ExpressionExperimentService.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 ee)	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 ee)	Check if the dataset is either troubled or uses a troubled platform.
boolean	isTwoChannel(ExpressionExperiment expressionExperiment)	Deprecated.
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 ExpressionExperimentService.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 ExpressionExperimentService.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 ExpressionExperimentService.thaw(ExpressionExperiment) with CacheMode.REFRESH.
<T extends Exception> ExpressionExperiment	loadAndThawOrFail(Long id, Function<String,T> exceptionSupplier)	Load an experiment and thaw it as per ExpressionExperimentService.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 ExpressionExperimentService.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)
void	remove(Collection<ExpressionExperiment> entities)
void	remove(ExpressionExperiment ee)	Deletes an experiment and all of its associated objects, including coexpression links.
int	removeAllRawDataVectors(ExpressionExperiment ee)
Characteristic	removeAnnotation(ExpressionExperiment ee, Long annotationId)	Per-tag REST-write counterpart to removeCharacteristics(ExpressionExperiment, Collection).
Characteristic	removeAnnotation(ExpressionExperiment ee, Long annotationId, String reason)	Reason-carrying overload; see addAnnotation(ExpressionExperiment, Characteristic, String).
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> newVectors)	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 qt, 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)	Idempotent set-replace for an EE's direct characteristic set.
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 an EE's primary + other-relevant publications, recording every one as a bare curator assertion.
void	updatePublications(ExpressionExperiment ee, PublicationAssertion primaryPublication, Collection<PublicationAssertion> otherRelevantPublications, Collection<PublicationAssertion> rejectedPublications)	Replace an EE's publications and the evidence behind them.
void	updateQuantitationType(ExpressionExperiment ee, QuantitationType qt, QuantitationType previousPreferredQt)	Update a quantitation type.

Methods inherited from class AbstractFilteringVoEnabledService

count, getFilter, getFilter, getFilter, getFilter, getFilter, getFilter, getFilter, getFilterableProperties, getFilterablePropertyAllowedValues, getFilterablePropertyConfigAttributes, getFilterablePropertyResolvableAllowedValuesLabels, getFilterablePropertyType, getSort, isFilterablePropertyDeprecated, isFilterablePropertyUsingSubquery, load, load, loadAllValueObjects, loadIds, loadValueObject, loadValueObjectById, loadValueObjects, loadValueObjects, loadValueObjects, loadValueObjectsByCursor, loadValueObjectsByIds

Methods inherited from class AbstractService

countAll, create, create, ensureInSession, ensureInSession, find, findOrCreate, findOrFail, getElementClass, load, load, loadAll, loadOrFail, loadOrFail, loadOrFail, loadOrFail, loadOrFail, loadOrFail, save, save, streamAll, streamAll, update, update

Methods inherited from class Object

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

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, getFilterablePropertyResolvableAllowedValuesLabels, getFilterablePropertyType, getSort, isFilterablePropertyDeprecated, isFilterablePropertyUsingSubquery

Methods inherited from interface FilteringVoEnabledService

loadValueObjectsByCursor

Methods inherited from interface SecurableBaseImmutableService

create, create, findOrCreate

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

Constructor Details

ExpressionExperimentServiceImpl

@Autowired
public ExpressionExperimentServiceImpl(ExpressionExperimentDao expressionExperimentDao)

Method Details

loadReference

@NonNull
@Transactional(readOnly=true)
public ExpressionExperiment loadReference(Long id)

Specified by:

loadReference in interface ExpressionExperimentService

loadReferences

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

Description copied from interface: ExpressionExperimentService

Load references for the given experiment IDs.

Specified by:

loadReferences in interface ExpressionExperimentService

loadAllReferences

public Collection<ExpressionExperiment> loadAllReferences()

Description copied from interface: ExpressionExperimentService

Load references for all experiments.

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

Specified by:

loadAllReferences in interface ExpressionExperimentService

loadWithAuditTrail

public ExpressionExperiment loadWithAuditTrail(Long id)

Description copied from interface: ExpressionExperimentService

Load an experiment with its audit trail initialized.

Specified by:

loadWithAuditTrail in interface ExpressionExperimentService

loadTroubledIds

public List<Long> loadTroubledIds()

Description copied from interface: ExpressionExperimentService

Load troubled experiment IDs.

Specified by:

loadTroubledIds in interface ExpressionExperimentService

See Also:

• CuratableDao.loadTroubledIds()

loadAllIdentifiersAndName

public SortedMap<String,String> loadAllIdentifiersAndName(boolean includeNames)

Description copied from interface: ExpressionExperimentService

Load all possible identifiers for experiments.

Specified by:

loadAllIdentifiersAndName in interface ExpressionExperimentService

Parameters:

includeNames - if true, include experiment names as possible identifier

Returns:

a mapping of candidate identifier to experiment name

loadIdentifiers

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

Specified by:

loadIdentifiers in interface ExpressionExperimentService

See Also:

• ExpressionExperimentReadService.loadIdentifiers(Collection)

reload

public ExpressionExperiment reload(ExpressionExperiment ee)

Specified by:

reload in interface ExpressionExperimentService

See Also:

• BaseDao.reload(Identifiable)

addFactor

public ExperimentalFactor addFactor(ExpressionExperiment ee,
 ExperimentalFactor factor)

Specified by:

addFactor in interface ExpressionExperimentService

addFactorValue

public FactorValue addFactorValue(ExpressionExperiment ee,
 FactorValue fv)

Specified by:

addFactorValue in interface ExpressionExperimentService

Parameters:

ee - experiment.

fv - must already have the experimental factor filled in.

addFactorValues

public void addFactorValues(ExpressionExperiment ee,
 Map<BioMaterial, FactorValue> fvs)

Description copied from interface: ExpressionExperimentService

Intended with the case of a continuous factor being added.

Specified by:

addFactorValues in interface ExpressionExperimentService

getRawDataVectors

public Collection<RawExpressionDataVector> getRawDataVectors(ExpressionExperiment ee,
 QuantitationType qt)

Specified by:

getRawDataVectors in interface ExpressionExperimentService

See Also:

• ExpressionExperimentDao.getRawDataVectors(ExpressionExperiment, QuantitationType)

getRawDataVectors

public Collection<RawExpressionDataVector> getRawDataVectors(ExpressionExperiment ee,
 List<BioAssay> samples,
 QuantitationType qt)

Specified by:

getRawDataVectors in interface ExpressionExperimentService

See Also:

• ExpressionExperimentDao.getRawDataVectors(ExpressionExperiment, List, QuantitationType)

getPreferredRawDataVectors

public Collection<RawExpressionDataVector> getPreferredRawDataVectors(ExpressionExperiment expressionExperiment)

Specified by:

getPreferredRawDataVectors in interface ExpressionExperimentService

See Also:

• ExpressionExperimentDao.getPreferredRawDataVectors(ExpressionExperiment)

getMissingValuesVectors

public Map<QuantitationType, Collection<RawExpressionDataVector>> getMissingValuesVectors(ExpressionExperiment ee)

Specified by:

getMissingValuesVectors in interface ExpressionExperimentService

See Also:

• ExpressionExperimentDao.getMissingValuesVectors(ExpressionExperiment)

addRawDataVectors

public int addRawDataVectors(ExpressionExperiment ee,
 QuantitationType quantitationType,
 Collection<RawExpressionDataVector> newVectors)

Description copied from interface: ExpressionExperimentService

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

Specified by:

addRawDataVectors in interface ExpressionExperimentService

Parameters:

ee - experiment to be updated.

newVectors - vectors to be added.

Returns:

the number of added vectors

replaceRawDataVectors

public int replaceRawDataVectors(ExpressionExperiment ee,
 QuantitationType qt,
 Collection<RawExpressionDataVector> vectors)

Specified by:

replaceRawDataVectors in interface ExpressionExperimentService

See Also:

• ExpressionExperimentDao.replaceRawDataVectors(ExpressionExperiment, QuantitationType, Collection)

replaceAllRawDataVectors

public int replaceAllRawDataVectors(ExpressionExperiment ee,
 Collection<RawExpressionDataVector> newVectors)

Description copied from interface: ExpressionExperimentService

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.

Specified by:

replaceAllRawDataVectors in interface ExpressionExperimentService

Parameters:

ee - experiment

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

Returns:

the number of vectors replaced

removeAllRawDataVectors

public int removeAllRawDataVectors(ExpressionExperiment ee)

Specified by:

removeAllRawDataVectors in interface ExpressionExperimentService

See Also:

• ExpressionExperimentDao.removeAllRawDataVectors(ExpressionExperiment)

removeRawDataVectors

public int removeRawDataVectors(ExpressionExperiment ee,
 QuantitationType qt)

Specified by:

removeRawDataVectors in interface ExpressionExperimentService

See Also:

• ExpressionExperimentDao.removeRawDataVectors(ExpressionExperiment, QuantitationType, boolean)

removeRawDataVectors

public int removeRawDataVectors(ExpressionExperiment ee,
 QuantitationType qt,
 boolean keepDimension)

Specified by:

removeRawDataVectors in interface ExpressionExperimentService

See Also:

• ExpressionExperimentDao.removeRawDataVectors(ExpressionExperiment, QuantitationType, boolean)

getProcessedDataVectors

public Optional<Collection<ProcessedExpressionDataVector>> getProcessedDataVectors(ExpressionExperiment ee)

Specified by:

getProcessedDataVectors in interface ExpressionExperimentService

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

public Optional<Collection<ProcessedExpressionDataVector>> getProcessedDataVectors(ExpressionExperiment ee,
 List<BioAssay> assays)

Specified by:

getProcessedDataVectors in interface ExpressionExperimentService

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

public int createProcessedDataVectors(ExpressionExperiment ee,
 Collection<ProcessedExpressionDataVector> vectors)

Description copied from interface: ExpressionExperimentService

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.

Specified by:

createProcessedDataVectors in interface ExpressionExperimentService

See Also:

• ExpressionExperimentDao.createProcessedDataVectors(ExpressionExperiment, Collection)

removeProcessedDataVectors

public int removeProcessedDataVectors(ExpressionExperiment ee)

Description copied from interface: ExpressionExperimentService

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.

Specified by:

removeProcessedDataVectors in interface ExpressionExperimentService

See Also:

• ExpressionExperimentDao.removeProcessedDataVectors(ExpressionExperiment)

replaceProcessedDataVectors

public int replaceProcessedDataVectors(ExpressionExperiment ee,
 Collection<ProcessedExpressionDataVector> vectors)

Description copied from interface: ExpressionExperimentService

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.

Specified by:

replaceProcessedDataVectors in interface ExpressionExperimentService

See Also:

• ExpressionExperimentDao.replaceProcessedDataVectors(ExpressionExperiment, Collection)

browse

public List<ExpressionExperiment> browse(int start,
 int limit)

Specified by:

browse in interface ExpressionExperimentService

filter

public Collection<Long> filter(String searchString)
                        throws SearchException

Description copied from interface: ExpressionExperimentService

returns ids of search results.

Specified by:

filter in interface ExpressionExperimentService

Parameters:

searchString - search string

Returns:

collection of ids or an empty collection.

Throws:

SearchException

filterByTaxon

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

Description copied from interface: ExpressionExperimentService

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

Specified by:

filterByTaxon in interface ExpressionExperimentService

Parameters:

ids - collection to purge.

taxon - taxon to retain.

Returns:

purged IDs.

loadWithPrimaryPublication

public ExpressionExperiment loadWithPrimaryPublication(Long id)

Specified by:

loadWithPrimaryPublication in interface ExpressionExperimentService

loadWithPrimaryPublicationAndOtherRelevantPublications

public ExpressionExperiment loadWithPrimaryPublicationAndOtherRelevantPublications(Long id)

Specified by:

loadWithPrimaryPublicationAndOtherRelevantPublications in interface ExpressionExperimentService

loadWithMeanVarianceRelation

public ExpressionExperiment loadWithMeanVarianceRelation(Long id)

Specified by:

loadWithMeanVarianceRelation in interface ExpressionExperimentService

findByAccession

public Collection<ExpressionExperiment> findByAccession(DatabaseEntry accession)

Specified by:

findByAccession in interface ExpressionExperimentService

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

public Collection<ExpressionExperiment> findByAccession(String accession)

Specified by:

findByAccession in interface ExpressionExperimentService

findOneByAccession

public ExpressionExperiment findOneByAccession(String accession)

Specified by:

findOneByAccession in interface ExpressionExperimentService

findByBibliographicReference

public Collection<ExpressionExperiment> findByBibliographicReference(BibliographicReference bibRef)

Specified by:

findByBibliographicReference in interface ExpressionExperimentService

Parameters:

bibRef - bibliographic reference

Returns:

a collection of EE that have that reference that BibliographicReference

findByBioAssay

public ExpressionExperiment findByBioAssay(BioAssay ba)

Specified by:

findByBioAssay in interface ExpressionExperimentService

Parameters:

ba - bio material

Returns:

experiment the given bioassay is associated with

findByBioAssay

public ExpressionExperiment findByBioAssay(BioAssay ba,
 boolean includeSubSets)

Specified by:

findByBioAssay in interface ExpressionExperimentService

Parameters:

includeSubSets - include assays that belong to subsets of the experiment

findIdByBioAssay

public Long findIdByBioAssay(BioAssay ba,
 boolean includeSubSets)

Specified by:

findIdByBioAssay in interface ExpressionExperimentService

findByBioMaterial

public Collection<ExpressionExperiment> findByBioMaterial(BioMaterial bm)

Specified by:

findByBioMaterial in interface ExpressionExperimentService

Parameters:

bm - bio material

Returns:

experiment the given biomaterial is associated with

findByBioMaterial

public Collection<ExpressionExperiment> findByBioMaterial(BioMaterial bm,
 boolean includeSubSets)

Specified by:

findByBioMaterial in interface ExpressionExperimentService

Parameters:

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

findIdsByBioMaterial

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

Specified by:

findIdsByBioMaterial in interface ExpressionExperimentService

findByBioMaterials

public Map<ExpressionExperiment, Collection<BioMaterial>> findByBioMaterials(Collection<BioMaterial> biomaterials)

Specified by:

findByBioMaterials in interface ExpressionExperimentService

findByExpressedGene

public Collection<ExpressionExperiment> findByExpressedGene(Gene gene,
 double rank)

Specified by:

findByExpressedGene in interface ExpressionExperimentService

Parameters:

gene - gene

rank - rank

Returns:

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

findByDesign

public ExpressionExperiment findByDesign(ExperimentalDesign ed)

Specified by:

findByDesign in interface ExpressionExperimentService

findIdByDesign

public Long findIdByDesign(ExperimentalDesign design)

Specified by:

findIdByDesign in interface ExpressionExperimentService

findByDesignId

public ExpressionExperiment findByDesignId(Long designId)

Specified by:

findByDesignId in interface ExpressionExperimentService

findByFactor

public ExpressionExperiment findByFactor(ExperimentalFactor factor)

Specified by:

findByFactor in interface ExpressionExperimentService

findIdByFactor

public Long findIdByFactor(ExperimentalFactor factor)

Specified by:

findIdByFactor in interface ExpressionExperimentService

findByFactors

public Collection<ExpressionExperiment> findByFactors(Collection<ExperimentalFactor> factors)

Specified by:

findByFactors in interface ExpressionExperimentService

findByFactorValue

public ExpressionExperiment findByFactorValue(FactorValue factorValue)

Specified by:

findByFactorValue in interface ExpressionExperimentService

findIdByFactorValue

public Long findIdByFactorValue(FactorValue factorValue)

Specified by:

findIdByFactorValue in interface ExpressionExperimentService

findByFactorValueId

public ExpressionExperiment findByFactorValueId(Long factorValueId)

Specified by:

findByFactorValueId in interface ExpressionExperimentService

findByFactorValues

public Collection<ExpressionExperiment> findByFactorValues(Collection<FactorValue> factorValues)

Specified by:

findByFactorValues in interface ExpressionExperimentService

findByFactorValueIds

public Collection<ExpressionExperiment> findByFactorValueIds(Collection<Long> factorValueIds)

Specified by:

findByFactorValueIds in interface ExpressionExperimentService

findByGene

public Collection<ExpressionExperiment> findByGene(Gene gene)

Specified by:

findByGene in interface ExpressionExperimentService

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

public Collection<ExpressionExperiment> findByName(String name)

Specified by:

findByName in interface ExpressionExperimentService

findOneByName

public ExpressionExperiment findOneByName(String name)

Specified by:

findOneByName in interface ExpressionExperimentService

findByQuantitationType

public ExpressionExperiment findByQuantitationType(QuantitationType type)

Specified by:

findByQuantitationType in interface ExpressionExperimentService

findByShortName

public ExpressionExperiment findByShortName(String shortName)

Specified by:

findByShortName in interface ExpressionExperimentService

findByShortNameWithPrimaryPublication

public ExpressionExperiment findByShortNameWithPrimaryPublication(String shortName)

Specified by:

findByShortNameWithPrimaryPublication in interface ExpressionExperimentService

findByShortNameAndThawLite

public ExpressionExperiment findByShortNameAndThawLite(String shortName)

Specified by:

findByShortNameAndThawLite in interface ExpressionExperimentService

findByTaxon

public Collection<ExpressionExperiment> findByTaxon(Taxon taxon)

Specified by:

findByTaxon in interface ExpressionExperimentService

findByUpdatedLimit

public List<ExpressionExperiment> findByUpdatedLimit(int limit)

Specified by:

findByUpdatedLimit in interface ExpressionExperimentService

findUpdatedAfter

public Collection<ExpressionExperiment> findUpdatedAfter(Date date)

Specified by:

findUpdatedAfter in interface ExpressionExperimentService

findByMeanVarianceRelation

public ExpressionExperiment findByMeanVarianceRelation(MeanVarianceRelation mvr)

Specified by:

findByMeanVarianceRelation in interface ExpressionExperimentService

findIdByMeanVarianceRelation

public Long findIdByMeanVarianceRelation(MeanVarianceRelation mvr)

Specified by:

findIdByMeanVarianceRelation in interface ExpressionExperimentService

existsByShortName

public boolean existsByShortName(String shortName)

Description copied from interface: ExpressionExperimentService

Check if a dataset with a given short name.

No ACL checks are performed.

Specified by:

existsByShortName in interface ExpressionExperimentService

getAnnotationCountsByIds

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

Specified by:

getAnnotationCountsByIds in interface ExpressionExperimentService

Parameters:

ids - ids

Returns:

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

previewDesignChange

@Transactional(readOnly=true)
public DesignPreflightReport previewDesignChange(ExpressionExperiment ee,
 ExperimentalDesignValueObject proposed)

Description copied from interface: ExpressionExperimentService

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.

Specified by:

previewDesignChange in interface ExpressionExperimentService

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

@Transactional(readOnly=true)
public DesignPreflightReport previewDesignChange(ExpressionExperiment ee,
 ExperimentalDesignValueObject proposed,
 @Nullable
 DesignCommitPlan plan)

Description copied from interface: ExpressionExperimentService

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.

Specified by:

previewDesignChange in interface ExpressionExperimentService

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:

• ExpressionExperimentService.previewDesignChange(ExpressionExperiment, ExperimentalDesignValueObject)

applyDesignChange

@Transactional
@AuditedConditional(value=DesignChangeEvent.class,
                    when="#result.applied",
                    messageSpel="'Design replaced via REST: factors +' + #result.preflightAtApply.summary.factorsToCreate + ' / -' + #result.preflightAtApply.summary.factorsToDelete + ' / ~' + #result.preflightAtApply.summary.factorsToUpdate + ', factor values +' + #result.preflightAtApply.summary.factorValuesToCreate + ' / -' + #result.preflightAtApply.summary.factorValuesToDelete + ' / ~' + #result.preflightAtApply.summary.factorValuesToUpdate + ', biomaterial assignments changed: ' + #result.preflightAtApply.summary.biomaterialsWithChangedAssignments + ', analyses removed: ' + #result.preflightAtApply.summary.differentialExpressionAnalysesToDelete + '.'")
public DesignApplyOutcome applyDesignChange(ExpressionExperiment ee,
 ExperimentalDesignValueObject proposed)

Description copied from interface: ExpressionExperimentService

Apply proposed as the experiment's new ExperimentalDesign.

Performs the same validation as ExpressionExperimentService.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).

Specified by:

applyDesignChange in interface ExpressionExperimentService

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.

getExperimentalDesignValueObject

public ExperimentalDesignValueObject getExperimentalDesignValueObject(ExpressionExperiment ee)

Description copied from interface: ExpressionExperimentService

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.

Specified by:

getExperimentalDesignValueObject in interface ExpressionExperimentService

getAnnotations

public Set<AnnotationValueObject> getAnnotations(ExpressionExperiment expressionExperiment)

Description copied from interface: ExpressionExperimentService

Retrieve annotations for a given experiment.

The following are included:

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

Specified by:

getAnnotations in interface ExpressionExperimentService

getAnnotations

public Set<AnnotationValueObject> getAnnotations(ExpressionExperiment expressionExperiment,
 boolean includeFreeText)

Description copied from interface: ExpressionExperimentService

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

Specified by:

getAnnotations in interface ExpressionExperimentService

See Also:

• ExpressionExperimentReadService.getAnnotations(ExpressionExperiment, boolean)

getAnnotations

public Set<AnnotationValueObject> getAnnotations(ExpressionExperimentSubSet ee)

Description copied from interface: ExpressionExperimentService

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

Specified by:

getAnnotations in interface ExpressionExperimentService

getAnnotations

public Set<AnnotationValueObject> getAnnotations(ExpressionExperimentSubSet ee,
 boolean includeFreeText)

Description copied from interface: ExpressionExperimentService

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

Specified by:

getAnnotations in interface ExpressionExperimentService

See Also:

• ExpressionExperimentReadService.getAnnotations(ExpressionExperiment, boolean)

getEnhancedFilters

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

Description copied from interface: ExpressionExperimentService

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.

Specified by:

getEnhancedFilters in interface ExpressionExperimentService

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

getFilterablePropertyDescription

public String getFilterablePropertyDescription(String property)

Augments the base service description with a note about ontology inference. Remains on the facade because it overrides the AbstractFilteringVoEnabledService hierarchy's contract; pure delegation here would break the inheritance chain.

Specified by:

getFilterablePropertyDescription in interface FilteringService<ExpressionExperiment>

Overrides:

getFilterablePropertyDescription in class AbstractFilteringVoEnabledService<ExpressionExperiment, ExpressionExperimentValueObject>

See Also:

• FilteringDao.getFilterablePropertyDescription(String)

getNumberOfDesignElementsPerSample

public Map<BioAssay,Long> getNumberOfDesignElementsPerSample(ExpressionExperiment expressionExperiment)

Description copied from interface: ExpressionExperimentService

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

Specified by:

getNumberOfDesignElementsPerSample in interface ExpressionExperimentService

loadWithCharacteristics

public ExpressionExperiment loadWithCharacteristics(Long id)

Specified by:

loadWithCharacteristics in interface ExpressionExperimentService

loadAndThawLiteOrFail

public <T extends Exception> ExpressionExperiment loadAndThawLiteOrFail(Long id,
 Function<String,T> exceptionSupplier,
 String message)
                                                                 throws T

Description copied from interface: ExpressionExperimentService

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

Specified by:

loadAndThawLiteOrFail in interface ExpressionExperimentService

Throws:

T

loadAndThawLiteOrFail

public <T extends Exception> ExpressionExperiment loadAndThawLiteOrFail(Long id,
 Function<String,T> exceptionSupplier)
                                                                 throws T

Specified by:

loadAndThawLiteOrFail in interface ExpressionExperimentService

Throws:

T

loadAndThawLiterOrFail

public <T extends Exception> ExpressionExperiment loadAndThawLiterOrFail(Long id,
 Function<String,T> exceptionSupplier)
                                                                  throws T

Specified by:

loadAndThawLiterOrFail in interface ExpressionExperimentService

Throws:

T

loadAndThaw

public ExpressionExperiment loadAndThaw(Long id)

Description copied from interface: ExpressionExperimentService

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

Specified by:

loadAndThaw in interface ExpressionExperimentService

loadAndThawLite

public ExpressionExperiment loadAndThawLite(Long id)

Specified by:

loadAndThawLite in interface ExpressionExperimentService

loadAndThawLiteWithRefreshCacheMode

public ExpressionExperiment loadAndThawLiteWithRefreshCacheMode(Long id)

Description copied from interface: ExpressionExperimentService

Load an experiment without cache and thaw it as per ExpressionExperimentService.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.

Specified by:

loadAndThawLiteWithRefreshCacheMode in interface ExpressionExperimentService

loadAndThawOrFail

public <T extends Exception> ExpressionExperiment loadAndThawOrFail(Long id,
 Function<String,T> exceptionSupplier)
                                                             throws T

Description copied from interface: ExpressionExperimentService

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

Specified by:

loadAndThawOrFail in interface ExpressionExperimentService

Throws:

T

loadIdsWithCache

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

Specified by:

loadIdsWithCache in interface ExpressionExperimentService

countWithCache

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

Description copied from interface: ExpressionExperimentService

Count the number of experiments that match the given filters.

Specified by:

countWithCache in interface ExpressionExperimentService

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

public Slice<ExpressionExperimentValueObject> loadValueObjectsWithCache(@Nullable
 Filters filters,
 @Nullable
 Sort sort,
 int offset,
 int limit)

Specified by:

loadValueObjectsWithCache in interface ExpressionExperimentService

getCategoriesUsageFrequency

public 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)

Description copied from interface: ExpressionExperimentService

Obtain category usage frequency for datasets matching the given filter.

Specified by:

getCategoriesUsageFrequency in interface ExpressionExperimentService

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

public 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

Description copied from interface: ExpressionExperimentService

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.

Specified by:

getAnnotationsUsageFrequency in interface ExpressionExperimentService

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

@Transactional(readOnly=true)
public Collection<ArrayDesign> getArrayDesignsUsed(ExpressionExperiment expressionExperiment)

Specified by:

getArrayDesignsUsed in interface ExpressionExperimentService

Parameters:

expressionExperiment - experiment

Returns:

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

getArrayDesignsUsedByExperiment

@Transactional(readOnly=true)
public Map<ExpressionExperiment, Collection<ArrayDesign>> getArrayDesignsUsedByExperiment(Collection<ExpressionExperiment> expressionExperiments)

Description copied from interface: ExpressionExperimentService

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 ExpressionExperimentService.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.

Specified by:

getArrayDesignsUsedByExperiment in interface ExpressionExperimentService

getArrayDesignsUsed

@Transactional(readOnly=true)
public Collection<ArrayDesign> getArrayDesignsUsed(ExpressionExperiment ee,
 QuantitationType qt)

Description copied from interface: ExpressionExperimentService

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

The type of vectors is inferred.

Specified by:

getArrayDesignsUsed in interface ExpressionExperimentService

See Also:

• ExpressionExperimentService.getArrayDesignsUsed(ExpressionExperiment, QuantitationType, Class)

getArrayDesignsUsed

@Transactional(readOnly=true)
public Collection<ArrayDesign> getArrayDesignsUsed(ExpressionExperiment ee,
 QuantitationType qt,
 Class<? extends DataVector> vectorType)

Description copied from interface: ExpressionExperimentService

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

Specified by:

getArrayDesignsUsed in interface ExpressionExperimentService

getGenesUsedByPreferredVectors

@Transactional(readOnly=true)
public Collection<Gene> getGenesUsedByPreferredVectors(ExpressionExperiment experimentConstraint)

Description copied from interface: ExpressionExperimentService

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

Specified by:

getGenesUsedByPreferredVectors in interface ExpressionExperimentService

getTechnologyTypeUsageFrequency

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

Specified by:

getTechnologyTypeUsageFrequency in interface ExpressionExperimentService

getArrayDesignUsedOrOriginalPlatformUsageFrequency

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

Description copied from interface: ExpressionExperimentService

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

Specified by:

getArrayDesignUsedOrOriginalPlatformUsageFrequency in interface ExpressionExperimentService

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

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

Description copied from interface: ExpressionExperimentService

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

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

Specified by:

getTaxaUsageFrequency in interface ExpressionExperimentService

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:

• ExpressionExperimentService.getPerTaxonCount()

getBioAssayDimensionsWithAssays

@Transactional(readOnly=true)
public Collection<BioAssayDimension> getBioAssayDimensionsWithAssays(ExpressionExperiment expressionExperiment)

Description copied from interface: ExpressionExperimentService

Obtain all the dimensions associated to the given experiment.

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

Specified by:

getBioAssayDimensionsWithAssays in interface ExpressionExperimentService

getBioAssayDimension

@Transactional(readOnly=true)
public BioAssayDimension getBioAssayDimension(ExpressionExperiment ee,
 QuantitationType qt,
 Class<? extends BulkExpressionDataVector> dataVectorType)

Specified by:

getBioAssayDimension in interface ExpressionExperimentService

getBioAssayDimension

@Transactional(readOnly=true)
public BioAssayDimension getBioAssayDimension(ExpressionExperiment ee,
 QuantitationType qt)

Description copied from interface: ExpressionExperimentService

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.

Specified by:

getBioAssayDimension in interface ExpressionExperimentService

getProcessedBioAssayDimension

@Transactional(readOnly=true)
public BioAssayDimension getProcessedBioAssayDimension(ExpressionExperiment ee)

Description copied from interface: ExpressionExperimentService

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

Specified by:

getProcessedBioAssayDimension in interface ExpressionExperimentService

getProcessedBioAssayDimensionsWithAssays

@Transactional(readOnly=true)
public Collection<BioAssayDimension> getProcessedBioAssayDimensionsWithAssays(ExpressionExperiment ee)

Description copied from interface: ExpressionExperimentService

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 ExpressionExperimentService.getProcessedBioAssayDimension(ExpressionExperiment) instead.

Specified by:

getProcessedBioAssayDimensionsWithAssays in interface ExpressionExperimentService

getBioAssayDimensionsWithAssays

@Transactional(readOnly=true)
public Collection<BioAssayDimension> getBioAssayDimensionsWithAssays(ExpressionExperiment ee,
 QuantitationType qt)

Description copied from interface: ExpressionExperimentService

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.

Specified by:

getBioAssayDimensionsWithAssays in interface ExpressionExperimentService

getBioAssayDimensionById

@Transactional(readOnly=true)
public BioAssayDimension getBioAssayDimensionById(ExpressionExperiment ee,
 Long dimensionId,
 Class<? extends BulkExpressionDataVector> dataVectorType)

Specified by:

getBioAssayDimensionById in interface ExpressionExperimentService

getBioAssayDimensionById

@Transactional(readOnly=true)
public BioAssayDimension getBioAssayDimensionById(ExpressionExperiment ee,
 Long dimensionId)

Description copied from interface: ExpressionExperimentService

Find a BioAssayDimension by ID.

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

Specified by:

getBioAssayDimensionById in interface ExpressionExperimentService

getBioMaterialCount

public long getBioMaterialCount(ExpressionExperiment expressionExperiment)

Specified by:

getBioMaterialCount in interface ExpressionExperimentService

Parameters:

expressionExperiment - experiment

Returns:

the amount of biomaterials associated with the given expression experiment.

getRawDataVectorCount

public long getRawDataVectorCount(ExpressionExperiment ee)

Specified by:

getRawDataVectorCount in interface ExpressionExperimentService

getExperimentsWithOutliers

public Collection<ExpressionExperiment> getExperimentsWithOutliers()

Specified by:

getExperimentsWithOutliers in interface ExpressionExperimentService

getLastArrayDesignUpdate

public Map<Long,Date> getLastArrayDesignUpdate(Collection<ExpressionExperiment> expressionExperiments)

Specified by:

getLastArrayDesignUpdate in interface ExpressionExperimentService

getLastArrayDesignUpdate

public Date getLastArrayDesignUpdate(ExpressionExperiment ee)

Specified by:

getLastArrayDesignUpdate in interface ExpressionExperimentService

Parameters:

ee - experiment

Returns:

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

getLastLinkAnalysis

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

Specified by:

getLastLinkAnalysis in interface ExpressionExperimentService

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

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

Specified by:

getLastMissingValueAnalysis in interface ExpressionExperimentService

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

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

Specified by:

getLastProcessedDataUpdate in interface ExpressionExperimentService

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

public Map<Taxon,Long> getPerTaxonCount()

Specified by:

getPerTaxonCount in interface ExpressionExperimentService

Returns:

counts of expression experiments grouped by taxon

getPopulatedFactorCounts

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

Specified by:

getPopulatedFactorCounts in interface ExpressionExperimentService

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

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

Specified by:

getPopulatedFactorCountsExcludeBatch in interface ExpressionExperimentService

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

@Transactional(readOnly=true)
public Optional<QuantitationType> getPreferredQuantitationType(ExpressionExperiment ee)

Description copied from interface: ExpressionExperimentService

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

Specified by:

getPreferredQuantitationType in interface ExpressionExperimentService

Parameters:

ee - experiment

Returns:

quantitation types

getProcessedQuantitationType

@Transactional(readOnly=true)
public Optional<QuantitationType> getProcessedQuantitationType(ExpressionExperiment ee)

Specified by:

getProcessedQuantitationType in interface ExpressionExperimentService

hasProcessedExpressionData

@Transactional(readOnly=true)
public boolean hasProcessedExpressionData(ExpressionExperiment ee)

Description copied from interface: ExpressionExperimentService

Test if the given experiment has processed data vectors.

Specified by:

hasProcessedExpressionData in interface ExpressionExperimentService

hasSourceMetadata

@Transactional(readOnly=true)
public boolean hasSourceMetadata(ExpressionExperiment ee)

Specified by:

hasSourceMetadata in interface ExpressionExperimentService

See Also:

• ExpressionExperimentDao.hasSourceMetadata(ExpressionExperiment)

getSourceMetadata

@Transactional(readOnly=true)
public String getSourceMetadata(ExpressionExperiment ee)

Specified by:

getSourceMetadata in interface ExpressionExperimentService

See Also:

• ExpressionExperimentDao.getSourceMetadata(ExpressionExperiment)

getQuantitationTypeCount

@Transactional(readOnly=true)
public Map<QuantitationType, Long> getQuantitationTypeCount(ExpressionExperiment ee)

Specified by:

getQuantitationTypeCount in interface ExpressionExperimentService

Returns:

counts design element data vectors grouped by quantitation type

getQuantitationTypes

@Transactional(readOnly=true)
public Collection<QuantitationType> getQuantitationTypes(ExpressionExperiment expressionExperiment)

Description copied from interface: ExpressionExperimentService

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

Specified by:

getQuantitationTypes in interface ExpressionExperimentService

See Also:

• QuantitationTypeDao.findByExpressionExperiment(ExpressionExperiment)

getQuantitationTypesByVectorType

@Transactional(readOnly=true)
public Map<Class<? extends DataVector>, Set<QuantitationType>> getQuantitationTypesByVectorType(ExpressionExperiment ee)

Specified by:

getQuantitationTypesByVectorType in interface ExpressionExperimentService

getQuantitationTypes

@Transactional(readOnly=true)
public Collection<QuantitationType> getQuantitationTypes(ExpressionExperiment expressionExperiment,
 BioAssayDimension dimension)

Description copied from interface: ExpressionExperimentService

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

Specified by:

getQuantitationTypes in interface ExpressionExperimentService

getQuantitationTypes

@Transactional(readOnly=true)
public Collection<QuantitationType> getQuantitationTypes(ExpressionExperiment expressionExperiment,
 BioAssayDimension dimension,
 Class<? extends BulkExpressionDataVector> dataVectorType)

Specified by:

getQuantitationTypes in interface ExpressionExperimentService

getQuantitationTypeValueObjects

@Transactional(readOnly=true)
public Collection<QuantitationTypeValueObject> getQuantitationTypeValueObjects(ExpressionExperiment expressionExperiment)

Description copied from interface: ExpressionExperimentService

Load all QuantitationType associated to an expression experiment as VOs.

Specified by:

getQuantitationTypeValueObjects in interface ExpressionExperimentService

See Also:

• ExpressionExperimentService.getQuantitationTypes(ExpressionExperiment)

getSampleRemovalEvents

public Map<ExpressionExperiment, Collection<AuditEvent>> getSampleRemovalEvents(Collection<ExpressionExperiment> expressionExperiments)

Specified by:

getSampleRemovalEvents in interface ExpressionExperimentService

getSubSetsWithBioAssays

public Collection<ExpressionExperimentSubSet> getSubSetsWithBioAssays(ExpressionExperiment expressionExperiment)

Description copied from interface: ExpressionExperimentService

Obtain all the subsets for a given dataset.

Specified by:

getSubSetsWithBioAssays in interface ExpressionExperimentService

getSubSetsWithBioAssays

public Map<ExpressionExperiment, Collection<ExpressionExperimentSubSet>> getSubSetsWithBioAssays(Collection<ExpressionExperiment> expressionExperiments)

Description copied from interface: ExpressionExperimentService

Batched variant of ExpressionExperimentService.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).

Specified by:

getSubSetsWithBioAssays in interface ExpressionExperimentService

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

public Collection<ExpressionExperimentSubSet> getSubSetsWithCharacteristics(ExpressionExperiment ee)

Description copied from interface: ExpressionExperimentService

Obtain all the subsets for a given dataset.

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

Specified by:

getSubSetsWithCharacteristics in interface ExpressionExperimentService

getSubSetsByDimension

public Map<BioAssayDimension, Set<ExpressionExperimentSubSet>> getSubSetsByDimension(ExpressionExperiment expressionExperiment)

Description copied from interface: ExpressionExperimentService

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

Specified by:

getSubSetsByDimension in interface ExpressionExperimentService

getSubSetsByDimensionWithBioAssays

public Map<BioAssayDimension, Set<ExpressionExperimentSubSet>> getSubSetsByDimensionWithBioAssays(ExpressionExperiment expressionExperiment)

Description copied from interface: ExpressionExperimentService

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

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

Specified by:

getSubSetsByDimensionWithBioAssays in interface ExpressionExperimentService

getSubSets

public Collection<ExpressionExperimentSubSet> getSubSets(ExpressionExperiment expressionExperiment,
 BioAssayDimension dimension)

Description copied from interface: ExpressionExperimentService

Obtain the subsets for a particular dimension.

Specified by:

getSubSets in interface ExpressionExperimentService

getSubSetsWithBioAssays

public Collection<ExpressionExperimentSubSet> getSubSetsWithBioAssays(ExpressionExperiment expressionExperiment,
 BioAssayDimension dimension)

Description copied from interface: ExpressionExperimentService

Obtain the subsets for a particular dimension.

Assays are lightly thawed.

Specified by:

getSubSetsWithBioAssays in interface ExpressionExperimentService

getSubSetsByFactorValue

public Map<ExperimentalFactor, Map<FactorValue, ExpressionExperimentSubSet>> getSubSetsByFactorValue(ExpressionExperiment expressionExperiment,
 BioAssayDimension dimension)

Description copied from interface: ExpressionExperimentService

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.

Specified by:

getSubSetsByFactorValue in interface ExpressionExperimentService

getSubSetsByFactorValue

public Map<FactorValue, ExpressionExperimentSubSet> getSubSetsByFactorValue(ExpressionExperiment expressionExperiment,
 ExperimentalFactor experimentalFactor,
 BioAssayDimension dimension)

Description copied from interface: ExpressionExperimentService

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

Specified by:

getSubSetsByFactorValue in interface ExpressionExperimentService

getSubSetsByFactorValueWithCharacteristicsAndBioAssays

public Map<FactorValue, ExpressionExperimentSubSet> getSubSetsByFactorValueWithCharacteristicsAndBioAssays(ExpressionExperiment expressionExperiment,
 ExperimentalFactor experimentalFactor,
 BioAssayDimension dimension)

Description copied from interface: ExpressionExperimentService

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).

Specified by:

getSubSetsByFactorValueWithCharacteristicsAndBioAssays in interface ExpressionExperimentService

getSubSetByIdWithCharacteristics

public ExpressionExperimentSubSet getSubSetByIdWithCharacteristics(ExpressionExperiment ee,
 Long subSetId)

Specified by:

getSubSetByIdWithCharacteristics in interface ExpressionExperimentService

getSubSetByIdWithCharacteristicsAndBioAssays

public ExpressionExperimentSubSet getSubSetByIdWithCharacteristicsAndBioAssays(ExpressionExperiment ee,
 Long subSetId)

Description copied from interface: ExpressionExperimentService

Obtain a particular subset by ID.

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

Specified by:

getSubSetByIdWithCharacteristicsAndBioAssays in interface ExpressionExperimentService

getTaxa

@Transactional(readOnly=true)
public Map<ExpressionExperiment, Taxon> getTaxa(Collection<ExpressionExperiment> ees)

Description copied from interface: ExpressionExperimentService

Return the taxon for each of the given experiments.

Specified by:

getTaxa in interface ExpressionExperimentService

getTaxon

public Taxon getTaxon(ExpressionExperiment ee)

Description copied from interface: ExpressionExperimentService

Returns the taxon of the given experiment.

Specified by:

getTaxon in interface ExpressionExperimentService

Returns:

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

isSingleCell

@Transactional(readOnly=true)
public boolean isSingleCell(ExpressionExperiment ee)

Description copied from interface: ExpressionExperimentService

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.

Specified by:

isSingleCell in interface ExpressionExperimentService

isRNASeq

@Transactional(readOnly=true)
public boolean isRNASeq(ExpressionExperiment expressionExperiment)

Specified by:

isRNASeq in interface ExpressionExperimentService

Parameters:

expressionExperiment - ee

Returns:

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

isTwoChannel

@Deprecated
@Transactional(readOnly=true)
public boolean isTwoChannel(ExpressionExperiment expressionExperiment)

Deprecated.

Description copied from interface: ExpressionExperimentService

Test if this experiment was run on a two-color microarray platform.

Specified by:

isTwoChannel in interface ExpressionExperimentService

isTroubled

@Transactional(readOnly=true)
public boolean isTroubled(ExpressionExperiment ee)

Description copied from interface: ExpressionExperimentService

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

Specified by:

isTroubled in interface ExpressionExperimentService

Parameters:

ee - the expression experiment to be checked for trouble. This method will usually be preferred over checking the curation details of the object directly, as this method also checks all the array designs the given experiment belongs to.

Returns:

true, if the given experiment, or any of its parenting array designs is troubled. False otherwise

loadDetailsValueObjects

public Slice<ExpressionExperimentDetailsValueObject> loadDetailsValueObjects(@Nullable
 Collection<Long> ids,
 @Nullable
 Taxon taxon,
 @Nullable
 Sort sort,
 int offset,
 int limit)

Specified by:

loadDetailsValueObjects in interface ExpressionExperimentService

See Also:

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

loadDetailsValueObjectsWithCache

public Slice<ExpressionExperimentDetailsValueObject> loadDetailsValueObjectsWithCache(Collection<Long> ids,
 @Nullable
 Taxon taxon,
 @Nullable
 Sort sort,
 int offset,
 int limit)

Specified by:

loadDetailsValueObjectsWithCache in interface ExpressionExperimentService

loadDetailsValueObjectsByIds

public List<ExpressionExperimentDetailsValueObject> loadDetailsValueObjectsByIds(Collection<Long> ids)

Specified by:

loadDetailsValueObjectsByIds in interface ExpressionExperimentService

loadDetailsValueObjectsByIdsWithCache

public List<ExpressionExperimentDetailsValueObject> loadDetailsValueObjectsByIdsWithCache(Collection<Long> ids)

Specified by:

loadDetailsValueObjectsByIdsWithCache in interface ExpressionExperimentService

loadBlacklistedValueObjects

public Slice<ExpressionExperimentValueObject> loadBlacklistedValueObjects(@Nullable
 Filters filters,
 @Nullable
 Sort sort,
 int offset,
 int limit)

Specified by:

loadBlacklistedValueObjects in interface ExpressionExperimentService

loadBlacklistedValueObjectsByCursor

public CursorPage<ExpressionExperimentValueObject> loadBlacklistedValueObjectsByCursor(@Nullable
 Filters filters,
 Sort sort,
 @Nullable
 Cursor cursor,
 int limit)

Description copied from interface: ExpressionExperimentService

Cursor-mode counterpart to ExpressionExperimentService.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.

Specified by:

loadBlacklistedValueObjectsByCursor in interface ExpressionExperimentService

See Also:

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

loadLackingFactors

public Collection<ExpressionExperiment> loadLackingFactors()

Specified by:

loadLackingFactors in interface ExpressionExperimentService

loadLackingTags

public Collection<ExpressionExperiment> loadLackingTags()

Specified by:

loadLackingTags in interface ExpressionExperimentService

loadValueObjectsByIdsWithRelationsAndCache

public List<ExpressionExperimentValueObject> loadValueObjectsByIdsWithRelationsAndCache(List<Long> ids)

Description copied from interface: ExpressionExperimentService

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

The order of VOs is preserved.

Specified by:

loadValueObjectsByIdsWithRelationsAndCache in interface ExpressionExperimentService

loadValueObjectsByIds

public List<ExpressionExperimentValueObject> loadValueObjectsByIds(List<Long> ids,
 boolean maintainOrder)

Description copied from interface: ExpressionExperimentService

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

Specified by:

loadValueObjectsByIds in interface ExpressionExperimentService

Parameters:

ids - ids to load

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

Returns:

value objects

addCharacteristic

public void addCharacteristic(ExpressionExperiment ee,
 Characteristic vc)

Description copied from interface: ExpressionExperimentService

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

Specified by:

addCharacteristic in interface ExpressionExperimentService

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

public void removeCharacteristics(ExpressionExperiment ee,
 Collection<Characteristic> characteristicsToRemove)

Specified by:

removeCharacteristics in interface ExpressionExperimentService

updateAnnotations

@Transactional
@AuditedConditional(value=ManualAnnotationEvent.class,
                    when="#result > 0",
                    messageSpel="'Replaced annotations via API (' + #result + ' change(s))'")
public int updateAnnotations(ExpressionExperiment ee,
 Collection<Characteristic> desired)

Idempotent set-replace for an EE's direct characteristic set. See the interface javadoc.

Implementation: diff current vs desired by (category, categoryUri, value, valueUri) using CharacteristicUtils.equals(String, String, String, String); preserved characteristics retain their identity (no churn for unchanged tags), drops go through characteristicService.remove, adds get an IC evidence code by default. Emits a single ManualAnnotationEvent when the desired set differs from the current set.

Specified by:

updateAnnotations in interface ExpressionExperimentService

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

@Transactional
public void updatePublications(ExpressionExperiment ee,
 BibliographicReference primaryPublication,
 Collection<BibliographicReference> otherRelevantPublications)

Replace an EE's primary + other-relevant publications, recording every one as a bare curator assertion. See the interface javadoc.

Specified by:

updatePublications in interface ExpressionExperimentService

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

@Transactional
public void updatePublications(ExpressionExperiment ee,
 @Nullable
 PublicationAssertion primaryPublication,
 Collection<PublicationAssertion> otherRelevantPublications,
 @Nullable
 Collection<PublicationAssertion> rejectedPublications)

Replace an EE's publications and the evidence behind them. See the interface javadoc.

Set-replace: the other-relevant set is cleared and repopulated from otherRelevantPublications (skipping any entry that equals the incoming primary, so the primary never doubles as an other-relevant row), and the primary is set to primaryPublication (or cleared when null). Persisted through the inherited update(ee), which carries the audit event — matching the legacy setPrimaryPublication(...) + update(ee) flow the gemma-web controller and the CLI used.

The assertions are reconciled first, on purpose. It is the step that can refuse — a publication standing rejected by an authority the caller does not outrank throws — and doing it before the links are touched means the refusal happens with the experiment unmodified rather than relying on the transaction to undo a half-applied change.

Specified by:

updatePublications in interface ExpressionExperimentService

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.

updateNameAndDescription

@Transactional
public boolean updateNameAndDescription(ExpressionExperiment ee,
 @Nullable
 String name,
 @Nullable
 String description)

Description copied from interface: ExpressionExperimentService

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 ExpressionExperimentService.updatePublications(ExpressionExperiment, BibliographicReference, Collection)).

Specified by:

updateNameAndDescription in interface ExpressionExperimentService

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

@Transactional
public CurationCommitResult commitCuration(ExpressionExperiment ee,
 CurationCommitRequest request,
 boolean dryRun)

Description copied from interface: ExpressionExperimentService

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.

Specified by:

commitCuration in interface ExpressionExperimentService

Returns:

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

addAnnotation

@Transactional
@Audited(value=TagAddedEvent.class,
         messageSpel="'Added tag ' + #vc.category + ' = ' + #vc.value")
public Characteristic addAnnotation(ExpressionExperiment ee,
 Characteristic vc)

Per-tag REST-write counterpart to addCharacteristic(ExpressionExperiment, Characteristic).

Emits one TagAddedEvent per call via the @Audited aspect; rejects duplicates by (categoryUri, valueUri) so the POST /annotations/datasets/{id}/annotations handler can surface a 409 Conflict. Delegates the actual persistence to ExpressionExperimentWriteService.addCharacteristic(ExpressionExperiment, Characteristic) (which does the IC-evidence-code defaulting and the Hibernate session attach).

Specified by:

addAnnotation in interface ExpressionExperimentService

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.

addAnnotation

@Transactional
@Audited(value=TagAddedEvent.class,
         messageSpel="'Added tag ' + #vc.category + ' = ' + #vc.value + (#reason != null ? ' \u2014 ' + #reason : '')")
public Characteristic addAnnotation(ExpressionExperiment ee,
 Characteristic vc,
 @Nullable
 String reason)

Reason-carrying overload. Separate method rather than a parameter on the one above so that every existing caller and its tests keep the signature they have; the two differ only in the audit note the aspect writes.

🛑 Both are audited and both delegate to the same private body. The delegation is a plain this call, so the inner method is NOT re-advised and one call still writes one event.

Specified by:

addAnnotation in interface ExpressionExperimentService

removeAnnotation

@Transactional
@AuditedConditional(value=TagRemovedEvent.class,
                    when="#result != null",
                    messageSpel="'Removed tag ' + #result.category + ' = ' + #result.value")
@Nullable
public Characteristic removeAnnotation(ExpressionExperiment ee,
 Long annotationId)

Per-tag REST-write counterpart to removeCharacteristics(ExpressionExperiment, Collection). Returns null when the id is not in ee's characteristic set so the REST handler can surface a 404.

Specified by:

removeAnnotation in interface ExpressionExperimentService

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

@Transactional
@AuditedConditional(value=TagRemovedEvent.class,
                    when="#result != null",
                    messageSpel="'Removed tag ' + #result.category + ' = ' + #result.value + (#reason != null ? ' \u2014 ' + #reason : '')")
@Nullable
public Characteristic removeAnnotation(ExpressionExperiment ee,
 Long annotationId,
 @Nullable
 String reason)

Reason-carrying overload; see addAnnotation(ExpressionExperiment, Characteristic, String).

Specified by:

removeAnnotation in interface ExpressionExperimentService

thaw

public ExpressionExperiment thaw(ExpressionExperiment expressionExperiment)

Specified by:

thaw in interface ExpressionExperimentService

See Also:

• ExpressionExperimentDao.thaw(ExpressionExperiment)

thawLite

public ExpressionExperiment thawLite(ExpressionExperiment expressionExperiment)

Specified by:

thawLite in interface ExpressionExperimentService

See Also:

• ExpressionExperimentDao.thawLite(ExpressionExperiment)

thawLiter

public ExpressionExperiment thawLiter(ExpressionExperiment expressionExperiment)

Specified by:

thawLiter in interface ExpressionExperimentService

See Also:

• ExpressionExperimentDao.thawLiter(ExpressionExperiment)

thawBioAssays

public ExpressionExperiment thawBioAssays(ExpressionExperiment expressionExperiment)

Specified by:

thawBioAssays in interface ExpressionExperimentService

See Also:

• ExpressionExperimentReadService.thawBioAssays(ExpressionExperiment)

remove

public void remove(ExpressionExperiment ee)

Deletes an experiment and all of its associated objects, including coexpression links. Some types of associated objects may need to be deleted before this can be run (example: analyses involving multiple experiments; these will not be deleted automatically).

Specified by:

remove in interface BaseImmutableService<ExpressionExperiment>

Specified by:

remove in interface SecurableBaseImmutableService<ExpressionExperiment>

Overrides:

remove in class AbstractService<ExpressionExperiment>

See Also:

• BaseDao.remove(Identifiable)

remove

public void remove(Collection<ExpressionExperiment> entities)

Specified by:

remove in interface BaseImmutableService<ExpressionExperiment>

Specified by:

remove in interface SecurableBaseImmutableService<ExpressionExperiment>

Overrides:

remove in class AbstractService<ExpressionExperiment>

See Also:

• BaseDao.remove(Collection)

isBlackListed

@Transactional(readOnly=true)
public boolean isBlackListed(String geoAccession)

Specified by:

isBlackListed in interface ExpressionExperimentService

isSuitableForDEA

@Transactional(readOnly=true)
public Boolean isSuitableForDEA(ExpressionExperiment ee)

Specified by:

isSuitableForDEA in interface ExpressionExperimentService

Returns:

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

getExperimentsLackingPublications

@Transactional(readOnly=true)
public Collection<ExpressionExperiment> getExperimentsLackingPublications(int maxResults)

Specified by:

getExperimentsLackingPublications in interface ExpressionExperimentService

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

public void updateQuantitationType(ExpressionExperiment ee,
 QuantitationType qt,
 @Nullable
 QuantitationType previousPreferredQt)

Description copied from interface: ExpressionExperimentService

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.

Specified by:

updateQuantitationType in interface ExpressionExperimentService

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

public MeanVarianceRelation updateMeanVarianceRelation(ExpressionExperiment ee,
 MeanVarianceRelation mvr)

Specified by:

updateMeanVarianceRelation in interface ExpressionExperimentService

countBioMaterials

public long countBioMaterials(@Nullable
 Filters filters)

Specified by:

countBioMaterials in interface ExpressionExperimentService

See Also:

• ExpressionExperimentDao.countBioMaterials(Filters)