java.lang.Object
- ubic.gemma.persistence.service.AbstractService<O>
- - 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 ubic.gemma.persistence.service.expression.experiment.ExpressionExperimentService
  ExpressionExperimentService.CharacteristicWithUsageStatisticsAndOntologyTerm

Field Summary
- Fields inherited from class ubic.gemma.persistence.service.AbstractService
  log
- Fields inherited from interface ubic.gemma.persistence.service.expression.experiment.ExpressionExperimentService
  FREE_TEXT, UNCATEGORIZED

Constructor Summary

Constructors
Constructor Description

ExpressionExperimentServiceImpl(ExpressionExperimentDao expressionExperimentDao)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`addCharacteristic(ExpressionExperiment ee, Characteristic vc)`	Will add the 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.
`List<ExpressionExperiment>`	`browse(int start, int limit)`
`long`	`countBioMaterials(Filters filters)`
`long`	`countWithCache(Filters filters, Set<Long> extraIds)`
`int`	`createProcessedDataVectors(ExpressionExperiment ee, Collection<ProcessedExpressionDataVector> vectors)`	Create a new set of processed vectors for an experiment.
`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)`
`Collection<ExpressionExperiment>`	`findByBioMaterial(BioMaterial bm)`
`ExpressionExperiment`	`findByDesign(ExperimentalDesign ed)`
`Collection<ExpressionExperiment>`	`findByExpressedGene(Gene gene, double rank)`
`ExpressionExperiment`	`findByFactor(ExperimentalFactor factor)`
`ExpressionExperiment`	`findByFactorValue(Long factorValueId)`
`ExpressionExperiment`	`findByFactorValue(FactorValue factorValue)`
`Map<ExpressionExperiment,FactorValue>`	`findByFactorValues(Collection<FactorValue> factorValues)`
`Collection<ExpressionExperiment>`	`findByGene(Gene gene)`
`Collection<ExpressionExperiment>`	`findByName(String name)`
`ExpressionExperiment`	`findByQuantitationType(QuantitationType type)`
`ExpressionExperiment`	`findByShortName(String shortName)`
`Collection<ExpressionExperiment>`	`findByTaxon(Taxon taxon)`
`List<ExpressionExperiment>`	`findByUpdatedLimit(int limit)`
`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(ExpressionExperimentSubSet ee)`	Retrieve annotations for a given experiment subset.
`List<ExpressionExperimentService.CharacteristicWithUsageStatisticsAndOntologyTerm>`	`getAnnotationsUsageFrequency(Filters filters, Set<Long> extraIds, String category, Collection<String> excludedCategoryUris, Collection<String> excludedTermUris, int minFrequency, Collection<String> retainedTermUris, int maxResults, long timeout, TimeUnit timeUnit)`	If the term cannot be resolved via `OntologyService.getTerm(String, long, TimeUnit)`, an attempt is done to resolve its category and assign it as its parent.
`Collection<ArrayDesign>`	`getArrayDesignsUsed(BioAssaySet 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<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)`
`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>`	`getBioAssayDimensions(ExpressionExperiment expressionExperiment)`
`Collection<BioAssayDimension>`	`getBioAssayDimensionsFromSubSets(ExpressionExperiment expressionExperiment)`	Retrieve all the dimensions that are linked to the subsets of the given experiment.
`BioAssayDimension`	`getBioAssayDimensionWithAssays(ExpressionExperiment ee, QuantitationType qt)`	Obtain a `BioAssayDimension` with its assays initialized as per `Thaws.thawBioAssay(BioAssay)`.
`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.
`Collection<ExpressionExperiment>`	`getExperimentsLackingPublications()`
`Collection<ExpressionExperiment>`	`getExperimentsWithOutliers()`
`Collection<org.springframework.security.access.ConfigAttribute>`	`getFilterablePropertyConfigAttributes(String property)`	Checks for special properties that are allowed to be referenced on certain objects.
`Filters`	`getFiltersWithInferredAnnotations(Filters f, Collection<OntologyTerm> mentionedTerms, Collection<OntologyTerm> inferredTerms, long timeout, TimeUnit timeUnit)`	The approach here is to construct a collection for each sub-clause in the expression that regroups all the predicates that apply to characteristics as well as their inferred terms.
`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<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.
`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)`
`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.
`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.
`<T extends BioAssaySet> Map<T,Taxon>`	`getTaxa(Collection<T> bioAssaySets)`	Return the taxon for each of the given experiments (or subsets).
`Map<Taxon,Long>`	`getTaxaUsageFrequency(Filters filters, Set<Long> extraIds)`	Calculate the usage frequency of taxa by the datasets matching the provided filters.
`Taxon`	`getTaxon(BioAssaySet bioAssaySet)`	Returns the taxon of the given experiment or subset.
`Map<TechnologyType,Long>`	`getTechnologyTypeUsageFrequency(Filters filters, Set<Long> extraIds)`
`boolean`	`hasProcessedExpressionData(ExpressionExperiment ee)`	Test if the given experiment has processed data vectors.
`boolean`	`isBlackListed(String geoAccession)`
`boolean`	`isRNASeq(ExpressionExperiment expressionExperiment)`
`Boolean`	`isSuitableForDEA(ExpressionExperiment ee)`
`boolean`	`isTroubled(ExpressionExperiment ee)`	Check if the dataset is either troubled or uses a troubled platform.
`SortedMap<String,String>`	`loadAllAccessionAndName()`
`SortedMap<Long,String>`	`loadAllIdAndName()`	Load all ID and name pairs.
`SortedSet<String>`	`loadAllName()`
`Collection<ExpressionExperiment>`	`loadAllReferences()`	Load references for all experiments.
`SortedMap<String,String>`	`loadAllShortNameAndName()`	Load all short name and name pairs.
`ExpressionExperiment`	`loadAndThaw(Long id)`	Load an experiment and thaw it as per `ExpressionExperimentService.thaw(ExpressionExperiment)`.
`<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.
`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, String message)`	Load an experiment and thaw it as per `ExpressionExperimentService.thawLite(ExpressionExperiment)` or fail with the supplied exception and message.
`BioAssaySet`	`loadBioAssaySet(Long id)`	Load a `BioAssaySet` by ID which can be either a `ExpressionExperiment` or a `ExpressionExperimentSubSet`.
`Slice<ExpressionExperimentValueObject>`	`loadBlacklistedValueObjects(Filters filters, Sort sort, int offset, int limit)`
`Slice<ExpressionExperimentDetailsValueObject>`	`loadDetailsValueObjects(Collection<Long> ids, Taxon taxon, Sort sort, int offset, int limit)`
`List<ExpressionExperimentDetailsValueObject>`	`loadDetailsValueObjectsByIds(Collection<Long> ids)`
`List<ExpressionExperimentDetailsValueObject>`	`loadDetailsValueObjectsByIdsWithCache(Collection<Long> ids)`
`Slice<ExpressionExperimentDetailsValueObject>`	`loadDetailsValueObjectsWithCache(Collection<Long> ids, Taxon taxon, Sort sort, int offset, int limit)`
`List<Long>`	`loadIdsWithCache(Filters filters, Sort sort)`
`Collection<ExpressionExperiment>`	`loadLackingFactors()`
`Collection<ExpressionExperiment>`	`loadLackingTags()`
`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`	`reload(ExpressionExperiment ee)`
`void`	`remove(Long id)`	Removes the entity with given ID from the persistent storage.
`void`	`remove(Collection<ExpressionExperiment> entities)`	Removes all the given entities from persistent storage.
`void`	`remove(ExpressionExperiment ee)`	Deletes an experiment and all of its associated objects, including coexpression links.
`int`	`removeAllRawDataVectors(ExpressionExperiment ee)`
`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`	`thawLite(ExpressionExperiment expressionExperiment)`
`ExpressionExperiment`	`thawLiter(ExpressionExperiment expressionExperiment)`
`MeanVarianceRelation`	`updateMeanVarianceRelation(ExpressionExperiment ee, MeanVarianceRelation mvr)`
`void`	`updateQuantitationType(ExpressionExperiment ee, QuantitationType qt)`	Update a quantitation type.

Methods inherited from class ubic.gemma.persistence.service.AbstractService
countAll, create, create, ensureInSession, ensureInSession, find, findOrCreate, findOrFail, getElementClass, load, load, loadAll, loadOrFail, loadOrFail, loadOrFail, loadOrFail, save, save, streamAll, streamAll, update, update

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface ubic.gemma.persistence.service.BaseReadOnlyService
countAll, getElementClass

Methods inherited from interface ubic.gemma.persistence.service.FilteringService
count, getFilter, getFilter, getFilter, getFilter, getFilter, getFilter, getFilterableProperties, getFilterablePropertyAllowedValues, getFilterablePropertyDescription, getFilterablePropertyIsUsingSubquery, getFilterablePropertyResolvableAllowedValuesLabels, getFilterablePropertyType, getIdentifierPropertyName, getSort

Methods inherited from interface ubic.gemma.persistence.service.common.auditAndSecurity.SecurableBaseImmutableService
create, create, findOrCreate

Methods inherited from interface ubic.gemma.persistence.service.common.auditAndSecurity.SecurableBaseReadOnlyService
find, findOrFail, load, load, loadAll, loadOrFail, loadOrFail, loadOrFail, loadOrFail, streamAll, streamAll

Methods inherited from interface ubic.gemma.persistence.service.common.auditAndSecurity.SecurableBaseService
save, save, update, update

Methods inherited from interface ubic.gemma.persistence.service.common.auditAndSecurity.SecurableBaseVoEnabledService
loadAllValueObjects, loadValueObject, loadValueObjectById, loadValueObjects, loadValueObjectsByIds

Methods inherited from interface ubic.gemma.persistence.service.common.auditAndSecurity.SecurableFilteringVoEnabledService
load, load, loadIds, loadValueObjects, loadValueObjects

Constructor Detail

ExpressionExperimentServiceImpl

@Autowired
public ExpressionExperimentServiceImpl(ExpressionExperimentDao expressionExperimentDao)

Method Detail

loadReference

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

Specified by:: loadReference in interface ExpressionExperimentService

loadReferences
```
@Transactional(readOnly=true)
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
```
@Transactional(readOnly=true)
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
```
@Transactional(readOnly=true)
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
```
@Transactional(readOnly=true)
public List<Long> loadTroubledIds()
```
Description copied from interface: ExpressionExperimentService

Load troubled experiment IDs.

Specified by:

loadTroubledIds in interface ExpressionExperimentService

See Also:

CuratableDao.loadTroubledIds()

loadAllIdAndName
```
@Transactional(readOnly=true)
public SortedMap<Long,String> loadAllIdAndName()
```
Description copied from interface: ExpressionExperimentService

Load all ID and name pairs.
Results are filtered by ACLs at the query-level.

Specified by:

loadAllIdAndName in interface ExpressionExperimentService

loadAllShortNameAndName
```
@Transactional(readOnly=true)
public SortedMap<String,String> loadAllShortNameAndName()
```
Description copied from interface: ExpressionExperimentService

Load all short name and name pairs.
Results are filtered by ACLs at the query-level.

Specified by:

loadAllShortNameAndName in interface ExpressionExperimentService

loadAllName
```
@Transactional(readOnly=true)
public SortedSet<String> loadAllName()
```
Specified by:

loadAllName in interface ExpressionExperimentService

loadAllAccessionAndName
```
@Transactional(readOnly=true)
public SortedMap<String,String> loadAllAccessionAndName()
```
Specified by:

loadAllAccessionAndName in interface ExpressionExperimentService

reload

@Transactional(readOnly=true)
public ExpressionExperiment reload(ExpressionExperiment ee)

Specified by:: reload in interface ExpressionExperimentService
See Also:: BaseDao.reload(Object)

addFactor

@Transactional
public ExperimentalFactor addFactor(ExpressionExperiment ee,
                                    ExperimentalFactor factor)

Specified by:: addFactor in interface ExpressionExperimentService

addFactorValue

@Transactional
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
```
@Transactional
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

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

Specified by:: getRawDataVectors in interface ExpressionExperimentService
See Also:: ExpressionExperimentDao.getRawDataVectors(ExpressionExperiment, QuantitationType)

getRawDataVectors

@Transactional(readOnly=true)
public Collection<RawExpressionDataVector> getRawDataVectors(ExpressionExperiment ee,
                                                             List<BioAssay> samples,
                                                             QuantitationType qt)

Specified by:: getRawDataVectors in interface ExpressionExperimentService
See Also:: ExpressionExperimentDao.getRawDataVectors(ExpressionExperiment, List, QuantitationType)

addRawDataVectors
```
@Transactional
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

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

Specified by:: replaceRawDataVectors in interface ExpressionExperimentService
See Also:: ExpressionExperimentDao.replaceRawDataVectors(ExpressionExperiment, QuantitationType, Collection)

replaceAllRawDataVectors
```
@Transactional
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
```
@Transactional
public int removeAllRawDataVectors(ExpressionExperiment ee)
```
Specified by:

removeAllRawDataVectors in interface ExpressionExperimentService

See Also:

ExpressionExperimentDao.removeAllRawDataVectors(ExpressionExperiment)

removeRawDataVectors
```
@Transactional
public int removeRawDataVectors(ExpressionExperiment ee,
                                QuantitationType qt)
```
Specified by:

removeRawDataVectors in interface ExpressionExperimentService

See Also:

ExpressionExperimentDao.removeRawDataVectors(ExpressionExperiment, QuantitationType, boolean)

removeRawDataVectors

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

Specified by:: removeRawDataVectors in interface ExpressionExperimentService
See Also:: ExpressionExperimentDao.removeRawDataVectors(ExpressionExperiment, QuantitationType, boolean)

getProcessedDataVectors
```
@Transactional(readOnly=true)
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

@Transactional(readOnly=true)
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
```
@Transactional
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
```
@Transactional
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
```
@Transactional
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

@Transactional(readOnly=true)
public List<ExpressionExperiment> browse(int start,
                                         int limit)

Specified by:: browse in interface ExpressionExperimentService

filter
```
@Transactional(readOnly=true)
public Collection<Long> filter(String searchString)
                        throws SearchException
```
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
```
@Transactional(readOnly=true)
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

@Transactional(readOnly=true)
public ExpressionExperiment loadWithPrimaryPublication(Long id)

Specified by:: loadWithPrimaryPublication in interface ExpressionExperimentService

loadWithMeanVarianceRelation
```
@Transactional(readOnly=true)
public ExpressionExperiment loadWithMeanVarianceRelation(Long id)
```
Specified by:

loadWithMeanVarianceRelation in interface ExpressionExperimentService

findByAccession
```
@Transactional(readOnly=true)
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.

See Also:

ExpressionExperimentService.findByAccession(DatabaseEntry)

findByAccession

@Transactional(readOnly=true)
public Collection<ExpressionExperiment> findByAccession(String accession)

Specified by:: findByAccession in interface ExpressionExperimentService

findOneByAccession

@Transactional(readOnly=true)
public ExpressionExperiment findOneByAccession(String accession)

Specified by:: findOneByAccession in interface ExpressionExperimentService

findByBibliographicReference
```
@Transactional(readOnly=true)
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

See Also:

ExpressionExperimentService.findByBibliographicReference(BibliographicReference)

findByBioAssay
```
@Transactional(readOnly=true)
public ExpressionExperiment findByBioAssay(BioAssay ba)
```
Specified by:

findByBioAssay in interface ExpressionExperimentService

Parameters:

ba - bio material

Returns:

experiment the given bioassay is associated with

See Also:

ExpressionExperimentService.findByBioAssay(BioAssay)

findByBioMaterial
```
@Transactional(readOnly=true)
public Collection<ExpressionExperiment> findByBioMaterial(BioMaterial bm)
```
Specified by:

findByBioMaterial in interface ExpressionExperimentService

Parameters:

bm - bio material

Returns:

experiment the given biomaterial is associated with

See Also:

ExpressionExperimentService.findByBioMaterial(BioMaterial)

findByExpressedGene
```
@Transactional(readOnly=true)
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

See Also:

ExpressionExperimentService.findByExpressedGene(Gene, double)

findByDesign

@Transactional(readOnly=true)
public ExpressionExperiment findByDesign(ExperimentalDesign ed)

Specified by:: findByDesign in interface ExpressionExperimentService

findByFactor
```
@Transactional(readOnly=true)
public ExpressionExperiment findByFactor(ExperimentalFactor factor)
```
Specified by:

findByFactor in interface ExpressionExperimentService

See Also:

ExpressionExperimentService.findByFactor(ExperimentalFactor)

findByFactorValue
```
@Transactional(readOnly=true)
public ExpressionExperiment findByFactorValue(FactorValue factorValue)
```
Specified by:

findByFactorValue in interface ExpressionExperimentService

See Also:

ExpressionExperimentService.findByFactorValue(FactorValue)

findByFactorValue
```
@Transactional(readOnly=true)
public ExpressionExperiment findByFactorValue(Long factorValueId)
```
Specified by:

findByFactorValue in interface ExpressionExperimentService

See Also:

ExpressionExperimentService.findByFactorValue(FactorValue)

findByFactorValues
```
@Transactional(readOnly=true)
public Map<ExpressionExperiment,FactorValue> findByFactorValues(Collection<FactorValue> factorValues)
```
Specified by:

findByFactorValues in interface ExpressionExperimentService

See Also:

ExpressionExperimentService.findByFactorValues(Collection)

findByGene
```
@Transactional(readOnly=true)
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)

See Also:

ExpressionExperimentService.findByGene(Gene)

findByName
```
@Transactional(readOnly=true)
public Collection<ExpressionExperiment> findByName(String name)
```
Specified by:

findByName in interface ExpressionExperimentService

See Also:

ExpressionExperimentService.findByName(String)

findOneByName

@Transactional(readOnly=true)
public ExpressionExperiment findOneByName(String name)

Specified by:: findOneByName in interface ExpressionExperimentService

findByQuantitationType

@Transactional(readOnly=true)
public ExpressionExperiment findByQuantitationType(QuantitationType type)

Specified by:: findByQuantitationType in interface ExpressionExperimentService

findByShortName
```
@Transactional(readOnly=true)
public ExpressionExperiment findByShortName(String shortName)
```
Specified by:

findByShortName in interface ExpressionExperimentService

See Also:

ExpressionExperimentService.findByShortName(String)

findByTaxon
```
@Transactional(readOnly=true)
public Collection<ExpressionExperiment> findByTaxon(Taxon taxon)
```
Specified by:

findByTaxon in interface ExpressionExperimentService

See Also:

ExpressionExperimentService.findByTaxon(Taxon)

findByUpdatedLimit

@Transactional(readOnly=true)
public List<ExpressionExperiment> findByUpdatedLimit(int limit)

Specified by:: findByUpdatedLimit in interface ExpressionExperimentService

findUpdatedAfter

@Transactional(readOnly=true)
public Collection<ExpressionExperiment> findUpdatedAfter(Date date)

Specified by:: findUpdatedAfter in interface ExpressionExperimentService

getAnnotationCountsByIds
```
@Transactional(readOnly=true)
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.

getAnnotations
```
@Transactional(readOnly=true)
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
```
@Transactional(readOnly=true)
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

getFiltersWithInferredAnnotations
```
public Filters getFiltersWithInferredAnnotations(Filters f,
                                                 @Nullable
                                                 Collection<OntologyTerm> mentionedTerms,
                                                 @Nullable
                                                 Collection<OntologyTerm> inferredTerms,
                                                 long timeout,
                                                 TimeUnit timeUnit)
                                          throws TimeoutException
```
The approach here is to construct a collection for each sub-clause in the expression that regroups all the predicates that apply to characteristics as well as their inferred terms.
The transformation only applies to properties that represent Characteristic objects such as characteristics, allCharacteristics, bioAssays.sample.characteristics and experimentalDesign.experimentalFactors.factorValues.characteristics
Given characteristics.valueUri = a, we construct a collection clause such as characteristics.valueUri in (a, children of a...).
For efficiency, all the terms mentioned in a sub-clause are grouped by ExpressionExperimentServiceImpl.SubClauseKey and aggregated in a single collection. If a term is mentioned multiple times, it is simplified as a single appearance in the collection.
For example, characteristics.termUri = a or characteristics.termUri = b will be transformed into characteristics.termUri in (a, b, children of a and b...).

Specified by:

getFiltersWithInferredAnnotations in interface ExpressionExperimentService

mentionedTerms - if non-null, all the terms explicitly mentioned in the filters are added to the collection.

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

Throws:

TimeoutException

getNumberOfDesignElementsPerSample
```
@Transactional(readOnly=true)
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

@Transactional(readOnly=true)
public ExpressionExperiment loadWithCharacteristics(Long id)

Specified by:: loadWithCharacteristics in interface ExpressionExperimentService

loadBioAssaySet
```
@Transactional(readOnly=true)
public BioAssaySet loadBioAssaySet(Long id)
```
Description copied from interface: ExpressionExperimentService

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

Specified by:

loadBioAssaySet in interface ExpressionExperimentService

loadAndThawLiteOrFail

@Transactional(readOnly=true)
public <T extends Exception> ExpressionExperiment loadAndThawLiteOrFail(Long id,
                                                                        Function<String,T> exceptionSupplier,
                                                                        String message)
                                                                 throws T extends Exception

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 extends Exception

loadAndThaw
```
@Nullable
@Transactional(readOnly=true)
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

loadAndThawLiteWithRefreshCacheMode
```
@Transactional(readOnly=true)
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

@Transactional(readOnly=true)
public <T extends Exception> ExpressionExperiment loadAndThawOrFail(Long id,
                                                                    Function<String,T> exceptionSupplier,
                                                                    String message)
                                                             throws T extends Exception

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 extends Exception

loadIdsWithCache

@Transactional(readOnly=true)
public List<Long> loadIdsWithCache(@Nullable
                                   Filters filters,
                                   @Nullable
                                   Sort sort)

Specified by:: loadIdsWithCache in interface ExpressionExperimentService

countWithCache

@Transactional(readOnly=true)
public long countWithCache(@Nullable
                           Filters filters,
                           @Nullable
                           Set<Long> extraIds)

Specified by:: countWithCache in interface ExpressionExperimentService

loadValueObjectsWithCache

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

Specified by:: loadValueObjectsWithCache in interface ExpressionExperimentService

getCategoriesUsageFrequency

@Transactional(readOnly=true)
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

@Transactional(readOnly=true)
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,
                                                                                                                       long timeout,
                                                                                                                       TimeUnit timeUnit)
                                                                                                                throws TimeoutException

If the term cannot be resolved via OntologyService.getTerm(String, long, TimeUnit), an attempt is done to resolve its category and assign it as its parent. This handles free-text terms that lack a value URI.

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

getArrayDesignsUsed
```
@Transactional(readOnly=true)
public Collection<ArrayDesign> getArrayDesignsUsed(BioAssaySet 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.

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

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

Specified by:: getTechnologyTypeUsageFrequency in interface ExpressionExperimentService

getArrayDesignUsedOrOriginalPlatformUsageFrequency

@Transactional(readOnly=true)
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.load(Filters, Sort, int, int); maxResults - the maximum of results, or unlimited if less than 1

getTaxaUsageFrequency

@Transactional(readOnly=true)
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
See Also:: ExpressionExperimentService.getPerTaxonCount()

getBioAssayDimensions
```
@Transactional(readOnly=true)
public Collection<BioAssayDimension> getBioAssayDimensions(ExpressionExperiment expressionExperiment)
```
Specified by:

getBioAssayDimensions in interface ExpressionExperimentService

Parameters:

expressionExperiment - experiment

Returns:

the BioAssayDimensions for the study.

getBioAssayDimensionsFromSubSets
```
@Transactional(readOnly=true)
public Collection<BioAssayDimension> getBioAssayDimensionsFromSubSets(ExpressionExperiment expressionExperiment)
```
Description copied from interface: ExpressionExperimentService

Retrieve all the dimensions that are linked to the subsets of the given experiment.

Specified by:

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

Specified by:: getBioAssayDimension in interface ExpressionExperimentService

getBioAssayDimensionWithAssays
```
@Transactional(readOnly=true)
public BioAssayDimension getBioAssayDimensionWithAssays(ExpressionExperiment ee,
                                                        QuantitationType qt)
```
Description copied from interface: ExpressionExperimentService

Obtain a BioAssayDimension with its assays initialized as per Thaws.thawBioAssay(BioAssay).

Specified by:

getBioAssayDimensionWithAssays 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
```
@Transactional(readOnly=true)
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

@Transactional(readOnly=true)
public long getRawDataVectorCount(ExpressionExperiment ee)

Specified by:: getRawDataVectorCount in interface ExpressionExperimentService

getExperimentsWithOutliers
```
@Transactional(readOnly=true)
public Collection<ExpressionExperiment> getExperimentsWithOutliers()
```
Specified by:

getExperimentsWithOutliers in interface ExpressionExperimentService

getLastArrayDesignUpdate

@Transactional(readOnly=true)
public Map<Long,Date> getLastArrayDesignUpdate(Collection<ExpressionExperiment> expressionExperiments)

Specified by:: getLastArrayDesignUpdate in interface ExpressionExperimentService

getLastArrayDesignUpdate
```
@Transactional(readOnly=true)
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
```
@Transactional(readOnly=true)
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
```
@Transactional(readOnly=true)
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
```
@Transactional(readOnly=true)
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
```
@Transactional(readOnly=true)
public Map<Taxon,Long> getPerTaxonCount()
```
Specified by:

getPerTaxonCount in interface ExpressionExperimentService

Returns:

counts of expression experiments grouped by taxon

getPopulatedFactorCounts
```
@Transactional(readOnly=true)
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
```
@Transactional(readOnly=true)
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

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

@Transactional(readOnly=true)
public Map<ExpressionExperiment,Collection<AuditEvent>> getSampleRemovalEvents(Collection<ExpressionExperiment> expressionExperiments)

Specified by:: getSampleRemovalEvents in interface ExpressionExperimentService

getSubSetsWithBioAssays
```
@Transactional(readOnly=true)
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

getSubSetsWithCharacteristics
```
@Transactional(readOnly=true)
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
```
@Transactional(readOnly=true)
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
```
@Transactional(readOnly=true)
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

@Transactional(readOnly=true)
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

@Transactional(readOnly=true)
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

@Transactional(readOnly=true)
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

@Transactional(readOnly=true)
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

@Transactional(readOnly=true)
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

@Transactional(readOnly=true)
public ExpressionExperimentSubSet getSubSetByIdWithCharacteristics(ExpressionExperiment ee,
                                                                   Long subSetId)

Specified by:: getSubSetByIdWithCharacteristics in interface ExpressionExperimentService

getSubSetByIdWithCharacteristicsAndBioAssays
```
@Transactional(readOnly=true)
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 <T extends BioAssaySet> Map<T,Taxon> getTaxa(Collection<T> bioAssaySets)
```
Description copied from interface: ExpressionExperimentService

Return the taxon for each of the given experiments (or subsets).

Specified by:

getTaxa in interface ExpressionExperimentService

getTaxon
```
@Transactional(readOnly=true)
public Taxon getTaxon(BioAssaySet bioAssaySet)
```
Description copied from interface: ExpressionExperimentService

Returns the taxon of the given experiment or subset.

Specified by:

getTaxon in interface ExpressionExperimentService

Parameters:

bioAssaySet - bioAssaySet.

Returns:

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

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.

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

@Transactional(readOnly=true)
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

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

Specified by:: loadDetailsValueObjectsWithCache in interface ExpressionExperimentService

loadDetailsValueObjectsByIds

@Transactional(readOnly=true)
public List<ExpressionExperimentDetailsValueObject> loadDetailsValueObjectsByIds(Collection<Long> ids)

Specified by:: loadDetailsValueObjectsByIds in interface ExpressionExperimentService

loadDetailsValueObjectsByIdsWithCache

@Transactional(readOnly=true)
public List<ExpressionExperimentDetailsValueObject> loadDetailsValueObjectsByIdsWithCache(Collection<Long> ids)

Specified by:: loadDetailsValueObjectsByIdsWithCache in interface ExpressionExperimentService

loadBlacklistedValueObjects

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

Specified by:: loadBlacklistedValueObjects in interface ExpressionExperimentService

loadLackingFactors

@Transactional(readOnly=true)
public Collection<ExpressionExperiment> loadLackingFactors()

Specified by:: loadLackingFactors in interface ExpressionExperimentService

loadLackingTags

@Transactional(readOnly=true)
public Collection<ExpressionExperiment> loadLackingTags()

Specified by:: loadLackingTags in interface ExpressionExperimentService

loadValueObjectsByIdsWithRelationsAndCache
```
@Transactional(readOnly=true)
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
```
@Transactional(readOnly=true)
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
```
@Transactional
public void addCharacteristic(ExpressionExperiment ee,
                              Characteristic vc)
```
Will add the 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.

thaw
```
@Transactional(readOnly=true)
public ExpressionExperiment thaw(ExpressionExperiment expressionExperiment)
```
Specified by:

thaw in interface ExpressionExperimentService

See Also:

ExpressionExperimentDao.thaw(ExpressionExperiment)

thawLite
```
@Transactional(readOnly=true)
public ExpressionExperiment thawLite(ExpressionExperiment expressionExperiment)
```
Specified by:

thawLite in interface ExpressionExperimentService

See Also:

ExpressionExperimentDao.thawLite(ExpressionExperiment)

thawLiter
```
@Transactional(readOnly=true)
public ExpressionExperiment thawLiter(ExpressionExperiment expressionExperiment)
```
Specified by:

thawLiter in interface ExpressionExperimentService

See Also:

ExpressionExperimentDao.thawLiter(ExpressionExperiment)

remove
```
@Transactional
public void remove(Long id)
```
Description copied from interface: BaseImmutableService

Removes the entity with given ID from the persistent storage.

Specified by:

remove in interface BaseImmutableService<ExpressionExperiment>

Specified by:

remove in interface SecurableBaseImmutableService<ExpressionExperiment>

Overrides:

remove in class AbstractService<ExpressionExperiment>

Parameters:

id - the ID of entity to be removed.

remove
```
@Transactional
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>

Parameters:

ee - the entity to be removed.

remove
```
@Transactional
public void remove(Collection<ExpressionExperiment> entities)
```
Description copied from interface: BaseImmutableService

Removes all the given entities from persistent storage.

Specified by:

remove in interface BaseImmutableService<ExpressionExperiment>

Specified by:

remove in interface SecurableBaseImmutableService<ExpressionExperiment>

Overrides:

remove in class AbstractService<ExpressionExperiment>

Parameters:

entities - the entities to be removed.

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()
```
Specified by:

getExperimentsLackingPublications in interface ExpressionExperimentService

Returns:

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

updateQuantitationType
```
@Transactional
public void updateQuantitationType(ExpressionExperiment ee,
                                   QuantitationType qt)
```
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

See Also:

QuantitationTypeService.update(QuantitationType)

updateMeanVarianceRelation

@Transactional
public MeanVarianceRelation updateMeanVarianceRelation(ExpressionExperiment ee,
                                                       MeanVarianceRelation mvr)

Specified by:: updateMeanVarianceRelation in interface ExpressionExperimentService

countBioMaterials

@Transactional(readOnly=true)
public long countBioMaterials(@Nullable
                              Filters filters)

Specified by:: countBioMaterials in interface ExpressionExperimentService
See Also:: ExpressionExperimentDao.countBioMaterials(Filters)

getFilterablePropertyConfigAttributes
```
public Collection<org.springframework.security.access.ConfigAttribute> getFilterablePropertyConfigAttributes(String property)
```
Checks for special properties that are allowed to be referenced on certain objects. E.g. characteristics on EEs. Obtain the Spring Security config attributes for a given property.

Specified by:

getFilterablePropertyConfigAttributes in interface FilteringService<ExpressionExperiment>

Overrides:

getFilterablePropertyConfigAttributes in class AbstractFilteringVoEnabledService<ExpressionExperiment,ExpressionExperimentValueObject>

Returns:

the config attributes, or null if no security check should be performed

Class ExpressionExperimentServiceImpl

Nested Class Summary

Nested classes/interfaces inherited from interface ubic.gemma.persistence.service.expression.experiment.ExpressionExperimentService

Field Summary

Fields inherited from class ubic.gemma.persistence.service.AbstractService

Fields inherited from interface ubic.gemma.persistence.service.expression.experiment.ExpressionExperimentService

Constructor Summary

Method Summary

Methods inherited from class ubic.gemma.persistence.service.AbstractFilteringVoEnabledService

Methods inherited from class ubic.gemma.persistence.service.AbstractService

Methods inherited from class java.lang.Object

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

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

Methods inherited from interface ubic.gemma.persistence.service.common.auditAndSecurity.SecurableBaseImmutableService

Methods inherited from interface ubic.gemma.persistence.service.common.auditAndSecurity.SecurableBaseReadOnlyService

Methods inherited from interface ubic.gemma.persistence.service.common.auditAndSecurity.SecurableBaseService

Methods inherited from interface ubic.gemma.persistence.service.common.auditAndSecurity.SecurableBaseVoEnabledService

Methods inherited from interface ubic.gemma.persistence.service.common.auditAndSecurity.SecurableFilteringVoEnabledService

Constructor Detail

ExpressionExperimentServiceImpl

Method Detail

loadReference

loadReferences

loadAllReferences

loadWithAuditTrail

loadTroubledIds

loadAllIdAndName

loadAllShortNameAndName

loadAllName

loadAllAccessionAndName

reload

addFactor

addFactorValue

addFactorValues

getRawDataVectors

getRawDataVectors

addRawDataVectors

replaceRawDataVectors

replaceAllRawDataVectors

removeAllRawDataVectors

removeRawDataVectors

removeRawDataVectors

getProcessedDataVectors

getProcessedDataVectors

createProcessedDataVectors

removeProcessedDataVectors

replaceProcessedDataVectors

browse

filter

filterByTaxon

loadWithPrimaryPublication

loadWithMeanVarianceRelation

findByAccession

findByAccession

findOneByAccession

findByBibliographicReference

findByBioAssay

findByBioMaterial

findByExpressedGene

findByDesign

findByFactor

findByFactorValue

findByFactorValue

findByFactorValues

findByGene

findByName

findOneByName

findByQuantitationType

findByShortName

findByTaxon

findByUpdatedLimit

findUpdatedAfter

getAnnotationCountsByIds

getAnnotations

getAnnotations

getFiltersWithInferredAnnotations

getNumberOfDesignElementsPerSample

loadWithCharacteristics

loadBioAssaySet

loadAndThawLiteOrFail