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

Interface ExpressionExperimentService

    • Method Detail

      • addFactorValue

        @Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
FactorValue addFactorValue​(ExpressionExperiment ee,
                           FactorValue fv)
        Parameters:
        ee - experiment.
        fv - must already have the experimental factor filled in.

      • addRawVectors

        @Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
ExpressionExperiment addRawVectors​(ExpressionExperiment eeToUpdate,
                                   Collection<RawExpressionDataVector> newVectors)
        Used when we want to add data for a quantitation type. Does not remove any existing vectors.
        Parameters:
        eeToUpdate - experiment to be updated.
        newVectors - vectors to be added.
        Returns:
        updated experiment.

      • browse

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

      • filterByTaxon

        Collection<Long> filterByTaxon​(Collection<Long> ids,
                               Taxon taxon)
        Remove IDs of Experiments that are not from the given taxon.
        Parameters:
        ids - collection to purge.
        taxon - taxon to retain.
        Returns:
        purged IDs.

      • loadWithPrimaryPublication

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

      • loadWithMeanVarianceRelation

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

      • findByAccession

        @Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_COLLECTION_READ"})
Collection<ExpressionExperiment> findByAccession​(DatabaseEntry accession)
        Parameters:
        accession - accession
        Returns:
        Experiments which have the given accession. There can be more than one, because one GEO accession can result in multiple experiments in Gemma.

      • findByBibliographicReference

        @Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_COLLECTION_READ"})
Collection<ExpressionExperiment> findByBibliographicReference​(BibliographicReference bibRef)
        Parameters:
        bibRef - bibliographic reference
        Returns:
        a collection of EE that have that reference that BibliographicReference

      • findByBioAssay

        @Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_READ"})
ExpressionExperiment findByBioAssay​(BioAssay ba)
        Parameters:
        ba - bio material
        Returns:
        experiment the given bioassay is associated with

      • findByBioMaterial

        @Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_READ"})
ExpressionExperiment findByBioMaterial​(BioMaterial bm)
        Parameters:
        bm - bio material
        Returns:
        experiment the given biomaterial is associated with

      • findByExpressedGene

        @Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_COLLECTION_READ"})
Collection<ExpressionExperiment> findByExpressedGene​(Gene gene,
                                                     double rank)
        Parameters:
        gene - gene
        rank - rank
        Returns:
        a collection of expression experiment ids that express the given gene above the given expression level

      • findByFactorValue

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

      • findByGene

        @Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_COLLECTION_READ"})
Collection<ExpressionExperiment> findByGene​(Gene gene)
        Parameters:
        gene - gene
        Returns:
        a collection of expression experiments that have an AD that detects the given Gene (ie a probe on the AD hybridizes to the given Gene)

      • findByUpdatedLimit

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

      • getAnnotationCountsByIds

        Map<Long,​Long> getAnnotationCountsByIds​(Collection<Long> ids)
        Parameters:
        ids - ids
        Returns:
        the map of ids to number of terms associated with each expression experiment.

      • getAnnotationsById

        Set<AnnotationValueObject> getAnnotationsById​(Long eeId)
        Parameters:
        eeId - experiment id.
        Returns:
        the terms associated this expression experiment.

      • getFiltersWithInferredAnnotations

        Filters getFiltersWithInferredAnnotations​(Filters f,
                                          @Nullable
                                          Collection<OntologyTerm> mentionedTerms,
                                          @Nullable
                                          Collection<OntologyTerm> inferredTerms,
                                          long timeout,
                                          TimeUnit timeUnit)
                                   throws TimeoutException
        Apply ontological inference to augment a filter with additional terms.
        Parameters:
        mentionedTerms - if non-null, all the terms explicitly mentioned in the filters are added to the collection.
        inferredTerms - if non-null, all the terms inferred from those mentioned in the filters are added to the collection
        Throws:
        TimeoutException

      • getCategoriesUsageFrequency

        Map<Characteristic,​Long> getCategoriesUsageFrequency​(@Nullable
                                                           Filters filters,
                                                           @Nullable
                                                           Set<Long> extraIds,
                                                           @Nullable
                                                           Collection<String> excludedCategoryUris,
                                                           @Nullable
                                                           Collection<String> excludedTermUris,
                                                           @Nullable
                                                           Collection<String> retainedTermUris,
                                                           int maxResults)
        Obtain category usage frequency for datasets matching the given filter.
        Parameters:
        filters - filters restricting the terms to a given set of datasets
        excludedCategoryUris - ensure that the given category URIs are excluded
        excludedTermUris - ensure that the given term URIs and their sub-terms (as per subClassOf relation) are excluded; this requires relevant ontologies to be loaded in OntologyService.
        retainedTermUris - ensure that the given terms are retained (overrides any exclusion from minFrequency and excludedTermUris)
        maxResults - maximum number of results to return

      • getArrayDesignsUsed

        @Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<ArrayDesign> getArrayDesignsUsed​(BioAssaySet expressionExperiment)
        Parameters:
        expressionExperiment - experiment
        Returns:
        a collection of ArrayDesigns referenced by any of the BioAssays that make up the given ExpressionExperiment.

      • getBatchConfound

        @Nullable
String getBatchConfound​(ExpressionExperiment ee)
        Checks the experiment for a batch confound.
        Parameters:
        ee - the experiment to check.
        Returns:
        a string describing the batch confound, or null if there was no batch confound.[FIXME: String return value is unsafe]

      • getBatchEffectDetails

        BatchEffectDetails getBatchEffectDetails​(ExpressionExperiment ee)
        Obtain the full batch effect details of a given experiment.
        Parameters:
        ee - experiment
        Returns:
        details for the principal component most associated with batches (even if it isn't "significant"). Note that we don't look at every component, just the first few.

      • getBatchEffectStatistics

        @Nullable
String getBatchEffectStatistics​(ExpressionExperiment ee)
        Obtain a string describing the summary statistics of a batch effect is present in the given experiment.
        Returns:
        summary statistics or null if there is no batch effect

      • getBioAssayDimensions

        @Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<BioAssayDimension> getBioAssayDimensions​(ExpressionExperiment expressionExperiment)
        Parameters:
        expressionExperiment - experiment
        Returns:
        the BioAssayDimensions for the study.

      • getBioMaterialCount

        @Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
long getBioMaterialCount​(ExpressionExperiment expressionExperiment)
        Parameters:
        expressionExperiment - experiment
        Returns:
        the amount of biomaterials associated with the given expression experiment.

      • getDesignElementDataVectorCount

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

      • getExperimentsWithOutliers

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

      • getLastArrayDesignUpdate

        @Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Date getLastArrayDesignUpdate​(ExpressionExperiment expressionExperiment)
        Parameters:
        expressionExperiment - experiment
        Returns:
        the date of the last time any of the array designs associated with this experiment were updated.

      • getLastLinkAnalysis

        Map<Long,​AuditEvent> getLastLinkAnalysis​(Collection<Long> ids)
        Parameters:
        ids - ids
        Returns:
        AuditEvents of the latest link analyses for the specified expression experiment ids. This returns a map of id -> AuditEvent. If the events do not exist, the map entry will point to null.

      • getLastMissingValueAnalysis

        Map<Long,​AuditEvent> getLastMissingValueAnalysis​(Collection<Long> ids)
        Parameters:
        ids - ids
        Returns:
        AuditEvents of the latest missing value analysis for the specified expression experiment ids. This returns a map of id -> AuditEvent. If the events do not exist, the map entry will point to null.

      • getLastProcessedDataUpdate

        Map<Long,​AuditEvent> getLastProcessedDataUpdate​(Collection<Long> ids)
        Parameters:
        ids - ids
        Returns:
        AuditEvents of the latest rank computation for the specified expression experiment ids. This returns a map of id -> AuditEvent. If the events do not exist, the map entry will point to null.

      • getPerTaxonCount

        Map<Taxon,​Long> getPerTaxonCount()
        Returns:
        counts of expression experiments grouped by taxon

      • getPopulatedFactorCounts

        Map<Long,​Long> getPopulatedFactorCounts​(Collection<Long> ids)
        Parameters:
        ids - ids
        Returns:
        map of ids to how many factor values the experiment has, counting only factor values which are associated with biomaterials.

      • getPopulatedFactorCountsExcludeBatch

        Map<Long,​Long> getPopulatedFactorCountsExcludeBatch​(Collection<Long> ids)
        Parameters:
        ids - ids
        Returns:
        map of ids to how many factor values the experiment has, counting only factor values which are associated with biomaterials and only factors that aren't batch

      • getPreferredQuantitationType

        @Nullable
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
QuantitationType getPreferredQuantitationType​(ExpressionExperiment ee)
        Iterates over the quantitation types for a given expression experiment and returns the preferred quantitation types.
        Parameters:
        ee - experiment
        Returns:
        quantitation types

      • hasProcessedExpressionData

        @Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
boolean hasProcessedExpressionData​(ExpressionExperiment ee)
        Test if the given experiment has processed data vectors.

      • getQuantitationTypeCount

        @Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Map<QuantitationType,​Long> getQuantitationTypeCount​(ExpressionExperiment ee)
        Returns:
        counts design element data vectors grouped by quantitation type

      • getQuantitationTypes

        @Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<QuantitationType> getQuantitationTypes​(ExpressionExperiment expressionExperiment)
        Parameters:
        expressionExperiment - experiment
        Returns:
        all the quantitation types used by the given expression experiment

      • getSubSets

        @Secured({"IS_AUTHENTICATED_ANONYMOUSLY","AFTER_ACL_COLLECTION_READ"})
Collection<ExpressionExperimentSubSet> getSubSets​(ExpressionExperiment expressionExperiment)
        Parameters:
        expressionExperiment - experiment
        Returns:
        any ExpressionExperimentSubSets this Experiment might have.

      • getTaxon

        @Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Taxon getTaxon​(BioAssaySet bioAssaySet)
        Returns the taxon of the given expressionExperiment.
        Parameters:
        bioAssaySet - bioAssaySet.
        Returns:
        taxon, or null if the experiment taxon cannot be determined (i.e., if it has no samples).

      • isRNASeq

        boolean isRNASeq​(ExpressionExperiment expressionExperiment)
        Parameters:
        expressionExperiment - ee
        Returns:
        true if this experiment was run on a sequencing-based platform.

      • isTroubled

        boolean isTroubled​(ExpressionExperiment expressionExperiment)
        Check if the dataset is either troubled or uses a troubled platform.

      • replaceRawVectors

        @Secured({"GROUP_USER","ACL_SECURABLE_EDIT"})
ExpressionExperiment replaceRawVectors​(ExpressionExperiment ee,
                                       Collection<RawExpressionDataVector> vectors)
        Used when we are replacing data, such as when converting an experiment from one platform to another. Examples would be exon array or RNA-seq data sets, or other situations where we are replacing data. Does not take care of computing the processed data vectors, but it does clear them out.
        Parameters:
        ee - experiment
        vectors - If they are from more than one platform, that will be dealt with.
        Returns:
        the updated Experiment

      • addCharacteristic

        void addCharacteristic​(ExpressionExperiment ee,
                       Characteristic vc)
        Will add the vocab characteristic to the expression experiment and persist the changes.
        Parameters:
        ee - the experiment to add the characteristics to.
        vc - If the evidence code is null, it will be filled in with IC. A category and value must be provided.

      • thawLite

        @CheckReturnValue
@Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
ExpressionExperiment thawLite​(ExpressionExperiment expressionExperiment)
        Partially thaw the expression experiment given - do not thaw the raw data.
        Parameters:
        expressionExperiment - experiment
        Returns:
        thawed experiment

      • isBlackListed

        boolean isBlackListed​(String geoAccession)

      • isSuitableForDEA

        @Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Boolean isSuitableForDEA​(ExpressionExperiment ee)
        Returns:
        true if the experiment is not explicitly marked as unsuitable for DEA; false otherwise.

      • getExperimentsLackingPublications

        @Secured({"IS_AUTHENTICATED_ANONYMOUSLY","ACL_SECURABLE_READ"})
Collection<ExpressionExperiment> getExperimentsLackingPublications()
        Returns:
        collection of GEO experiments which lack an association with a publication (non-GEO experiments will be ignored)