All Classes and Interfaces
Class
Description
Base class for
AnnDataSingleCellDataLoader configurers.Base implementation of
AsyncFactoryBean.An entity which can have an audit trail attached to it.
Base class for all ontologies built-in to the baseCode project.
Base class for bulk expression data matrices.
Partial implementation of
FilteringVoEnabledDao based on the JPA Criteria API.Holder for the JPA Criteria primitives needed to assemble a filtering query.
Created by tesarst on 07/03/17.
Created by tesarst on 07/03/17.
Pre-fetched triple of "last X event" associations off a
CurationDetails, batch-loaded
per page of curatable entities to avoid the N×3-SELECT proxy-init cost of letting each VO
constructor touch the three lazy proxies on its own.AbstractDao finds the generic type at runtime and provides default
BaseDao implementations on top of
SessionFactory.A delegating executor service inspired by
DelegatingSecurityContextExecutorService.The bare minimum to represent a factor value.
Base class for fetchers that provide data downloading, file locking, progress reporting, logging and parallel task
execution capabilities.
Base implementation of the filter interface.
Base implementation for
FilteringVoEnabledDao.Meta-information for a filterable property.
Base implementation for
FilteringVoEnabledService.Base class for design element mapper that use gene identifiers.
Base class for identifiable entities.
Base class for flat lexical vocabularies served as an
OntologyService.Abstract class representing an object that can read in a
Matrix2D from a file.Base class for ExpressionDataMatrix implementations that can deal with multiple BioAssays per BioMaterial.
Base class to use to pretend to offer filtering, but actually supporting no filterable properties.
Partial implementation of
FilteringVoEnabledDao based on Hibernate Query.Base for all services handling DAO access.
Handle detection and download of single-cell data from a single file in the supplementary materials of a GEO series.
Created by tesarst on 01/06/17.
Created by tesarst on 01/06/17.
Gemma-specific extension points for
BaseAclAdvice: identifies User / UserGroup,
supplies their granted authority, marks the entity types that should keep private ACLs on
admin-driven creation, and runs the DEA → ExpressionAnalysisResultSet parent-ACL
special case.This is only needed because we use a custom Sid implementation.
Stash the
SessionFactoryImplementor onto AclQueryUtils.sessionFactory
at Spring init.Provide ACL-related metadata.
We have our own implementation of the AclDao in part because of deadlock problems caused by the default JDBC-based
spring security DAO.
Hibernate-mapped
acl_entry row.Subclass this when you want to filter collections based not on the security of the object itself, but by an
associated object.
Subclass this when filtering a collection based not on the security of the element itself but on the security of an
associated parent domain object.
Single-object after-invocation provider that evaluates ACLs on an associated (parent) domain object rather than on
the returned object itself.
Overrides the functionality of the spring-provided
AclEntryAfterInvocationCollectionFilteringProvider
to be more efficient with large collections.Overrides the functionality of the spring-provided
AclEntryAfterInvocationCollectionFilteringProvider
to be more efficient with large collections by using AclService.readAclsById(List, List)
to bulk-fetch ACLs for every element of the returned collection in a single query.Filter
CompositeSequence based on the permissions of the associated ArrayDesign.Filter collections of
CompositeSequence based on the permissions of the associated ArrayDesign(s).Filter collections of
DataVector and DataVectorValueObjects based on the permissions of the
associated ExpressionExperiment(s).Filter collections of
DifferentialExpressionAnalysisResult by the ExpressionAnalysisResultSet they
belong to.Like the AclEntryAfterInvocationCollectionFilteringProvider, but filters on the keys AND values of a Map, where the
keys are Securable and the values MAY be Securable.
Filter a one-to-one map where the keys are NON-SECURABLE and the values ARE securable (or at least, can be).
Filter out public
Securables, leaving only ones that the user owns and can edit.Filter a collection of
Securable so that only the entries the current user owns (or is an admin on) and can
edit remain.Filter out public
Securables, leaving only ones that the user specifically can view but aren't public.Filter a collection of
Securable to keep only entries that are not public AND that the current user
can read (this includes data sets that are read-only-shared by another user).Overrides default behaviour by returning null, rather than throwing an access denied exception
After-invocation provider for the
AFTER_ACL_READ_QUIET config attribute: same ACL
check as the stock AclEntryAfterInvocationProvider (READ or ADMINISTRATION on the
returned single domain object), but denial is converted
to a null return value rather than propagated.Filter domain objects from a
Stream.After-invocation provider that filters a
Stream of domain objects, retaining only those for which the
authenticated user holds one of the requirePermission grants.Security check for reading collections of SecureValueObjects, or maps that have SecureValueObjects as keys - map
values are NOT checked.
Gemma-owned after-invocation provider for the
AFTER_ACL_VALUE_OBJECT_COLLECTION_READ
config attribute: bulk ACL check + per-row SecureValueObject security-metadata
population over a returned collection.Gemma-owned after-invocation provider for the
AFTER_ACL_VALUE_OBJECT_MAP_READ config
attribute: bulk ACL check + per-key SecureValueObject security-metadata population over
a returned Map whose keys are SecureValueObjects.Security check for reading value objects.
Gemma-owned after-invocation provider for the
AFTER_ACL_VALUE_OBJECT_READ config
attribute: single-object ACL check on a SecureValueObject return value.Customized voter that looks at collections to see if permissions are present for objects contained in the collection;
the processDomainObjectClass set refers to the types of objects in the collection.
A voter for the value of a map.
A voter over the keys of a map.
An extension of
AclEntryVoter.Renovations Phase 3: drive ACL maintenance directly off Hibernate's per-entity insert and
delete events instead of
@AfterReturning AOP advice on DAO methods.Renovations Phase 3: register
AclEventListener with Hibernate's
EventListenerRegistry so PostInsert and PostDelete events drive ACL maintenance
directly, replacing the @AfterReturning AOP advice that walked DAO arguments via
reflection.Hibernate-mapped row for a granted-authority entry in
acl_sid (discriminator
principal=0).Represents an access control list (ACL) for a domain object.
Configuration for the ACL linter.
Transaction boundary for the ACL linter's parent-linking repair.
Lint and possibly fix ACL issues.
Implementation of
ObjectIdentity.Hibernate-mapped row for a principal entry in
acl_sid (discriminator principal=1).Utilities for integrating ACL into
Query.Hibernate-mapped abstract base for
acl_sid rows.Sid retrieval strategy that mirrors Spring Security's stock
SidRetrievalStrategyImpl but threads through an
injected RoleHierarchy (Spring's stock impl uses a NullRoleHierarchy by default).Spring Security 6
AuthorizationManager adapter that delegates to a legacy
AccessDecisionVoter bound to a single ConfigAttribute string.Wires
AclVoterAuthorizationManager beans, one per active ACL_SECURABLE_* config
attribute, on top of the existing gsec voter beans.The curator an action is being taken FOR, for the duration of one call.
Closeable that does not throw, so it can sit in a try-with-resources without a catch.
Interface for services of immutable entities that can only be edited by admins.
Interface for services of entities that can only be edited by admins.
Extract the chip type from Affymetrix CEL files.
Reads Affymetrix Probe files, including exon arrays.
Extract the scan date from Affymetrix CEL files.
Discriminator on
AgentProposal rows: which kind of agent activity a
row records — a forward-looking proposal (pre-curation suggestion), an audit
(a post-hoc review of an existing dataset, reporting findings to act on), or
an evaluation (a scored assessment of curation that already exists).Special case of
DataAddedEvent for aggregated single-cell data.Because agilent makes slides that work with any scanner, the formats are not that predictable.
Strategy used to handle a failed user authentication if it is a ajax style login (ajaxLoginTrue parameter = true)
then no redirect happens and a some JSON is sent to the client if the request is not ajax style then the default
redirection takes place
Strategy used to handle a successful user authentication if it is a ajax style login (ajaxLoginTrue parameter = true)
then no redirect happens and a some JSON is sent to the client if the request is not ajax-style then the default
redirection takes place
Signifies a mapping based on sequence alignment performed by the system.
Exception raised when all analyses fail.
Exception raised when all subset analyses failed with an
AnalysisException.Can be thrown when an attempt is made to load data into the system that already exists.
Hibernate Search 7 mapping: contributes its
AlternateName.getName() as a tokenized field to
ArrayDesign's document via @IndexedEmbedded.An analysis of one or more Investigations.
Base exception for all differential analysis-related exceptions.
Abstract class representing a single result from an
Analysis and a typical part of an AnalysisResultSet.An abstract class representing a related set of generic analysis results, part of an analysis.
Generic DAO for manipulating
AnalysisResultSet.Interface for services providing
AnalysisResultSet.Exposes an
AnalysisResultSet to the public API.Wraps an
AnalysisResult to expose it on the public API.Provides basic services for dealing with analyses
Used for indication of the suitability, or unsuitability, of an entity for a particular type of analysis.
Defines the different types of analyses our linear modeling framework supports:
GENERICLM - generic linear regression (interactions are omitted, but this could change)
OSTTEST - one sample t-test
OWA - one-way ANOVA
TTEST - two sample t-test
TWO_WAY_ANOVA_WITH_INTERACTION
TWO_WAY_ANOVA_NO_INTERACTION
Utility methods for dealing with analyses.
Detects AnnData in GEO series.
Reads single-cell vectors from the AnnData on-disk HDF5 format.
A configuration for loading single-cell data form AnnData format.
An association between BioSequence and GeneProduct that is provided through an external annotation source, rather
than our own sequence analysis.
Read-only retrieval service for
AnnotationAssociation.Implementation of
AnnotationAssociationReadService.To signify the array design was mapped from an external source, not by our own sequence analysis.
Turns on annotation-driven scheduling (
@Scheduled) for real deployments.One term stands in some relation to another term:
subject — predicate → object, plus where
that came from.How an
AnnotationRelation came to be known, ranked best first.Reads over
AnnotationRelation.Which end of the relation a caller is seeding from.
What to look for.
A relation aggregated over its attesting experiments, for one basis.
Hibernate implementation of
AnnotationRelationDao.Read access to the relations Gemma knows between annotation terms.
Read-only service over
AnnotationRelationDao.Whether a source is stating that a relation holds, or stating that it does not.
A "curation hypothesis" attached to an
Investigation: a JSON
description of one annotation set in one of three lifecycle shapes
(see AnnotationSetRole).DAO for
AnnotationSet rows.Field a cross-experiment listing is ordered by.
Hibernate implementation of
AnnotationSetDao.One ruling on one finding inside an
AnnotationSet.DAO for
AnnotationSetDisposition rows — a curator's rulings on the
individual findings inside an audit set.Hibernate implementation of
AnnotationSetDispositionDao.A curator's rulings on the individual findings inside an audit
AnnotationSet.Default
AnnotationSetDispositionService.Emitted when an
AnnotationSet row is appended to a
PreboardedExperiment (or, for the private curation API, to a
loaded ExpressionExperiment).How many factors and tags an annotation-set payload proposes.
Role discriminator on
AnnotationSet rows.Service surface for
AnnotationSet rows.Who produced an annotation set, and from which build.
Default
AnnotationSetService implementation.Source discriminator on
AnnotationSet rows.Thin metadata projection of an
AnnotationSet row, served by the
REST surface when ?shape=meta is requested.One judge's standing ruling on how much an
AnnotationSet matters.DAO for
AnnotationSetTriage rows — one standing ruling per
(annotation set, judge).Hibernate implementation of
AnnotationSetTriageDao.Triage rulings on
AnnotationSets: how much a set matters, one
standing judgement per judge.Default
AnnotationSetTriageService.Represents one row of an ANOVA table
Interface implemented by
SingleCellDetector have the capabilities of looking-up archives.Interface defining a class that downloads archives and unpacks them.
Represents an assembly of design elements that are assayed all at once.
An event involving the analysis of an ArrayDesign
Methods to generate annotations for array designs, based on information already in the database.
Created by tesarst on 13/03/17.
The mapping of probes to genes for an ArrayDesign
Supports obtaining detailed information about the sequence analysis of probes on microarrays.
Co-bean carrying the
ArrayDesignMergeEvent emission that
ArrayDesignMergeHelperServiceImpl.persistMerging(ArrayDesign, ArrayDesign, Collection, boolean, Collection) records against
each participating platform.Implementation of
ArrayDesignMergeAuditService: a thin co-bean that
exists so each ArrayDesignMergeAuditServiceImpl.recordMerge(ArrayDesign, String) call is invoked
through a Spring proxy and the Audited aspect can intercept it and
emit the ArrayDesignMergeEvent.
Make new array design based on others
Keep map of relation between new design elements and old ones
Store relationship with mergees
Handles persisting array designs.
For an array design, generate gene product mappings for the sequences.
A probe mapper spaces task .
A command object to be used by spaces.
Signifies that the probes were renamed from their original values.
Thin read-only retrieval service for
ArrayDesign.Implementation of
ArrayDesignReadService.Compact platform identity — enough to name a platform and link to it.
Project a full
ArrayDesignValueObject down to this shape at serialization time.A command object to be used by spaces.
An array design repeat scan spaces task
Regenerates the cached platform reports in the background.
Regenerate the cached on-disk platform reports, either for every platform or for a single one.
Aligns sequences from array designs to the genome, using blat, and persists the blat results.
The sequence alignment analysis of an ArrayDesign
Handles collapsing the sequences, attaching sequences to DesignElements, either from provided input or via a fetch.
Used to indicate that all associations that this array design has with BioSequences have been removed.
The updating of the sequences associated with an ArrayDesign
Used to hold information for matching to a new experiment, during persisting.
Value object for quickly displaying varied information about Array Designs.
Utilities and algorithms for arrays.
Async extension of the
FactoryBean interface.Created by tesarst on 07/03/17.
Method-level annotation requesting that an
AuditEvent of the declared type be
written to the audit trail of the first Auditable argument after the method
returns normally.Spring AOP aspect that backs the
Audited annotation.Conditional cousin of
Audited.Spring
ApplicationEvent published by AuditedAspect every
time an Audited-annotated method completes successfully.Throwing cousin of
Audited / AuditedConditional.Container annotation for repeated
AuditedOnError declarations on a
single method.An event in the life of an object.
Marker for typed, JSON-serialised payloads carried by an
AuditEvent.Sentinel payload for events that carry no extra structured data.
Logger for created
AuditEvent.The trail of events (create or update) that occurred in an objects lifetime.
Phase 3 persister retirement (roadmap step 2): a Hibernate
PersistEventListener
that guarantees every Auditable entity has a non-null AuditTrail attached
before session.persist hands it off to the cascade machinery.Phase 3 persister retirement (roadmap step 2): registers
AuditTrailEventListener with Hibernate's EventListenerRegistry
so every session.persist of an Auditable flows through a single
audit-trail guard, replacing the per-call priming previously hand-coded in
PersisterHelperImpl.doPersist.Create and manipulate audit trails.
Defines constants used in GrantedAuthories.
Deprecated.
this event type was used by the auto-tagger, which has been removed.
Adds security controls to newly created objects (including those created by updates to other objects via cascades),
and removes them for objects that are deleted.
Configure the baseCode library from a given property sources.
Exception that wraps a baseCode
OntologySearchException.Interface that supports basic CRUD operations.
Base service class for an immutable entity.
Represents a baseline for a single factor or an interaction of factors.
Utilities for deciding if a factor value is a baseline condition.
Interface for read-only services.
Interface that supports basic CRUD operations.
Created by tesarst on 01/06/17.
Created by tesarst on 01/06/17.
A line parser that produces a Map instead of a Collection.
A simple LineParser implementation that doesn't do anything.
Represents a summary of a batch effect confound.
Test if an experimental design is confounded with batches.
provide some basic information about the properties and strength of a batch effect, if any.
Represents a batch effect.
Task to try to get 'batch' information about an experiment.
Indicate that batch information is missing.
Parse information on batch from raw data files.
Used to indicate a problem with the population of batch information for a given
ExpressionExperiment.Retrieve batch information from the data source, if possible, and populate it into experiments.
Retrieve batch information from the data source, if possible, and populate it into experiments.
Schedule job that populates batch information for all experiments that have been updated since the last run.
Abstract class for events related to batch information.
Indicates that batch information was successfully obtained.
Indicate that batch information has been looked for and was missing.
Event that tracks when batch effects or problems are detected.
Utilities for working with bean factories.
Hook into the bean post-processing lifecycle and record bean initialization time.
Our \@Service etc.
Hibernate Search 7 indexed root.
Read-only retrieval service for
BibliographicReference.Implementation of
BibliographicReferenceReadService.Implementation of
BibliographicReferenceService.represents a BibliographicReferenceValueObject when this value object is needed in core, the same value object exists
in web
Base class for
Keyword and MedicalSubjectHeading; the @Indexed
annotation lives on the concrete subclasses.Registers binary-aware HQL functions for working with BLOB-mapped columns.
Represents the bringing together of a biomaterial with an assay of some sort (typically an expression assay).
Categories for
BioAssays.Stores the order of BioAssays referred to in DataVectors.
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
ubic.gemma.model.expression.bioAssayData.BioAssayDimension.
Spring Service base class for
BioAssayDimensionService, provides access to all services and entities
referenced by this service.Strategy used for comparing
BioAssay to sample names from the data.Handle 'flagging' a sample as an outlier.
Read-only retrieval service for
BioAssay.Implementation of
BioAssayReadService.Represents a set of
BioAssays.Interface for VOs deriving from
BioAssaySet.Parser for BioMart file.
BioMart is a query-oriented data management system.
Class that is responsible for generating a map of BioMartEnsembleNcbiObject value objects which are keyed on ensemble
protein id.
In MAGE, BioMaterial is an abstract class that represents the important substances such as cells, tissues, DNA,
proteins, etc...
Indicates that the biomaterial to bioassay mapping of the expression experiment was modified.
Read-only retrieval service for
BioMaterial.Implementation of
BioMaterialReadService.
The sequence of a biological polymer such as a protein or DNA.
An association between a BioSequence and a Gene Product.
Read-only retrieval service for
BioSequence.Implementation of
BioSequenceReadService.Spring Service base class for
BioSequenceService, provides access to
all services and entities referenced by this service.Helpers for emitting portable native-SQL bitwise operations.
Represents a blacklisted entity that should not be loaded into Gemma.
TODO Document Me
This class contains Java versions of a number of the LINPACK
basic linear algebra subroutines (blas):
isamax_j
daxpy_j
ddot_j
dscal_j
dswap_j
dnrm2_j
dcopy_j
drotg_j
It also contains utility routines that the translator found useful
while translating the FORTRAN code to Java code.
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
BlatAssociation.Read-only retrieval service for
BlatAssociation.Implementation of
BlatAssociationReadService.Given a set of BlatAssociations that might be redundant, clean them up and score them.
Spring Service base class for
BlatAssociationService, provides access to all services and entities
referenced by this service.Represents the result of a BLAT search.
Used to convert BlatResult objects into PSL lines that can be displayed in the UCSC Genome Browser.
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
ubic.gemma.model.genome.sequenceAnalysis.BlatResult.Loader to handle results generated by Jim Kent's Blat.
Read-only retrieval service for
BlatResult.Implementation of
BlatResultReadService.Spring Service base class for
BlatResultService, provides access to all services and entities referenced
by this service.Value object for a
BulkExpressionDataVector containing booleans.A bootstrapped data source that strips the database from the JDBC URL.
Cheesy v1 brain-related keyword matcher.
Support for paging through the data.
Populate build information in the Log4j
ThreadContext.Slice bulk data vectors.
A bulk expression data matrix that can be efficiently accessed as a primitive int matrix.
Interface for bulk expression data matrices.
Interface for bulk expression data matrices that can be efficiently accessed as a primitive double matrix.
Interface for bulk expression data matrices that can be efficiently accessed as a primitive int matrix.
A data vector storing bulk expression data.
Methods to test business-key-related issues on objects.
Class to convert byte arrays (e.g., Blobs) to and from other types of arrays.
Represents a vector of scalars stored as a byte array in a single column.
Utilities for working with byte arrays.
Represents a lock over a cache key.
Represents an acquired lock on a cache key.
Common helpers for Spring
Cache manipulation.Represents a categorical array.
Enumeration of commonly used categories for referring to in the code.
Represents a category.
Write metadata file for the Cell Browser visualization tool.
Generate a tabular matrix format compatible with Cell Browser.
Strategy for mapping sample name to
BioAssay that relies on overlapping cell IDs.Characteristics applicable to individual cells in a
SingleCellDimension.Event emitted when a cell-level characteristics is removed.
Event emitted when a cell-level characteristics is modified (either added or removed).
Utilities for creating, reading and writing mappings of
CellLevelCharacteristics to ExperimentalFactor.Event emitted when a cell-level characteristics is removed.
Cellosaurus served as a flat lexical cell-line
name-resolution source, as a backup for the Cell Line Ontology (CLO) in cell-line searches.
Turns Cellosaurus into
AnnotationRelationBasis.EXTERNAL relations: which disease a cell
line's donor had, and which part of the body it came from.Represents a cell type assignment where cells from a given dataset are assigned cell types.
Event emitted when a
CellTypeAssignmentEvent is added.Event emitted when a cell type assignment is modified (either added or removed).
Event emitted when a
CellTypeAssignmentEvent is removed.Configures a
AnnDataSingleCellDataLoader for CELLxGENE datasets.A configuration for loading CELLxGENE data from AnnData files.
Convert CELLxGENE dataset metadata into an ExpressionExperiment.
High-level service for fetching and loading CELLxGENE datasets.
Fetch data from CELLxGENE.
Implementation of a chain of entity mappers.
Determine if a quantitation type (by name) represents background or signal.
Instances of this are used to describe other entities.
A term prior curators chose for some value string, and how many distinct experiments they
chose it on.
One representative, ACL-visible usage of a term (keyed by its value URI), for showing a search hit in
the context it has actually been applied (e.g.
Read-only retrieval service for
Characteristic and Statement.Implementation of
CharacteristicReadService.This handles characteristic updates from the client: experiment tags, characteristic browser
Value object representation of a
Characteristic.Resolves the corpus-side seed set for the CHEBI slim build (consumed by
ubic.gemma.core.ontology.providers.OntologySlimExtractor): every CHEBI
URI the gemd corpus uses, in any of the subject, object or second-object slots.Identifies a drug developmental / trial code against ChEMBL's synonym table.
Resolves a trial code against ChEMBL's synonym table
(
GET {base}/chembl/api/data/molecule?molecule_synonyms__molecule_synonym__iexact=...).A compound ChEMBL identifies for a developmental / trial code, together with the provenance of
that identification.
Immutable representation of a chromosome
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
ubic.gemma.model.genome.Chromosome.Some part of a chromosome
Spring Service base class for
ChromosomeService, provides access to all services
and entities referenced by this service.A utility class for
ChromosomeRepresents a BibliographicReference as a citation string (which is really super light value object).
An ontology service that loads an ontology from a classpath resource.
Cell type → anatomical structure relations that CL entails rather than asserts.
Creates a color matrix from a matrix of doubles
An event indicating a comment was added to the auditable.
Persister for ubic.gemma.model.common package classes.
Contains methods to perform 'common' queries that are needed across DAOs.
Phase 3 XML->Java migration: replaces
applicationContext-component-scan.xml.Static factories for Micrometer registries that need a wiring step Spring XML cannot express
directly (because the constructors take Clock or PrometheusConfig statics that are public
fields, not factory methods).
A search source constituted of multiple other sources.
A "Probe set" (Affymetrix) or a "Probe" (other types of arrays).
Lightweight (sequence, length) projection used to hydrate
CompositeSequenceValueObject.getSequence() +
CompositeSequenceValueObject.getSequenceLength() on opt-in
platform-elements requests.This is a convenience object to hold the results of CompositeSequence mapping results.
Parse the "old" array description format.
Read-only retrieval service for
CompositeSequence.Implementation of
CompositeSequenceReadService.Hibernate Search 7 mapping: chemicals attached to
BibliographicReference
via @IndexedEmbedded; name is tokenized, registryNumber is keyword (CAS).
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
ubic.gemma.model.expression.biomaterial.Compound.
Spring Service base class for
CompoundService, provides access to all services and entities referenced
by this service.Supports sparse matrices (where sparse means most values are zero, not that they are missing).
Utilities for
CompRowMatrix.Configuration of ontology services and other things.
Shared configuration helpers.
Convenience methods for loading configurations.
Constants used across Gemma.
Numeric constants used in some ports of statistical code.
Representing a person or organization that can be contacted about, or is the source of, data in the system.
Helpers for reading a
Contact the way a person is displayed.Represents a contrast.
Represents a contrast between "conditions".
Represents a contrast result.
Stores selected details of the contrasts for a single DifferentialExpressionResult
Helper object, not for general use.
Defines a class that can convert objects from one type to another.
Implementation of meta-analysis of correlations along the lines of chapter 18 of Cooper and Hedges, "Handbook of
Research Synthesis".
Statistical evaluation and transformation tools for correlations.
Information about a CPU.
Create a new database and drop an existing one if desired.
Fetch bibliographic metadata for a DOI from the CrossRef REST API
(api.crossref.org).
Created by tesarst on 06/03/17.
Created by tesarst on 13/03/17.
Resolved, section-scoped inputs for one all-or-none curation commit
(
ExpressionExperimentService.commitCuration(ExpressionExperiment, CurationCommitRequest, boolean)).A per-sample characteristic to create:
clientRef, the resolved biomaterial id, and the tag.A tag to create, paired with the document
clientRef so the report can echo its new id.Per-section change tallies from one
ExpressionExperimentService.commitCuration(ExpressionExperiment, CurationCommitRequest, boolean) call, mapped by the
web layer to the wire CurationCommitReport.changes.A curator's standing ruling that a change must NOT be made — or may be.
DAO for
CurationDecision rows -- standing rulings that a change must
not be made to an experiment.Hibernate implementation of
CurationDecisionDao.How wide a
CurationDecision reaches — the difference between the
refusal verbs the curation ledger actually uses.Standing rulings that a change must not be made to an experiment -- and the
rarer ruling that one may be.
Default
CurationDecisionService.Which way a standing
CurationDecision went.Class encapsulating all the curation information for Curatable objects.
Deprecated.
use
TicketService.Deprecated.
this interface only exists as a compatibility shim while callers
migrate off
Curatable#getCurationDetails().Default read-side implementation of
CurationDetailsService.Value object exposing
CurationDetails over the REST API.Derive per-element
CurationDraftDispositions.Disposition for a DRAFT
AnnotationSet by diffing its payload against the PROPOSAL
it was seeded from, and consulting AnnotationSet.getParkedElements().Result of a single-element diff.
An advisory, steal-able claim on a dataset's curation.
Advisory, steal-able claims on a dataset's curation.
Thrown when a lock is held by someone else and the caller did not ask to
steal it.
Default
CurationLockService.Deprecated.
curation notes will be migrated to ticket comments via
TicketService.addComment(Ticket, Contact, String)
once the curation-note ↔ ticket mapping lands (see CURATION_DETAILS_RETIREMENT.md).Opaque cursor for keyset pagination of REST collections.
A page of results returned by keyset (cursor) pagination.
Indicates that a data type (for a specific QuantitationType, possibly new) was added.
A reference to a record in a database.
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
DatabaseEntry.Read-only retrieval service for
DatabaseEntry.Implementation of
DatabaseEntryReadService.Spring Service base class for
DatabaseEntryService, provides access to all services and entities
referenced by this service.ValueObject for database entry
Populates the database schema.
Populates an existing database with any incremental schema changes implied by the current
Hibernate mapping.
Search source for direct database results.
ArrayExpress stores files in an FTP site as tarred-gzipped archives.
Represents an AnnData dataframe.
Base interface for loading expression data in Gemma.
Configures a
DataLoader from a DataLoaderConfig.Indicates that a data type (for a specific QuantitationType, possibly new) was removed.
Signifies that the data for the experiment was replaced (or filled in) after the experiment was loaded into the
system.
Class to handle cases where there are multiple GEO dataset for a single actual experiment.
Retrieve GEO GDS files from the NCBI FTP server.
A publication as it appears in the context of one dataset: the reference, plus the evidenced claim
that ties it to (or rules it out for) that dataset.
Emitted on
POST /datasets/{id}/publish?reviewer=X, when a curator
publishes a dataset under a named reviewer.Fired when a curator renames an ExpressionExperiment's
shortName.Renovations Phase 3: Java-config replacement for
applicationContext-dataSource.xml.Co-bean carrying the
DataReplacedEvent emission written at the end of
the data-replacement public methods on DataUpdaterImpl
(addAffyDataFromAPTOutput, reprocessAffyDataFromCel,
replaceData).Implementation of
DataUpdaterAuditService: a thin co-bean that exists
so DataUpdaterAuditServiceImpl.recordDataReplaced(ExpressionExperiment, String) is invoked
through a Spring proxy and the Audited aspect can intercept its
return path and emit the DataReplacedEvent.Update or fill in the data associated with an experiment.
An abstract class representing a one-dimensional vector of data about some aspect of an
ExpressionExperiment.Compute descriptive statistics for
DataVector.Base class for value objects of
BulkExpressionDataVector.Date helpers.
Default
Highlighter implementation that returns the matched value verbatim under its
field name.An interface for
ExecutorService that delegate to another ExecutorService.A dense matrix of doubles that knows about row and column names.
Use this class when fast iteration over the matrix is of primary interest.
Represents a dense AnnData matrix.
Interface for entities that have a name and description.
Utilities to manipulate
Describable and collections thereof.Mathematical functions for statistics that allow missing values without scotching the calculations.
Outcome returned by the
PUT /datasets/{id}/design apply path.Emitted by the
PUT /datasets/{id}/design apply path when a proposed
ExperimentalDesignValueObject
is successfully written back as the experiment's new design.Side-channel the web-layer design mapper hands to
ExpressionExperimentService.commitCuration(ExpressionExperiment, CurationCommitRequest, boolean) so the
service can, after applying the proposed design, (1) resolve each new entity's clientRef to the
database id it was assigned and (2) wire sample assignments that target freshly-created factor values.A sample assignment whose target factor value does not exist yet (identified by its
clientRef).Data vector associated to a
CompositeSequence.Maps gene identifiers to
CompositeSequence.Represents the A matrix in regression problems posed as Ax=b.
Report returned by
POST /datasets/{id}/designPreflight.One reason the proposed payload cannot be applied.
An analysis of changes in expression levels across experimental conditions
Holds the settings used for differential expression analysis, and defines some defaults.
Indicates the experiment was the subject of a differential expression analysis.
Filter used for performing DEA.
Holds the result of data filtering for differential expression analysis.
Service methods to do database-related work for differential expression analysis
Transactional methods for dealing with differential expression analyses.
Structured payload for the
DifferentialExpressionAnalysisEvent
written at the end of
DifferentialExpressionAnalyzerServiceImpl#persistAnalysis.Read-only retrieval service for
DifferentialExpressionAnalysis.Implementation of
DifferentialExpressionAnalysisReadService.Specialized command object for removing analysis results.
Result of an analysis of differences in expression levels -- a single test (e.g., for one gene or one probe), for one
factor.
File service for arbitrary list of
DifferentialExpressionAnalysisResult.Wraps an
ExpressionAnalysisResultSet and expose it to the public API.This class contains data for a column in metaheatmap visualization.
Unlike
DiffExResultSetSummaryValueObject, this value object is meant for the public API.Service interface for
DifferentialExpressionAnalysis.A command object to be used by spaces.
A differential expression analysis spaces task
A helper class for the differential expression analyzers.
Summary of a differential expression analysis
Co-bean facade for the
DifferentialExpressionAnalysisEvent audit
emission carried out at the end of
DifferentialExpressionAnalyzerServiceImpl.persistAnalysis(ExpressionExperiment, DifferentialExpressionAnalysis, DifferentialExpressionAnalysisConfig).Implementation of
DifferentialExpressionAnalyzerAuditService.Differential expression service to run the differential expression analysis (and persist the results using the
appropriate data access objects).
Represents a complete set of data for a differential expression query over a set of genes x conditions (resultSets x
contrasts).
A value object with meta analysis results.
Cache for differential expression results.
Cache for data from differential expression result queries.
This is a key class for queries to retrieve differential expression results (as well as standard CRUD aspects of
working with DifferentialExpressionResults).
Read-only retrieval service for
DifferentialExpressionAnalysisResult.Implementation of
DifferentialExpressionResultReadService.Main entry point to retrieve differential expression data.
Facade for
DifferentialExpressionResultService.Created with IntelliJ IDEA.
Created with IntelliJ IDEA.
Encapsulates the search for differential expression results, for a set of genes and experiments (which can be
grouped)
Used to indicate the suitability status of an ExpressionExperiment for differential expression analysis.
Represents the results for one probe.
Writer for
DifferentialExpressionAnalysis.Periodic warm-up of the DEA "find results by gene" path.
Used to perform meta-analyses of complete data sets (actually result sets), select the top genes, and potentially
store the results.
A command object to be used by spaces.
A differential expression meta-analysis space task
A command object with a selected factor and associated experiment.
Value object for differential expression result for one result - corresponds to the
DifferentialExpressionAnalysisResults for one gene in one ResultSet (combined for multiple probes), but represents
only the "selected" analysisResult.
Summary of a result set.
Pre-aggregated
experimentalFactors + baselineGroup for a single
ExpressionAnalysisResultSet, sourced from a batched join-fetch query so the
VO ctor avoids three sequential lazy initializations.
Represents the direction of a change e.g.
Thrown when
WorkflowService.advance(Investigation, WorkflowState, String, Long) is
asked for a transition the state machine forbids (e.g.Alternative distance and similarity metrics for vectors.
Deprecated.
resolve the open
GENERIC /
BATCH_INFO_NEEDED
ticket(s) targeting the entity via
TicketService.transition(Ticket, TicketState, Contact, String)
(target state
TicketState.RESOLVED).Abstract base class for 2D matrices of double values with named columns and rows.
Use this factory to create matrices of type selected at runtime (String parameterization only)
Reader for
DoubleMatrix.Value object for a
BulkExpressionDataVector containing doubles.Utilities for converting
DoubleVectorValueObject to BulkExpressionDataVector instances.This class contains the LINPACK DQRDC (QR decomposition)
and DQRSL (QR solve) routines.
Mock mail sender for testing.
Occurs when empirical bayes estimation fails.
This class provides a fast-path to
AclQueryUtils that uses the denormalized mask for anonymous users.Write service for
ExpressionExperiment graphs.Strangler-fig replacement for the EE-graph write path historically owned by
ExpressionPersister (now removed; the polymorphic EE dispatch arms
have been folded into PersisterHelperImpl.doPersist(Collection, Map)).Spring application-cache configuration backed by Ehcache 3 (jakarta classifier) via JCache (JSR-107).
A right singular vector (a.k.a.
author: anton date: 10/02/13
An empty bulk expression data matrix.
Used to make a 'dummy matrix' that has the column information populated.
Value object that represents a file record line from BioMart as configured with query parameters.
Match design elements using Ensembl IDs.
Map external identifiers to Gemma entities.
Mapping statistics computed from a given set of entities and identifiers.
A stateful entity mapper keeps an internal state for a set of candidates to optimize the mapping process.
A simple task command that contains an entity ID and class.
This builder allows for generating URLs for entities in Gemma Web and REST.
Exception raised when an Entrez reply contains an
ERROR tag.Represents an Entrez search query.
Possible values for the Entrez
retmode parameter.Low-level utilities for generating Entrez URLs.
Utilities for manipulating Entrez XML responses.
An array backend by a H5 enum dataset.
Spring profile name constants used in the Gemma context.
High-level API for interacting with NCBI Entrez utilities.
Extends
Executors to ensure that security context logging works as expected.Hibernate Search 7 mapping: indexed root and embedded contributor to
ExpressionExperiment.getExperimentalDesign().
Parse a description of ExperimentalFactors from a file, and associate it with a given ExpressionExperiment.
See interface for docs.
Read-only retrieval service for
ExperimentalDesign.Implementation of
ExperimentalDesignReadService.Spring Service base class for
ubic.gemma.model.expression.experiment.ExperimentalDesignService, provides
access to all services and entities referenced by this service.Describes an event that involved a change of assignment of factor value to bio material, or other changes in the
experimental design.
Full structural representation of an
ExperimentalDesign: factors, their factor values (with statements
carrying stable database IDs), and the assignment of biomaterials to factor values.Assignment of a single
BioMaterial (sample) to its assigned FactorValues.One
ExperimentalFactor, with its factor values inlined.Tools for visualizing experimental designs.
Output compatible with
ExperimentalDesignImporterImpl.ExperimentFactors are the dependent variables of an experiment (e.g., genotype, time, glucose concentration).
Read-only retrieval service for
ExperimentalFactor.Implementation of
ExperimentalFactorReadService.Per-gene differential-expression statistics carried alongside expression levels for the
/datasets/{dataset}/expressions/differential endpoint.An analysis of one or more ExpressionExperiments
A group of results for an ExpressionExperiment.
🔒 The loaders below are ACL-guarded.
Matrix of booleans mapped from an ExpressionExperiment.
A high-level service for deleting data and their associated files.
A data structure that holds a reference to the data for a given expression experiment.
Supports the creation and location of 'flat file' versions of data in the system, for download by users.
Generate filenames for various types of data files.
Base interface for expression data filters.
Expression data heatmap for experiments and subsets.
Warning, not fully tested.
Represents a matrix of data from an
ExpressionExperiment.Methods to organize ExpressionDataMatrices by column (or at least provide the ordering).
Encapsulates information about the row 'label' for a ExpressionDataMatrix.
Tools for easily getting data matrices for analysis in a consistent way.
Tools for easily getting data matrices for analysis in a consistent way.
Base interface for writing
ExpressionDataMatrix.Interface for matrices that can provide unboxed doubles.
Perform SVD on an expression data matrix, E = U S V'.
Utilities for writing expression data files.
Hibernate Search 7 indexed root.
An event involving an ExpressionExperiment
Methods for correcting batch effects.
Provides status of batch information for datasets.
Created by tesarst on 13/03/17.
Raw + processed data vector CRUD operations for
ExpressionExperiment.Implementation of
ExpressionExperimentDataVectorService.Default filter used for various analyses of expression experiments.
Holds settings for filtering with
ExpressionExperimentFilter.Hold the results of filtering with
ExpressionExperimentFilter.This service provides access to GEO metadata for any given Gemma dataset.
A minimalistic projection of an
ExpressionExperiment.Types of metadata files that can be attached to an
ExpressionExperiment.
The event that this experiment has had its array design switched (typically to a 'merged' one.
Switch an expression experiment from one array design to another.
Async-task wrapper around
ExpressionExperimentPlatformSwitchService.switchExperimentToArrayDesign(ExpressionExperiment, ArrayDesign).Sets up the array designs before saving an experiment.
Sets up the array designs, put the designelements in the data vectors.
Thin read-only retrieval service for
ExpressionExperiment.Implementation of
ExpressionExperimentReadService.Compact dataset identity — enough to name a dataset and link to it.
Methods for reading and creating reports on ExpressinExperiments.
Handles creation, serialization and/or marshaling of reports about expression experiments.
Handles delegation of report generation (to the space, or run locally)
Handles searching for experiments and experiment sets
A grouping of expression studies.
Spring Service base class for
ubic.gemma.model.analysis.expression.ExpressionExperimentSetService,
provides access to all services and entities referenced by this service.This class will handle population of ExpressionExperimentSetValueObjects.
A subset of assays (or derived assays) from an
ExpressionExperiment.
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
ubic.gemma.model.expression.experiment.ExpressionExperimentSubSet.Read-only retrieval service for
ExpressionExperimentSubSet objects in the context of
a parent ExpressionExperiment.Implementation of
ExpressionExperimentSubSetReadService.Utility methods for
ExpressionExperimentSubSet.Indicates that we have updated an expression experiment's information from GEO, after it was already loaded in Gemma.
Indicates that the "Vector merging" has been done on the associated experiment.
Co-bean for
ExpressionExperimentWriteServiceImpl: a thin layer
that exists so the preferred-QuantitationType change-audit
methods are invoked through a Spring proxy, allowing the AuditedAspect
to intercept the return path.Co-bean implementation of
ExpressionExperimentWriteAuditService.Thin write/mutation service for
ExpressionExperiment.Implementation of
ExpressionExperimentWriteService.Service for reading and appending to changelog files.
Read-only retrieval service for
ExternalDatabase.Implementation of
ExternalDatabaseReadService.Co-bean carrying the
@Audited hook for
ReleaseDetailsUpdateEvent writes.Implementation of
ExternalDatabaseReleaseAuditService.Enumerates various globally available
ExternalDatabase by name.Utilities for working with various external databases.
Class to provide functionality to load genes from a tab delimited file.
Sync state of a
Ticket's optional GitHub-issue mirror (Decision 7
of AUDIT_AS_WORKFLOW_RECCE.md).What was extracted from the sample and assayed — GEO's
!Sample_molecule_chN.The value for a ExperimentalFactor, representing a specific instance of the factor, such as "10 ug/kg" or "mutant"
Each factorvalue can be associated with multiple characteristics (or with a measurement).
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
ubic.gemma.model.expression.experiment.FactorValue.This interface needed to be extracted for factor value deletions in
order to be able to make the methods transactional
Handles deletions of a factor values.
Indicates that a factor value needs attention.
Service to manipulate the "needs attention" flag on
FactorValues.Ticket-backed implementation of
FactorValueNeedsAttentionService.Ontology service for factor values and their annotations.
Read-only retrieval service for
FactorValue.Implementation of
FactorValueReadService.
Spring Service base class for
FactorValueService, provides access
to all services and entities referenced by this service.Deprecated.
aim towards using the
FactorValueBasicValueObject.Indicates that the attempt to get batch information failed due to an error.
Deprecated.
Represents a failed data replace.
A pipeline job reached terminal failure on an experiment.
Interface representing a class that can retrieve sequences from Blast databases.
FASTA sequence file parser.
Indicates that FASTQ headers were present, but were not in a format that yields usable information on batches.
Dense 2D matrix implementation designed for very fast access of entire rows.
Interface for classes that can fetch files from a remote location and copy them to a specified location.
Search source that can retrieve results matching specific fields.
Use to indicate a file format error.
Metadata about a file lock.
Metadata about a file lock.
Create shared and exclusive locks for files.
Ported in-tree from
ubic.basecode.util.FileTools (baseCode project, Apache 2.0,
University of British Columbia).An interface representing the functionality of a class that can filter 2-d matrix-based data by row-oriented
criteria.
Holds the necessary information to filter an entity with a property, operator and right-hand side value.
Interface for filtering-capable DAO.
One predicate of a conjoined subquery filter.
Exception raised when there is an issue during the filtering process of expression data.
Exception raised when data filtering fails.
Interface for filtering-capable services.
Interface for VO-enabled DAO with filtering capabilities.
Interface VO-enabled service with filtering capabilities.
JPA Criteria equivalent of
FilterQueryUtils.Utilities for integrating
Filter into Query.Represents a conjunction of disjunctions of
Filter.A curator's ruling on ONE finding inside an audit.
*
Fetcher that can fetch archives (e.g., tar.gz) and unpack them.
Factory and pool for
FTPClient.This implementation maintains one pool of FTP clients per URL authority (i.e
URL.getAuthority()).Download files by FTP.
Represents quality information about a data set.
Represents administrative geeq information.
Co-bean carrying the
GeeqEvent emission that
GeeqServiceImpl.calculateScore(ExpressionExperiment, GeeqService.ScoreMode) records at the end of each
scoring run.Implementation of
GeeqAuditService: a thin co-bean that exists so
GeeqAuditServiceImpl.recordGeeqScoring(ExpressionExperiment, String, String) is invoked
through a Spring proxy and the Audited aspect can intercept its
return path and emit the GeeqEvent.Modes for filling GEEQ scores.
Async-task wrapper around
GeeqService.calculateScore(ExpressionExperiment, GeeqService.ScoreMode).Represents publicly available geeq information
Spring-native ACL stack, replacing gsec's Hibernate-backed AclServiceImpl/AclDaoImpl.
Spring Security 6
PasswordEncoder that understands three formats:
Legacy SHA-1 + username-as-salt: stored as a bare 40-char hex digest with no
prefix, computed as SHA-1(rawPassword + "{" + username + "}") (the exact
output of Spring Security 3/4's ShaPasswordEncoder configured with
ReflectionSaltSource(userPropertyToUse="username") — see Gemma's pre-Phase-2
applicationContext-security.xml).Ontology created for Gemma.
A minimalist client for accessing Gemma's RESTful API.
For endpoints that return no data (i.e.
For endpoints that may return an error.
A response from the API, which is either a
GemmaRestApiClient.DataResponse or GemmaRestApiClient.ErrorResponse.Indicate that a property or type is only visible not visible outside of Gemma REST.
Provides convenience methods for GenBank.
Represents a functionally transcribed unit in the genome, recognized by other databases (NCBI, Ensembl).
Used to store information about what happened when the GENE2CS table was updated.
Entity representing a relationship between two genes.
Read-only retrieval service for
Gene2GOAssociation.Implementation of
Gene2GOAssociationReadService.Hibernate Search 7 mapping: contributes its
GeneAlias.getAlias() as a keyword (non-tokenized)
field via @IndexedEmbedded from Gene.Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
ubic.gemma.model.genome.gene.GeneAlias.Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
Gene.Represents an analysis that combines the results of other analyses of differential expression.
Provides access to
DifferentialExpressionAnalysisResults and meta-analysis results.* @author frances
This is a convenience value object to hold a BlatResult and its associated gene products and genes.
One probe-to-gene mapping, as it goes over the wire: a single alignment plus the genes it
supports.
Populate/update the gene multifunctionality information in the system.
Compute gene multifunctionality and store it in the database.
GO-based search source.
Hibernate Search 7 mapping: contributes
name (tokenized), ncbiGi (keyword), and
its accessions (via @IndexedEmbedded -> DatabaseEntry.accession) up to
Gene's document via the Gene.getProducts() embedded path.Read-only retrieval service for
GeneProduct.Implementation of
GeneProductReadService.Read-only retrieval service for
Gene.Implementation of
GeneReadService.Compact gene identity — just enough to label a row and link to the gene page.
Generic cell-level characteristics.
Service that simplifies operation with curatable entities of unknown types.
A meter binder that delegates to the appropriate
Executor implementation.A generic loader that can be used to load single-cell data with a tabular metadata file.
Attach all the given
MeterBinder to the registry.A way to create ad-hoc in-memory ontology services.
Looks through text file looking for a date near the top of the file in a reasonable format.
A meter binder that delegates to the appropriate
TaskExecutor implementation.Service for searching genes (and gene sets)
Service for searching genes (and gene sets)
A grouping of genes that share a common relationship.
The interface for managing groupings of genes.
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
ubic.gemma.model.genome.gene.GeneSet.Read-only retrieval service for
GeneSet.Implementation of
GeneSetReadService.Service for managing gene sets
Service for managing gene sets
Represents a Gene group gene set
* @author tvrossum
This class will handle population of GeneSetValueObjects.
Gene write-side business logic lifted out of
GenomePersister as part of the Phase 3 persisterHelper retirement
(Chunk 5.3 PREP).Implementation of
GeneWriteService.Persister-shrink S2b: lifted out of the
CommonPersister inheritance chain
into a concrete @Component.Genotype Ontology (GENO) — zygosity,
alleles and genotype structure.
Amounts of data that can be retrieved from GEO.
Strategy to match a
BioAssay against a sample name provided by GEO.Gets records from GEO and compares them to Gemma.
Represents data for one channel on a microarray in GEO.
Where a GEO
"key: value" characteristic actually divides.Constants used to help decipher GEO data files.
Convert GEO domain objects into Gemma objects.
Abstract class from which other GEO objects are descended.
A GEO-curated dataset.
Handle fetching and parsing GEO files.
GEO object generator that works on local files.
Class for parsing GSE and GDS files from NCBI GEO.
SRA's
library_strategy controlled vocabulary, as GEO reports it in
!Sample_library_strategy.This simply holds the results obtained from parsing.
Bean describing a microarray platform in GEO
Represents a GEO query.
Used to contain GEO summary information from the 'Browse' views.
Pluggable predicate over a
GeoRecord for the GEO scrape & preboard
pipeline.Outcome of a single matcher's evaluation.
Type of records that can be browsed in GEO.
Represents a group of samples that were replicated.
Permitted types of replication.
Configuration to use to retrieve GEO records from a
GeoQuery.Represents a sample (GSM) in GEO.
Holds information about GEO samples that "go together" across datasets (GDS), because they came from the same sample
(or so we infer)
Scope of data that can be retrieved from GEO.
Candidate returned from a dry-run GEO scrape.
Deprecated.
Supplanted by the curation agent's own GEO scraping, currently
scrape_geo_and_open_triage.py.Outcome of a dry run: the candidates, plus the two things a batching caller cannot work out
from the candidate list alone.
Parameters for a single scrape run.
Default
GeoScrapeService implementation.Deprecated.
Supplanted by the curation agent's own GEO scraping, currently
scrape_geo_and_open_triage.py.Deprecated.
Supplanted by the curation agent's own GEO scraping, currently
scrape_geo_and_open_triage.py.Async runner for the GEO scrape & preboard pipeline.
Append-only record of one GEO scrape run.
Lifecycle status of a scrape run.
Enumeration of possible fields for searching GEO records.
Represents a set of GEO samples that were submitted together.
Non-interactive fetching, processing and persisting of GEO data.
This is the main single-cell data detector that delegates to other more specific detectors.
Builds the schema-v1
Investigation.sourceMetadata document from a parsed GeoSeries.Identity of the experiment the document is being written for.
Represents a subset of samples.
Co-bean carrying the audit emission for
GeoServiceImpl.updateFromGEO(ExpressionExperiment, GeoUpdateConfig).Implementation of
GeoUpdateAuditService: a thin co-bean that exists
so GeoUpdateAuditServiceImpl.recordGeoUpdate(ExpressionExperiment, int, boolean) is invoked through a Spring proxy and the
AuditedConditional aspect can intercept its return path.Class to store the expression data prior to conversion.
A GeoVariable represents variables which were investigated.
Permitted descriptions of terms.
This enumeration was originally based on GO, but is used for all entities that have evidenciary aspects; Thus it has
been expanded to include: Terms from RGD (rat genome database)
IED = Inferred from experimental data
IAGP = Inferred from association of genotype and phenotype
IPM = Inferred from phenotype manipulation
QTM = Quantitative Trait Measurement
And our own custom code IIA which means Inferred from Imported Annotation to distinguish IEAs that we ourselves have
computed
See https://geneontology.org/docs/guide-go-evidence-codes/ for documentation of GO evidence codes.
Perform useful queries against GoldenPath (UCSC) databases.
Factory for
GoldenPathQuery instances.Default
GoldenPathQueryFactory that constructs a real
GoldenPathQuery bound to the configured GoldenPath database for
the supplied taxon.Using the Goldenpath databases for comparing sequence alignments to gene locations.
Factory for
GoldenPathSequenceAnalysis instances.Default
GoldenPathSequenceAnalysisFactory that constructs a real
GoldenPathSequenceAnalysis bound to the configured GoldenPath
database for the supplied taxon.Represents an
GrantedAuthority conferred by a group membership.Authority for groups (kind of like a "user role", but for group-based authorization)
Extension of
GroupManager.H2 dialect override for Gemma tests.
Represents an HDF5 attribute.
Represents an HDF5 dataset.
Represents all the fundamental H5 types from which all other types are derived.
Minimal interface for a labelled heatmap.
Metrics for Hibernate 4.
Query metrics for Hibernate 4.
Renovations Phase 3: Java-config replacement for
applicationContext-hibernate.xml.Wraps a Hibernate Search runtime exception in a checked
SearchException.Search source backed by Hibernate Search 7's local-Lucene backend.
Spring
FactoryBean that builds a Hibernate SessionFactory using Hibernate's native
Configuration bootstrap (not JPA).Pre-phase-2 this class did deep Hibernate-internal introspection
(
ClassMetadata, AbstractEntityPersister, reflective field
access for batchSize and eager).Custom highlighter for search results.
Interface for mappers that can provide hints of identifier candidates.
A simple histogram.
The number of probes meeting a given q-value threshold in the result set.
Cached snapshot of public-home-page statistics.
Count of public experiments created within one trailing window.
A single annotation term with its EE-mention count — used inside
HomeStats.TreatmentBucketStat.topTerms for the catchall-iteration loop.Refreshes
HomeStats on a daily cron AND on every Spring context refresh
(startup).Read + refresh the cached public home-page statistics snapshot.
Computes + caches the public home-page statistics snapshot.
Grabs urls like ftp:///ftp.ncbi.nih.gov/pub/HomoloGene/current/homologene.data
Reads in the homologene list as specified in the Gemmea.properties file.
A generic class for fetching files via HTTP and writing them to a local file system.
Deprecated.
this ontology was last updated in unmaintained since 2013
Interface for objects that have a numerical id.
Utilities for
Identifiable.Base implementations for value objects representing persistent objects
Mark a method as ignored for ACL.
Parse an Illumina "manifest.txt" file (tab-delimited).
Drives Hibernate Search 7's mass-indexer (built-in
MassIndexer) across the
@Indexed entity roots Gemma actually searches.Drives Hibernate Search 7's
MassIndexer for one entity class at a time.Marker interface for the async mass-indexer task.
Command for the asynchronous mass-indexer task; one boolean per indexable entity root.
Asynchronous mass-indexer task.
Exception raised when the quantitation of an
ExpressionDataMatrix does not agree with the one inferred.Populate some initial data for tests.
Exception raised when there is insufficient data to perform a filtering operation.
Exception indicating that there is insufficient design elements (rows) to perform a particular filter.
Exception indicating that there are insufficient samples (columns) in the dataset to perform a particular filter.
Exception raised when an
encoding-type attribute has an unexpected value.Exception raised when a log2 conversion fails.
An abstract concept of a scientific study
Jena-text 4.10 / Lucene 9 implementation of
OntologySearchService.Closes the "scheduler ran but never phoned home" gap.
Scheduler-side state read via
PipelineScheduler.poll(SchedulerHandle).Lifecycle of one
PipelineJob.Writes a
BulkExpressionDataMatrix to a JSON format.Hibernate Search 7 mapping: indexed root for keyword phrases attached to a
BibliographicReference.Perform a Kruskal-Wallis test.
Represents a layer.
Mark beans as lazy-init by default.
For performing "bulk" linear model fits, but also offers simple methods for simple univariate and multivariate
regression for a single vector of dependent variables (data).
DaoAuthenticationProvider that understands Gemma's two pre-Phase-2 legacy
password formats, both bare 40-char hex SHA-1 with no prefix:
Username-salt (post-2009-11-23): SHA-1(rawPassword + "{" + username + "}") —
configured via <s:salt-source user-property="username"/>.A plain
AnnotationProperty for flat lexical vocabularies.A Jena-agnostic, in-memory Lucene 9 full-text index over a flat lexical vocabulary.
A term from a flat lexical vocabulary (Cellosaurus, MGI strains, ...).
A single term from a flat lexical vocabulary: a URI, a primary label, zero or more synonyms, and
whatever descriptive metadata the source carries.
Descriptive metadata carried alongside a
LexicalTerm — the flat-vocabulary equivalent of the
annotation properties (definition, species, category) that a real ontology term carries.An organism an entry derives from.
Handles fitting linear models with continuous or fixed-level covariates.
The difference between this class and BasicLineMapParser is more flexibility in how keys are provided.
A Parser that processes its input line-by-line.
Computing coexpression links for an expression experiment
Utilities and algorithms for
List.Used for testing, but might have other uses, to fetch GEO data from local files instead of the GEO website.
A fetcher that only looks locally for "family" files (GPLXXX_family, GSEXXX_family).
A locked path.
Report progress to a specific log category.
Detects Loom files in series and samples.
Filter rows with low variance by keeping those with variance above a given cut-off.
Utilities for parsing search queries using Lucene.
Luigi-backed scheduler.
High-level service for sending mails.
Indicate that an entity has been made private.
Indicate that an entity has been made public.
Creates a security context using manual authentication.
Process authentication requests that come from outside a web context.
A simple implementation of
EntityMapper that uses a Map to store association between identifiers and
entities.Represents an AnnData mapping.
Utilities for handling Markdown text.
A wrapper for an
ExpressionDataMatrix that applies a mask to the data, allowing selective access to the
underlying matrix.Small numeric helpers.
Represents an AnnData matrix.
Represents a matrix with index columns and rows.
A visual component for displaying a color matrix
Utilities for reading MatrixMarket format.
Convenience functions for getting row statistics from matrices.
Extends
MatrixStats.Writes
BulkExpressionDataMatrix to a tabular format.Class for writing matrices to disk
Indicate that a collection or an entity may be intentionally uninitialized.
Meta-analysis methods from chapter 18 of Cooper and Hedges, sections 2.1 and 3.1
Estimate mean-variance relationship and use this to compute weights for least squares fitting.
Exception raised when
MeanVarianceEstimator fails.Responsible for returning the coordinates of the experiment's Mean-Variance relationship.
Manage the mean-variance relationship.
Utilities for
Measurement.Hibernate Search 7 mapping: indexed root for MeSH terms attached to a
BibliographicReference.Deprecated.
Information about system memory.
MeSH entry terms served as extra search strings for MONDO disease terms.
Statistics for meta-analysis.
Bind per-cache JSR-107 (JCache) metrics from a
CacheManager to a MeterRegistry.Method-security configuration for Gemma, replacing the deprecated XML
<s:global-method-security> block in applicationContext-security.xml.Phase 3 XML->Java migration: replaces the
<beans profile="metrics"> block from
applicationContext-serviceBeans.xml.Detects MEX data from GEO series and samples.
Bundles a directory containing MEX files into a TAR archive.
Writes
SingleCellExpressionDataMatrix to the 10x MEX format.Load single cell data from 10X Genomics MEX format.
Configure a
MexSingleCellDataLoader for a given directory and collection of BioAssays.Turns MGI's genotype-to-disease reports into
AnnotationRelationBasis.EXTERNAL relations:
which mutant alleles MGI's curators say model which diseases, and which they say do not.MGI (Mouse Genome Informatics) mouse strains as a
flat lexical strain name-resolution source, to annotate the complicated mouse strains/genotypes
that EFO/TGEMO don't enumerate (the ~84k coisogenic + ~17k congenic mutant strains).
Filter that removes samples that do not meet a minimum number of cells requirement.
Exception raised when a HDF5 file/group/dataset is lacking a
encoding-type and/or encoding-version
attribute.Represents a gene that was not tested.
Computing missing values for an expression experiment
In-JVM mock scheduler for local-mode smoke testing of the admin pipeline UI
without a real Luigi/Nextflow wired.
Utilities for working with Gemma models.
Implements methods described in
MONDO counterpart of
ChebiSeedResolver: every MONDO URI currently used as
Characteristic.valueUri anywhere in the gemd corpus.An interface for bulk matrices that supports multiple
BioAssay per BioMaterial.Task command for recomputing per-gene multifunctionality scores for a single taxon.
Async port of
MultifunctionalityCli: recompute per-gene multifunctionality
scores for a single taxon (or all taxa, if taxon == null).Raised when a factor carries more than one explicitly marked baseline and the analysis was not configured with a
subset factor.
Methods for p-value correction of sets of hypothesis tests.
Gemma's MySQL dialect, pinned to MySQL 5.7 / InnoDB semantics.
See ftp://ftp.ncbi.nlm.nih.gov/gene/DATA/README
Class to parse the NCBI gene2accession files.
This parses GO annotations from NCBI.
Convert NCBIGene2Accession objects into Gemma Gene objects with associated GeneProducts.
Simple helper data structure that stores an NcbiGeneInfo and its associated
NcbiGene2Accession elements.
Combines information from the gene2accession and gene_info files from NCBI Gene.
Class to download files for NCBI gene.
Represents the information from the "gene_history" file from NCBI (for one gene's history).
Parse the NCBI "gene_history" file.
See ftp://ftp.ncbi.nlm.nih.gov/gene/DATA/README
See http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/lxr/source/src/objects/entrezgene/entrezgene.asn unknown (0)
, 36
Class to parse the gene_info file from NCBI Gene.
Load or update information about genes from the NCBI Gene database.
Match design elements using the NCBI ID.
Deprecated.
see
CurationDetailsEvent — the needs-attention flag is being replaced
by open
GENERIC /
BATCH_INFO_NEEDED
tickets.Deprecated.
open a
GENERIC ticket
(or TicketType.BATCH_INFO_NEEDED
when the trigger is missing batch information) via
TicketService.openTicket(Contact, TicketType, String, Collection)
instead.Helper methods to get FTP connection.
Network / transfer-rate helpers.
Neuro Behavior Ontology — behavioural
processes and the paradigms used to elicit them.
Nextflow-backed scheduler.
Exception raised when no design elements (rows) are left after filtering the expression data matrix.
Exception raised when suitable factor is left for analysis.
Represents a gene that was tested, but the result wasn't significant.
An exception that can be raised when trying to create a describable entity or add one to a collection with a name
that is already being used.
Exception raised when retrieving a non-unique QT by name.
Deprecated.
resolve the open
QUALITY_REVIEW
ticket(s) via
TicketService.transition(Ticket, TicketState, Contact, String)
instead (target state
TicketState.RESOLVED).Single-cell data loader used when no data is available.
Customized to know how to deal with SecureValueObject, makes it easier to share code in SecurityService; and doesn't
use the default ObjectIdentityImpl.
Matrix that can hold any type of object
A strategy to determine if a given domain object is transient.
What an obsolete-term correction run did, or — in a dry run — would do.
Rewrites annotations that use an obsolete ontology term to the successor the ontology asserts.
Rewrite annotations using obsolete ontology terms to the successors their ontologies assert.
Async wrapper for
ObsoleteTermCorrectionService.apply(Collection, boolean, long, TimeUnit).One obsolete ontology term that Gemma's annotations still use, together with whatever the owning ontology says
should replace it.
Match design elements using the official symbol of a gene.
A term resolved from the EBI Ontology Lookup Service by its IRI.
Resolves an ontology term IRI against the EBI Ontology Lookup Service
(ols4).
Resolves a term IRI against the EBI OLS4 REST API (
GET {base}/api/terms?iri={iri}).Raised when the EBI Ontology Lookup Service cannot be reached or returns an unexpected response — a
transient condition, distinct from OLS successfully reporting that it has no term for an IRI (which is a
null return from OlsTermResolver.resolve(String)).The single place the ontology Lucene analysis recipe is defined.
Provides external links for ontology resources based on their URIs and other metadata.
Highlighter specialized for ontology terms.
Reads ontologies from OWL resources
Simple in-memory implementation of
OntologyProperty.Shared query shaping for the ontology Lucene indexes.
Writes the
AnnotationRelationBasis.ONTOLOGY rows of
ANNOTATION_RELATION: the relations our loaded ontologies already assert.Reads
OntologyTerm.getRestrictions() over the sources named in OntologyRelationSource
and writes what they assert into ANNOTATION_RELATION.Note: this only handle 'someof' and 'allof' restrictions, not cardinality.
Base class for exceptions raised by
OntologyService.findTerm(String, int) and others.Represents a search result from an ontology.
Full-text search over ontology resources backed by Jena's
jena-text (Lucene 9) integration over a TDB dataset.Lightweight result envelope.
Factory bean for baseCode's
OntologyService.Has a static method for finding out which ontologies are loaded into the system and a general purpose find method
that delegates to the many ontology services.
Resolves user-supplied text (a REST path segment, a CLI argument) to an
OntologyService.Module-extract a slim subset of an OWL ontology around a given seed of term URIs.
Summary returned from
OntologySlimExtractor.extract(File, Collection, File) for caller bookkeeping
(sidecar meta.json, log lines, regression tests).Sidecar metadata for an
*Ontology-slim.owl cache.Represents a statement triplet in an ontology.
A term's declared
in_taxon value: the NCBITaxon URI, its numeric id, and its label
when the loaded model carries one.A light-weight version of OntologyTerms.
Validates the ontology terms carried by a
Characteristic (or Statement)
against the terms Gemma actually knows about — the last checkpoint before a curator's or an agent's
annotation is persisted, so a hallucinated URI or a label that doesn't match its URI is caught here
rather than becoming stored data.Default
OntologyTermValidator: resolves each slot's URI against Gemma's loaded ontologies
(OntologyService.getTerm(String, long, TimeUnit)) first, then OLS, and compares labels.Utilities for working with ontologies.
One cross-reference an ontology declares from its own term to an identifier in another resource,
with the mapping qualifier kept.
How the foreign identifier stands to the term that declares the cross-reference, read from the
declaring term's point of view:
OntologyXref.Strength.NARROW means the foreign term is narrower than this
one, OntologyXref.Strength.BROAD that it is wider.The cross-references of an ontology, read backwards: foreign identifier → the terms that claim
it.
Container for details about a proposed outlier.
Methods to (attempt to) detect outliers in data sets.
Co-bean facade for the
SampleRemovalEvent /
SampleRemovalReversionEvent audit emissions carried out by
OutlierFlaggingServiceImpl.Implementation of
OutlierFlaggingAuditService.Service for removing sample(s) from an expression experiment.
Filter that removes outliers from expression data by masking them with
Double.NaN.Strategy for locating parent ACL identities.
Use domain-specific logic to resolve parent ACL identities.
Interface for classes that allow parsing of files and streams.
Utilities to be used by parsers and loaders.
An exception that indicate that the search query could not be parsed.
Represents a change in permissions of an
Auditable entity.Interface defining the ability to create domain objects in bulk or singly.
This interface contains a few extensions to the base
Persister interface to handle special cases with
ExpressionExperiment.A service that knows how to persist Gemma-domain objects.
Deprecated.
not needed
Deprecated.
as Person is deprecated
Deprecated.
as Person is deprecated
A very simple value object to represent a physical location
Curator requested cancellation of a batch (or of one job mid-batch — the
latter still emits a batch-level event so the timeline reads as one stream).
All child jobs in a batch reached a terminal state and the batch moved to
CLOSED.Abstract base for audit events that live on a
PipelineJobBatch's
audit trail.Curator submitted a new pipeline batch.
One pipeline run against one experiment, dispatched to an external scheduler.
One curator-initiated submission of a pipeline against a set of experiments.
Coarse batch lifecycle.
Curator-driven pipeline batch submissions.
One progress / state / log record reported by the scheduler-side pipeline.
A pipeline job reached terminal success on an experiment.
Abstraction over an external pipeline scheduler (Luigi or Nextflow today;
a different impl tomorrow if needed).
Wraps any scheduler-side failure (network, auth, HTTP non-2xx, malformed
response, etc.).
Fetch GEO "GPLXXX_family.soft.gz" files
General-purpose pointcuts to recognize CRUD operations etc.
Co-bean carrying the
PreboardedCreatedEvent emission for
PreboardedExperimentServiceImpl.createPreboarded(String, String, String).Implementation of
PreboardedAuditService: a thin co-bean that exists
so PreboardedAuditServiceImpl.recordPreboardedCreated(PreboardedExperiment, String) is invoked
through a Spring proxy and the @Audited aspect can intercept its
return path and emit the PreboardedCreatedEvent.Emitted by
POST /preboarded when a PreboardedExperiment
is created for a previously-unknown accession.Subclass of
Investigation representing a proposed-but-not-yet-loaded
dataset.Service surface for
PreboardedExperiment CRUD + accession resolution
+ promotion.Thrown by
PreboardedExperimentService.createPreboarded(String, String, String) when an
existing entity carries the same accession.Thrown by
PreboardedExperimentService.promote(ExpressionExperiment, PreboardedExperiment)
when the preboarded has already been promoted.Default
PreboardedExperimentService implementation.Emitted on
POST /preboarded/{id}/promote, when a
PreboardedExperiment is promoted to a loaded
ExpressionExperiment.Event emitted when the preferred cell type assignment is changed.
Event emitted when the preferred data for an experiment is changed.
Event emitted when the preferred raw data is changed.
Event emitted when the preferred set of single-cell vectors is changed.
Helper class for sample coexpression analysis.
A "processed expression data vector create" task
Allows us to catch preprocessing errors and handle them correctly.
Co-bean carrying the
processFor* diagnostic steps that
PreprocessorServiceImpl.processDiagnostics(ExpressionExperiment)
runs as part of the post-load preprocessing pipeline.Implementation of
PreprocessorHelperService: a thin co-bean that
exists so each processFor* method is invoked through a Spring proxy
and the AuditedOnError aspect can intercept its catch path.Encapsulates steps that are done to expression data sets after they are loaded and experimental design curated.
Command object for processing data vectors.
Matrix that holds primitives, with an available object representation of the values.
Primitive storage types for data vectors.
Read-only retrieval service for
PrincipalComponentAnalysis.Implementation of
PrincipalComponentAnalysisReadService.Only stored for some of the probes (e.g.
Holds parameters for how mapping should be done.
Provides methods for mapping sequences to genes and gene products.
Parse probes from a tabular file.
Represents the processed data that is used for actual analyses.
Co-bean facade for the
ProcessedVectorComputationEvent success-path
audit emission carried out by
ProcessedExpressionDataVectorServiceImpl.createProcessedDataVectors(ExpressionExperiment, boolean, boolean).Implementation of
ProcessedExpressionDataVectorAuditService: a thin
co-bean whose only purpose is to expose an Audited-annotated method
through a Spring proxy.Computation of the "processed" expression data with the ranking (by 'expression level') information filled in, for an
Expression Experiment
Structured payload for
ProcessedVectorComputationEvent writes.Report progress.
This appender is used by remote tasks to send progress notifications to the webapp.
Represents a context under which progress update logs are intercepted the
ProgressUpdateCallback is
invoked.Callback used to emit progress updates.
Represents a mapping between a query/criteria property and some original property space.
Utilities for dealing with
PropertyMapping.Deprecated.
This has been replaced with Spring-based configuration
SettingsConfig and usage of Value
to inject configurations.Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
Protocol.Read-only retrieval service for
Protocol.Implementation of
ProtocolReadService.One incoming claim about a publication: the reference, plus who is claiming it and on what basis.
An evidenced claim about whether a
BibliographicReference belongs to an
Investigation — who says so, on what basis, and whether they are affirming or denying it.Thrown when a writer tries to accept a publication that a higher authority has already ruled out
for that experiment.
DAO for
PublicationAssociation rows.Hibernate implementation of
PublicationAssociationDao.Reads and writes the evidenced claims behind an experiment's publication links.
Implementation of
PublicationAssociationService.Who asserted a
PublicationAssociation — the authority behind the claim, as distinct from the
evidence they gave for it.Whether a
PublicationAssociation affirms or denies the link between an experiment and a
publication.Wire form of a
PublicationAssociation: why a publication is (or is not) attached to a
dataset, and on whose authority.Search PubMed for terms, retrieve document records.
Manage the loading of large numbers of pubmed entries into the database.
Simple class to parse XML in the format defined by
ncbi.
Interface implemented by single-cell data transformation that require Python.
QR with pivoting.
Perform quantile normalization on a matrix, as described in:
Exception raised when an
ExpressionDataMatrix does not meet the expectations set by a given
QuantitationType.Base class for representing problematic
QuantitationType conversion.Perform various computations on ExpressionDataMatrices (usually in-place).
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
QuantitationType.An exception that wraps a
QuantitationTypeDetectionException.Has the unpleasant task of figuring out what the quantitation type should look like, given a description and name
string.
Read-only retrieval service for
QuantitationType.Implementation of
QuantitationTypeReadService.Utilities for working with
QuantitationTypes.Value object for the
QuantitationType.Utilities for Hibernate
Query.Defines a class that produces object that can be consumed by other classes.
Utilities for generating random
DifferentialExpressionAnalysis for testing purposes.Calculate rank statistics for arrays.
Deprecated.
Retrieve and unpack the raw data files for GEO series.
Data for one design element, across one or more bioassays, for a single quantitation type.
Provides methods that can be applied to both RawExpressionDataVector and ProcessedExpressionDataVector
Abstract record-based parser.
An association between a BioSequence and a GeneProduct based on external database identifiers.
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
ReferenceAssociation.Which end of a relation implies the other.
Persist objects like Gene2GOAssociation.
Whether a relation says something about the TERM, or records a parameter of an EXPERIMENT.
Event triggered when the release details of a
Versioned entity are
updated.Structured payload for
ReleaseDetailsUpdateEvent writes against
ExternalDatabase.A BioAssay-to-sample-name matcher that renames samples before matching them.
Parses a file that contains a mapping between old and new bioassay names.
Scan sequences for repeats using RepeatMasker.
Filter design elements with repetitive values across samples.
A "probe" (Affymetrix); for other types of arrays, there is no practical distinction between compositesequences and
reporters, and all analysis would take place at the level of CompositeSequences.
Convert
DataVector to different PrimitiveType.Used to indicate that the suitability status of an experiment is the default.
Cacheable, immutable snapshot of the per-result-set hit-list counts displayed by
DiffExResultSetSummaryValueObject.Indicate that the method should be retried on failure.
Provide logging when an operation has failed and is being retried.
Rounding of floating-point payloads on their way into JSON.
Applies
RoundingUtils.round(double) at serialization time, leaving the in-memory value exact.Remove rows from a matrix that are missing too many points.
Filter out rows that have "too many" missing values.
Only retain design elements that have a
BioSequence associated.The 'analysis' in the name is a bit of a stretch here, as this object servers purely as an aggregator
of all the sample coexpression matrices.
Manage the "sample correlation/coexpression" matrices.
Co-bean facade for the
SampleCorrelationAnalysisEvent success-path
audit emission carried out by
SampleCoexpressionAnalysisServiceImpl.compute(ExpressionExperiment, PreparedCoexMatrices).Implementation of
SampleCoexpressionAuditService: a thin co-bean
whose only purpose is to expose an Audited-annotated method through
a Spring proxy, so AuditedAspect fires, picks up the
SampleCorrelationAnalysisPayload argument, serialises it to JSON and
writes it to AUDIT_EVENT.PAYLOAD.Holds the data of the sample coexpression matrix
Exception raised in preprocessing when there is a problem with sample coexpression analysis.
Structured payload for
SampleCorrelationAnalysisEvent writes: the
row-and-column attrition of the expression matrix as each filter was
applied, plus the filter configuration that produced it.The settings the filter ran under.
One rung of the attrition funnel, in the order the filters ran.
Event used when a sample is removed from an experiment (typically due to QC concerns or when marked as an outlier).
Structured payload for
SampleRemovalEvent and
SampleRemovalReversionEvent.Indicates that samples that were previously removed have been "put back", e.g.
Convert
DataVector to different ScaleType.Generic interface for classes that extract scan dates from raw data files.
Nightly
@Scheduled task that runs Hibernate Search's MassIndexer for any
@Indexed entity class whose underlying rows have been touched since the
last successful reindex, or whose index no longer holds one document per row.Quartz scheduler configuration for Gemma, replacing the deprecated XML
applicationContext-schedule.xml.Opaque pointer to a scheduler-side job.
External scheduler that owns the runtime of a
PipelineJob.The outcome a curator or agent recorded for one
TicketTarget when screening it.Fetch the SRDF file
Exception raised by the
SearchService when the search could not be performed.How a
SearchResult matched the query — the structured discriminant that a
double score cannot carry on its own.Represents an individual search result.
Object to store search results of different classes in a similar way for displaying to user (ex: enables genes and
gene sets to be entries in the same combo box) object types handled are: Gene, GeneSet, GeneSetValueObject,
ExpressionExperiment and ExpressionExperimentSet SearchObject is also handled if the object it holds is of any of
those types for a gene or experiment, the memberIds field is a collection just containing the object's id.
This is a special kind of set designed for holding
SearchResult.Free-text search service: delegates per-result-type lookups to a
CompositeSearchSource
composed of all registered SearchSource beans (e.g.Configuration options for searching.
author: anton date: 18/03/13
Search source that provides
SearchResult from a search engine.Indicate that the search failed due to a
TimeoutException.Interface that indicates an entity can be secured.
A base service for securable entities.
A base service for securable entities with filtering and VO capabilities.
Indicates a securable that must have a parent that holds the permissons.
Interface to mark entities which are secured, and which should not have 'parent's, and therefore do not inherit
permissions from other objects.
Specialization of Spring task-running support so task threads have secure context (without using MODE_GLOBAL!).
A secure Quartz job bean that executes with a given security context.
Indicates that a value object represents a Securable so security filtering can be provided during reading.
Core Spring Security wiring for Gemma, replacing the legacy
applicationContext-security.xml.High-level methods for security-related manipulations.
Methods for changing security on objects, creating and modifying groups, checking security on objects.
Database-independent methods for ACLs
Fail-fast startup hook for unresolved sentinel (
XXXXXX) placeholder values shipped by
default.properties.Used to assign a bin to a chromosome location, identify bins for a range, or to generate SQL to add to a query on a
GoldenPath database.
Convenient methods for manipulating BioSequences and PhysicalLocations
Tools for writing biosequences to files so they can be analyzed by external tools, and then read back into Gemma.
An interface for data loaders that can load sequencing data.
Configuration for loading sequencing data.
Represents sequencing metadata for a
BioAssay.Load sequencing metadata from a TSV file.
Adapt a
SequencingMetadataFileDataLoader so that it can be used as a SingleCellDataLoader.Per-sample sequencing QC metrics for one experiment, read out of the RNA-Seq pipeline's MultiQC
report and joined to the experiment's
BioAssays.A metric column as MultiQC describes it.
One report row below the sample level — a sequencing run, or one mate of a paired run.
The metrics resolved for a single bioAssay.
Reads the per-sample sequencing QC metrics the RNA-Seq pipeline's MultiQC report carries, and
joins them to the experiment's bioAssays.
Streams
report_general_stats_data out of the MultiQC report and resolves its row keys to
bioAssays.Interface implemented by single-cell detector that can contextualize a sample within a series.
Performs conversion by identifier and collection of identifier for a
BaseReadOnlyService.Perform conversion to value object by entity, ID and collections of entities and IDs and also to entity by ID and
collection of IDs.
Phase 3 XML->Java migration: replaces the default-profile beans from
applicationContext-serviceBeans.xml — entityUrlBuilder, taskExecutor,
and expressionDataFileTaskExecutor.Deprecated.
This has been replaced with Spring-based configuration
SettingsConfig and usage of Value
to inject configurations.Beans declaration for making the settings available via the Spring Environment and placeholder substitution.
Class to manage the gfServer and run BLAT searches.
Utilities for inspecting
Sid instances.A simple strategy for matching BioAssay to sample name.
A simple design element mapper that simply uses the name as identifier.
A simple downloader for FTP and HTTP(s) URLs.
Load experiment from a flat file.
Convert a simple matrix and some meta-data into an ExpressionExperiment.
Represents the basic data to enter about an expression experiment when starting from a delimited file of data
Simple implementation of methods for fetching sequences from blast-formatted databases, using blastdbcmd (aka
fastacmd)
A simple retry implementation with exponential backoff.
An interface for work that can be retried.
Holds the state of a retry attempt.
A simple thread factory based on a preferably unique thread name prefix.
Indicates that we got batch information, but there was (as far as we can tell) just one batch.
Filter 10x Chromium Sequencing data to remove low-quality cells.
Configuration for aggregating single-cell data.
Exception raised when aggregation fails.
Structured payload for the
DataAddedEvent written at the end of
SingleCellExpressionExperimentAggregateServiceImpl#aggregateVectors.Per-assay metrics for an aggregated pseudo-bulk assay.
Brain + single-cell intersection matcher.
Special case of
DataAddedEvent for single-cell data.Represents a boxplot(s) of single-cell data.
Common interface for all single-cell data loaders.
Basic configuration for loading single-cell data.
Interface for configuring a single-cell data loader.
High-level service for loading single-cell data.
Pack an AnnData object by removing unnecessary zeroes.
Represents a single-cell data transformation.
Factory for obtaining
SingleCellDataTransformations.Transpose a single-cell dataset.
Supported single-cell data types.
Utilities for aggregating single-cell data vectors.
A
BulkExpressionDataMatrix that was derived from a SingleCellExpressionDataMatrix.Descriptive statistics for single-cell data.
Interface for single-cell data detectors from GEO.
Represents a single-cell dimension, holding shared information for a set of
SingleCellExpressionDataVector.Denormalized link row that records the
SingleCellDimension attached to a given
ExpressionExperiment / QuantitationType pair.DAO for the denormalized
SingleCellDimensionExperiment link table.Hibernate implementation of
SingleCellDimensionExperimentDao.Value object for a single-cell dimension.
Co-bean carrying the
ExperimentalDesignUpdatedEvent emissions for the
cell-type-factor create / remove flows in
SingleCellExpressionExperimentServiceImpl.Implementation of
SingleCellExperimentDesignAuditService: a thin
co-bean that exists so the @Audited aspect can intercept the
cell-type-factor create / remove audit emissions previously written
imperatively from private helpers in
SingleCellExpressionExperimentServiceImpl.Configuration for subsetting single-cell expression data in pseudo-bulks.
In a single-cell expression data matrix, each column represents a cell.
An expression data vector that contains data at the resolution of individual cells.
Utilities for working with
SingleCellExpressionDataVector.Co-bean facade for the
DataAddedEvent audit emission carried out at
the end of SingleCellExpressionExperimentAggregateServiceImpl.aggregateVectors(ExpressionExperiment, QuantitationType, List, CellLevelCharacteristics, ExperimentalFactor, Map, SingleCellAggregationConfig).Implementation of
SingleCellExpressionExperimentAggregateAuditService.Aggregate single-cell vectors.
Methods for aggregating single-cell expression data.
High-level service for creating subsets and aggregating single-cell expression experiments.
Co-bean facade for the
SingleCellSubSetsCreatedEvent audit emission
carried out at the end of
SingleCellExpressionExperimentSubSetServiceImpl.createSubSets(ExpressionExperiment, SingleCellDimension, CellLevelCharacteristics, ExperimentalFactor, Map, SingleCellExperimentSubSetsCreationConfig).Implementation of
SingleCellExpressionExperimentSubSetAuditService.Service to create single-cell expression experiment subsets.
Simple transformation with input and output files.
Utility class for handling masks in single-cell analysis.
Utilities for slicing single-cell data.
Heatmap that displays the sparsity of single-cell data.
Compute sparsity metrics for single-cell data.
Emitted when a collection of
ExpressionExperimentSubSet for holding aggregated single-cell data is created.Structured payload for
SingleCellSubSetsCreatedEvent writes.An analysis of a single experiment or subset.
Indicates that batches with only a single sample were found, which means we don't form batches at all.
Indiates that there was at least one batch with only one sample.
SVD for DoubleMatrix.
Log4j2 appender that report log events to a Slack channel.
Represents a slice of
List.Marker for an
OntologyService that can produce a corpus-tailored slim
variant of its source via OWL-API STAR module extraction.Methods for moving averages, loess
Represents a directed sort by a property.
Direction of the sort.
A sparse array backed by an
ArrayList.A sparse matrix that knows about row and column names.
A subclass of
List for sparsely stored lists.Utilities for dealing with sparse
ListRepresents a sparse AnnData matrix.
A sparse range array is a data structure that efficiently stores arrays of repeated elements by encoding their
starting offsets.
Assorted special functions, primarily concerning probability distributions.
TODO Document Me
Split an experiment into multiple experiments.
Methods to create Spring contexts for Gemma manually.
SQL helpers.
Parses SRA runinfo format.
Parses SRA XML format.
A special kind of characteristic that act as a statement.
Represents a VO for a
Statement, typically part of a FactorValueBasicValueObject.Implementation of the
CacheKeyLock interface that uses a static week map to store locks by key.Miscellaneous functions used for statistical analysis.
Utilities for working with
StopWatch.String distance metrics (Levenshtein edit distance and prefix/suffix weighted Hamming variants).
A NamedMatrix containing String objects.
Reader for
StringMatrix.String helpers (R-style name munging, common prefix/suffix, CSV split, etc.).
Various utilities for manipulating strings.
Payload handed to
PipelineScheduler.submit(SubmitRequest).Obtained from the TaskRunningService, can be used to monitor status.
Represents a subquery right-hand side of a
Filter.Mode to use when filtering with a subquery.
Targeted opt-out marker for ArchUnit production-code rules.
Exception raised when suspicious values are detected in an
ExpressionDataMatrix.Exception raised when the SVD of a given expression data matrix cannot be computed.
Exception raised if a SVD cannot be computed.
Store information about SVD of expression data and comparisons to factors/batch information.
Performs Singular value decomposition on experiment data to get eigengenes, and does comparison of those PCs to
factors recorded in the experimental design.
Perform SVD on expression data and store the results.
This does a very minimal parse of Swissprot records, just to get mRNAs associated with a single protein.
Repairs Adobe Symbol-font text that was mapped into the Unicode Private Use Area.
Functions for maintaining the database.
Write a set of single-cell vectors to a simple tabular format.
Emitted when a single experiment-level annotation (tag) is added to an
ExpressionExperiment via the
REST annotation write endpoints.Emitted when a single experiment-level annotation (tag) is removed from an
ExpressionExperiment via the
REST annotation write endpoints.This command class is used to allow communication of parameters for a task between a client and task running service,
which might be on a different computer.
Post-processor that wraps
TaskExecutor, AsyncTaskExecutor and SchedulingTaskExecutor with a
DelegatingSecurityContextTaskExecutor.Post-process
TaskExecutor, AsyncTaskExecutor and SchedulingTaskExecutor such that they
inherit the ThreadContext of their callers.author: anton
date: 10/02/13
author: anton date: 10/02/13
This class describes the result of long-running task.
Handles the execution of tasks in threads that can be checked by clients later.
Taxon information from NCBI comes as a tar.gz archive; only the names.dmp file is of interest.
Load taxa into the system.
Parse the "names.dmp" file from NCBI, ftp://ftp.ncbi.nih.gov/pub/taxonomy/.
Read-only retrieval service for
Taxon.Implementation of
TaxonReadService.A utility class for taxon.
An implementation based on Jena TDB.
Utilities for detecting 10x Cell Ranger data in GEO series and sample metadata.
A single in-place rewrite that
OntologyTermValidator applied to a slot of a
Characteristic while grounding it — the slot still passes (it
is not a TermViolation), but what was stored differs from what was submitted, so a client can echo
the correction back to its display.A single ontology-term grounding failure found by
OntologyTermValidator: one term slot
(category / value / predicate / object / …) whose URI does not resolve, or resolves to a term whose label
disagrees with the submitted one.JVM-wide one-shot guard for the integration-test database bootstrap.
This will exclude the component or configuration from component scanning.
Converts a text resource into a set of lines.
Cheesy v1 transcription-factor perturbation matcher.
Vocabulary for The Gemma Factor Value Ontology (TGFVO).
Consistent initialization logic for the entity graph.
Interface for populating the Log4j
ThreadContext with custom information.Utilities for creating
Thread objects.A curation ticket targeting one or more entities (initially
TicketTargetType.EXPRESSION_EXPERIMENT and
TicketTargetType.ARRAY_DESIGN).Emitted on the inherited audit trail when a
Ticket's
assignee is set or cleared.Persistence operations for
Ticket (Phase B-1 of
AUDIT_AS_WORKFLOW_RECCE.md).Hibernate implementation of
TicketDao.An append-only entry in a
Ticket's workflow event log.Value object projection of
TicketEvent for the REST surface
(Phase B-2 of AUDIT_AS_WORKFLOW_RECCE.md).Emitted on the inherited audit trail when a
Ticket's
non-workflow metadata changes — priority, dueDate, title, body, or mode.How a
Ticket advances between actions.Emitted on the inherited audit trail when a new
Ticket is created.Priority of a
Ticket.One row of
GET /tickets/search — enough of a ticket to pick it out of a list with
confidence, and nothing more.Service-layer API for the Phase B-1 Ticket layer
(AUDIT_AS_WORKFLOW_RECCE.md).
What
TicketService.addTarget(Ticket, TicketTargetType, Long, Contact) did: the saved ticket, and whether the target was new to it.Implementation of
TicketService.Lifecycle state of a
Ticket.Emitted on the inherited audit trail when a
Ticket
transitions to a different TicketState (OPEN /
IN_PROGRESS / RESOLVED / CANCELLED).One open ticket as it bears on ONE target — the per-ticket summary plus that target's own
TicketTargetStatus.A single target of a
Ticket.Per-target progress through a
Ticket's work.Emitted on the inherited audit trail when one of a
Ticket's
TicketTargets
changes status (NOT_DONE / UNDERWAY / DONE).Type of entity a
TicketTarget points at.Value object projection of
TicketTarget for the REST surface
(Phase B-2 of AUDIT_AS_WORKFLOW_RECCE.md).Domain category of a
Ticket.Value object projection of
Ticket for the REST surface (Phase B-2
of AUDIT_AS_WORKFLOW_RECCE.md).Remove rows that have a low diversity of values (equality judged based on tolerance set in
RowLevelFilter).Indicates that the data set had too few samples or probes to be analyzed (after filtering), and was skipped
Externalised bucket spec for
/stats/home treatmentSubcategories.What kind of judge produced an
AnnotationSet triage ruling.One judge's ruling on how much an
AnnotationSet matters.Deprecated.
see
CurationDetailsEvent — the trouble flag is being replaced by
open
QUALITY_REVIEW
tickets.Deprecated.
open a
QUALITY_REVIEW
ticket via
TicketService.openTicket(Contact, TicketType, String, Collection)
instead.Bunch of utilities for writing data to TSV.
Utility methods for taking an ExpressionExperiment and returning various types of ExpressionDataMatrices, such as the
processed data, preferred data, background, etc.
Computes a missing value matrix for ratiometric data sets.
Space task for computing two channel missing values.
Lightweight type-safe row-and-list transformer.
Indicates that FASTQ headers were present, but they were not usable for determining batches, typically because of
invalid formatting or lack of information.
A collection that is intentionally not initialized.
Exception raised when an operation is performed on an intentionally uninitialized collection.
A list that is intentionally not initialized.
A set that is intentionally not initialized.
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
ubic.gemma.model.common.measurement.Unit.Indicates that the associated Experiment is NOT suitable for differential expression analysis.
Exception raised when data in a given representation cannot be converted to another representation.
Exception raised when data from a given scale cannot be converted to another scale.
Exception raised when data from a given quantitation type cannot be converted to another quantitation type.
Used to indicate failure was due to the format being unusable, but the files are available.
Exception raised when a
ScaleType is not suitable for aggregating.An ontology service that loads an ontology from a URL.
TODO Document Me
A user of the software system, who is authenticated.
DAO Class: is able to create, update, remove, load, and find objects of type
ubic.gemma.model.common.auditAndSecurity.User.Implementation for Spring Security.
Extension of
UserDetailsManager.Exception raised when a user with a given username already exist.
Represents a group of users whom are conferred a set of
GrantedAuthority.An organized group of researchers with an identifiable leader and group members.
Overrides gsec's UserManager to provide Gemma-specific types.
Implementation for Spring Security, plus some other handy methods.
Simple username/password authenticator.
Read-only implementation of the
UserService read cluster.Override a few definition from gsec so that we can use Gemma-specific implementations safely.
Represents a value.
Annotate class representing value objects.
Commonly used values across Gemma.
Deprecated.
Nothing calls this any more (Paul, 2026-09-04): we do not map submitter text onto
preset ontology terms on import.
Tackles the problem of concatenating DesignElementDataVectors for a single experiment.
Processed expression data vectors were reordered to align with the experimental design layout.
Interface implemented by entities that are externally versioned.
Base class for events relating to a
Versioned entity.Micrometer binder for virtual-thread-per-task executors (JDK 21+).
A value object to hold onto the 'new' objects.
Creates reports that can be shown on the web pages or in social media feeds.
Service to collect data on objects that are new in the system.
Withhold a property from the RESTful API, and say why.
Lightweight projection used by
GET /workflow/queue.Service surface for the 8-state workflow lifecycle
(HANDOFF_WORKFLOW_STATE_STORAGE.md).
Default
WorkflowService implementation.Eight-state workflow lifecycle for experiments (and forthcoming
PreboardedExperiments).Emitted on every successful workflow-state transition of an
Investigation (currently:
ExpressionExperiment; a
forthcoming PreboardedExperiment subclass will join the same
stream).Return value of
WorkflowService.advance(Investigation, WorkflowState, String, Long).Handy methods for dealing with XML.
Resolves Hibernate XSD schemas from the classpath.
Remove rows that have a variance of zero (within a small constant)