All Classes Interface Summary Class Summary Enum Summary Exception Summary Error Summary Annotation Types Summary
| Class |
Description |
| aa |
|
| aaa |
|
| AAindexFactory |
Factory class to get Providers for substitution matrices the are provided by the AAINDEX database.
|
| AAIndexFileParser |
|
| AAIndexProvider |
|
| ABITrace |
Title: ABITrace
|
| ABITracerCompoundSet |
|
| AboutDialog |
|
| AbstractAlignmentJmol |
An Abstract Class to generalize the visualization of AFP and
MultipleAlignment structure alignments in Jmol.
|
| AbstractAnnotation |
A utility class to ease the problem of implementing an Annotation to that of
providing an apropreate implementation of Map.
|
| AbstractBean |
a generic class that implements the toString method for a bean
|
| AbstractCompound |
The details of a Compound
|
| AbstractCompoundSet<C extends Compound> |
|
| AbstractCompoundTranslator<F extends Compound,T extends Compound> |
|
| AbstractFeature<S extends AbstractSequence<C>,C extends Compound> |
A feature is currently any descriptive item that can be associated with a sequence position(s)
A feature has a type and a source which is currently a string to allow flexibility for the user
Ideally well defined features should have a class to describe attributes of that feature
|
| AbstractLocation |
Base abstraction of a location which encodes for the majority of important
features about a location such as the start, end and strand
|
| AbstractMatrixAligner<S extends Sequence<C>,C extends Compound> |
Implements common code for an Aligner which builds a score matrix during computation. |
| AbstractNucleotideCompoundSet<C extends NucleotideCompound> |
|
| AbstractPairwiseSequenceAligner<S extends Sequence<C>,C extends Compound> |
|
| AbstractProfileProfileAligner<S extends Sequence<C>,C extends Compound> |
|
| AbstractReference |
|
| AbstractRenderer |
|
| AbstractScorer |
Implements common code for algorithms which compute a score.
|
| AbstractScoresCache |
Abstact implementation of the ScoresCache with the shared code used
in all objects with a variables cache. |
| AbstractSequence<C extends Compound> |
The base class for DNA, RNA and Protein sequences.
|
| AbstractSequence.AnnotationType |
|
| AbstractStructureAlignment |
|
| AbstractTerm |
Abstract implementation of term
This provides basic change-forwarding functionality from
the annotation and ontology properties.
|
| AbstractUserArgumentProcessor |
Base class for a new structure alignment CLI.
|
| AccesionedLocation |
A location which is bound to an AccessionID.
|
| Accession |
|
| Accession.Source |
|
| Accessioned |
Indicates an entity is accessioned
|
| AccessionID |
Used in Sequences as the unique indentifier.
|
| AccessionParser |
|
| AdjactantDirectedBinaryDomainCombination |
|
| AdjactantDirectedCombinableDomains |
|
| AFP |
A class to represent a FATCAT AFP
|
| AFPAlignmentDisplay |
|
| AFPCalculator |
a class that performs calculations on AFPCHains
|
| AFPChain |
A bean to contain the core of a structure alignment.
|
| AFPChainCoordManager |
|
| AFPChainer |
a class to chain AFPs to an alignment
|
| AFPChainFlipper |
|
| AFPChainScorer |
|
| AfpChainWriter |
A class to convert the data in an AfpChain object to various String outputs.
|
| AFPChainXMLConverter |
|
| AFPChainXMLParser |
|
| AFPFromFasta |
|
| AFPOptimizer |
|
| AFPPostProcessor |
does post processing after alignment chaingin
|
| AFPTwister |
|
| AgScore |
|
| AligMatEl |
|
| Alignable |
|
| AlignedPosition |
|
| AlignedSequence<S extends Sequence<C>,C extends Compound> |
Defines a data structure for a Sequence within an alignment. |
| AlignedSequence.Step |
Defines an alignment step in order to pass alignment information from an Aligner to a constructor.
|
| Aligner<S extends Sequence<C>,C extends Compound> |
Defines an algorithm which computes an alignment Profile from a list of Sequences. |
| AlignerHelper |
Static utility to construct alignment routines from a common library of methods.
|
| AlignerHelper.Anchor |
Compounds in query and target sequences that must align
|
| AlignerHelper.Anchor.QueryIndexComparator |
|
| AlignerHelper.Cut |
Defines a 'cut' row for divide-and-conquer alignment in which a new anchor is found.
|
| AlignerHelper.Last |
Define a traceback pointer for the three edit operations: substitution (match/replacement of a query compound
with a target compound), deletion (removal of a query compound leaving a gap in the target sequence), and
insertion (addition of a target compound opening a gap in the query sequence).
|
| AlignerHelper.Subproblem |
Alignment subproblem.
|
| AlignmentCalc |
A class that obtains two structures via DAS and aligns them
This is done in a separate thread.
|
| AlignmentCalc |
A class that obtains two structures via DAS and aligns them
This is done in a separate thread.
|
| AlignmentCalcDB |
|
| AlignmentCalculationRunnable |
|
| AlignmentGui |
A JFrame that allows to trigger a pairwise structure alignment,
either from files in a directory,
or after manual upload.
|
| AlignmentGuiDemo |
Get an instance of the two alignment GUIs.
|
| AlignmentPositionListener |
|
| AlignmentProgressListener |
|
| AlignmentProgressListener |
A class to listen to progress of the structure alignment calculations
|
| AlignmentResult |
A class to track the alignment results in a flat file
|
| Alignments |
Static utility to easily run alignment routines.
|
| Alignments.PairInProfileScorerType |
List of implemented sequence pair in a profile scoring routines.
|
| Alignments.PairwiseSequenceAlignerType |
List of implemented pairwise sequence alignment routines.
|
| Alignments.PairwiseSequenceScorerType |
List of implemented pairwise sequence scoring routines.
|
| Alignments.ProfileProfileAlignerType |
List of implemented profile-profile alignment routines.
|
| Alignments.RefinerType |
List of implemented profile refinement routines.
|
| AlignmentTextPanel |
|
| AlignmentTools |
Methods for analyzing and manipulating AFPChains and for
other pairwise alignment utilities.
|
| AlignmentTools.IdentityMap<K> |
A Map can be viewed as a function from K to V.
|
| AligNPE |
|
| AlignUtils |
Low level helper methods for CE and FATCAT algorithms.
|
| AligPanel |
A JPanel that can display an AFPChain in a nice way and interact with Jmol.
|
| AligPanelMouseMotionListener |
|
| AligUIManager |
|
| AllChemCompProvider |
A ChemComp provider that downloads and caches the components.cif file from the wwPDB site.
|
| AlreadyExistsException |
Thrown to indicate that a term or triple can't be added to an ontology
because it is already present.
|
| AltAligComparator |
a comparator to sort AlternativeAlignments based on their number of equivalent residues
and RMSD.
|
| AlternativeAlignment |
Implements a class which handles one possible (alternative) solution.
|
| AlternativeAlignmentFrame |
a frame showing the alternative alignments, which are the result of a structure superimposition
|
| AmbiguityDNACompoundSet |
|
| AmbiguityDNARNAHybridCompoundSet |
Ambiguity set for hybrid DNA/RNA sequences.
|
| AmbiguityRNACompoundSet |
|
| AminoAcid |
A Group that represents an AminoAcid. |
| AminoAcidComposition |
|
| AminoAcidCompositionTable |
|
| AminoAcidCompound |
Used to describe an Amino Acid.
|
| AminoAcidCompoundSet |
Set of proteinogenic amino acids.
|
| AminoAcidImpl |
AminoAcid inherits most from Hetatom.
|
| AminoAcidProperties |
This class provides the protein properties at the level of individual amino acids.
|
| AncestralTaxonomyInference |
|
| AncestralTaxonomyInferenceException |
|
| AncestralTaxonomyInferrer |
|
| AnchoredPairwiseSequenceAligner<S extends Sequence<C>,C extends Compound> |
This algorithm uses a divide-and-conquer approach to find optimal pairwise global sequence alignments (from the
first until the last Compound of each Sequence) with the restriction that any alignment produced
will connect the query sequence to the target sequence at the anchors. |
| AngleOrderDetectorPlus |
Guesses an order of rotational symmetry from the angle.
|
| AngleOutlier |
Java class for anonymous complex type.
|
| Annotatable |
Indicates that an object has an associated annotation.
|
| Annotation |
Arbitrary annotation associated with one or more objects.
|
| Annotation |
|
| AnnotationParser |
|
| annotator |
|
| App |
Hello world!
|
| App |
Hello world!
|
| AptxUtil |
|
| AptxUtil.GraphicsExportType |
|
| Archaeopteryx |
|
| ArchaeopteryxA |
|
| ArchaeopteryxE |
|
| ArrayListProxySequenceReader<C extends Compound> |
|
| ArrayListSequenceReader<C extends Compound> |
Stores a Sequence as a collection of compounds in an ArrayList
|
| AsaCalculator |
Class to calculate Accessible Surface Areas based on
the rolling ball algorithm by Shrake and Rupley.
|
| AsciiHistogram |
|
| AssertionFailure |
An unchecked exception representing an Assertion failure.
|
| AssignmentXMLSerializer |
|
| Astral |
Provides programmatic access to ASTRAL representative sets.
|
| Astral.AstralSet |
An ASTRAL sequence-identity cutoff with an identifier such as:
|
| Atom |
A simple interface for an Atom.
|
| AtomCache |
A utility class that provides easy access to Structure objects.
|
| AtomContact |
A pair of atoms that are in contact
|
| AtomContactSet |
A set of atom-atom contacts to hold the results of intra and inter-chain contact calculations
|
| AtomIdentifier |
|
| AtomImpl |
Implementation of an Atom of a PDB file.
|
| AtomInfo |
This class uniquely describes an atom
|
| AtomInfoParser |
|
| AtomIterator |
an iterator over all atoms of a structure / group.
|
| AtomPositionMap |
|
| AtomPositionMap.GroupMatcher |
Used as a Predicate to indicate whether a particular Atom should be mapped
|
| AtomSite |
|
| AtomSites |
A class containing the _atom_sites data.
|
| AuditAuthor |
|
| AugmentedResidueRange |
Created by douglas on 1/23/15.
|
| Author |
Describes author attributes for author information in a PDB file.
|
| AutoSuggestProvider |
A class that provides auto-completion suggestions for JAutoSuggest
|
| AxisAligner |
|
| BasePairParameters |
This module calculates the el Hassan-Calladine Base Pairing and Base-pair Step Parameters for any nucleic
acid containing structure that has the information about the core base-pair rings.
|
| BasicBinaryDomainCombination |
|
| BasicCharacterStateMatrix<S> |
|
| BasicCombinableDomains |
|
| BasicDescriptiveStatistics |
|
| BasicDomain |
|
| BasicDomainSimilarityCalculator |
|
| BasicExternalNodeBasedCoverageExtender |
|
| BasicGenomeWideCombinableDomains |
|
| BasicGoRelationship |
|
| BasicGoSubset |
|
| BasicGoTerm |
|
| BasicGoXRef |
|
| BasicMsa |
|
| BasicPhylogeniesWebserviceClient |
|
| BasicProtein |
|
| BasicSequence<C extends Compound> |
Bare bones version of the Sequence object to be used sparingly.
|
| BasicSequence |
|
| BasicSpecies |
|
| BasicSymmetricalDistanceMatrix |
|
| BasicTable<E> |
|
| BasicTableParser |
|
| BcifFileReader |
Parse binary Cif files and provide capabilities to store them locally.
|
| BerkeleyScopInstallation |
|
| BetaBridge |
Container that represents a beta Bridge between two residues.
|
| BinaryCharacters |
|
| BinaryCharactersParser |
|
| BinaryDomainCombination |
|
| BinaryDomainCombination.DomainCombinationType |
|
| BinaryDomainCombination.OutputFormat |
|
| BioAssemblyIdentifier |
|
| BioAssemblyInfo |
Representation of a Biological Assembly annotation as provided by the PDB.
|
| BioAssemblyTools |
|
| BioJavaAADemo |
Created by andreas on 8/9/14.
|
| BiojavaJmol |
A class that provides a simple GUI for Jmol
|
| BioJavaStructureAlignment |
Wrapper for the BioJava Structure Alignment Implementation
|
| BiologicalAssemblyBuilder |
Reconstructs the quaternary structure of a protein from an asymmetric unit
|
| BiologicalAssemblyTransformation |
The transformation needed for generation of biological assemblies
from the contents of a PDB/mmCIF file.
|
| BitSequenceReader<C extends Compound> |
An implementation of the popular bit encodings.
|
| BitSequenceReader.BitArrayWorker<C extends Compound> |
The logic of working with a bit has been separated out into this class
to help developers create the bit data structures without having to
put the code into an intermediate format and to also use the format
without the need to copy this code.
|
| Blast |
|
| BlastAlignmentParameterEnum |
Alignment request parameters accepted by QBlast service.
Not all are mandatory.
|
| BlastClustReader |
|
| BlastHitBuilder |
Designed by Paolo Pavan.
|
| BlastHomologyHits |
|
| BlastHspBuilder |
Designed by Paolo Pavan.
|
| BlastJob |
Information about QBlast search job
|
| BlastMatrixEnum |
Enum representing matrices supported by QBlast
|
| BlastOutputAlignmentFormatEnum |
Enum representing available output alignment types.
|
| BlastOutputFormatEnum |
Enum representing available output formats.
|
| BlastOutputParameterEnum |
Output parameters accepted by QBlast service.
|
| BlastProgramEnum |
Enum representing available blast programs.
|
| BlastResult |
This class models a Blast/Blast plus result.
|
| BlastResultBuilder |
Designed by Paolo Pavan.
|
| BlastTabularParser |
Designed by Paolo Pavan.
|
| BlastXMLParser |
Re-designed by Paolo Pavan on the footprint of:
org.biojava.nbio.genome.query.BlastXMLQuery by Scooter Willis
You may want to find my contacts on Github and LinkedIn for code info
or discuss major changes.
|
| BlastXMLQuery |
|
| Block |
A Block is a Data Structure that stores aligned positions of a
MultipleAlignment with the condition that residues are in a
sequential order. |
| BlockImpl |
General implementation of a Block that supports any type of
sequential alignment with gaps. |
| BlockSet |
A BlockSet is a Data Structure to store a flexible alignment part of a
multiple alignment.
|
| BlockSetImpl |
A general implementation of a BlockSet to store a flexible part of a multiple
alignment.
|
| Bond |
A simple bond -- it stores information about two atoms as well as information
about its bond order.
|
| BondImpl |
A simple bond -- it stores information about two atoms as well as information
about its bond order.
|
| BondMaker |
Adds polymer bonds for peptides and nucleotides based on distance cutoffs and
intra-group (residue) bonds based on data from the Chemical Component Dictionary
to the Structure object.
|
| BondOutlier |
Java class for anonymous complex type.
|
| BondType |
Work in progress - NOT final!
|
| BootstrapResampler |
|
| BoundingBox |
A bounding box for short cutting some geometrical calculations.
|
| BranchColor |
|
| BranchCountingBasedScoringMethod |
|
| BranchData |
|
| BranchLengthBasedScoringMethod |
|
| BranchWidth |
|
| BranchWidthParser |
|
| BravaisLattice |
An enum to represent the 7 Bravais lattices
|
| BridgeType |
A bridge is formed by two non-overlapping stretches of three residues each
(i-1,i,i+1) and (j-1,j,j+1), where i
|
| BrowserOpener |
|
| BufferedReaderBytesRead |
Need to keep track of actual bytes read and take advantage of buffered reader
performance.
|
| C2RotationSolver |
|
| CachedRemoteScopInstallation |
An extension of the RemoteScopInstallation that caches some of the data locally.
|
| CAConverter |
Converts full atom representations to Calpha only ones.
|
| Calc |
Utility operations on Atoms, AminoAcids, Matrices, Point3d, etc.
|
| CalcPoint |
Utility operations on Point3d.
|
| CallablePairwiseSequenceAligner<S extends Sequence<C>,C extends Compound> |
|
| CallablePairwiseSequenceScorer<S extends Sequence<C>,C extends Compound> |
|
| CallableProfileProfileAligner<S extends Sequence<C>,C extends Compound> |
|
| CallableStructureAlignment |
|
| CartesianProduct<T> |
A cartesian product between two lists A and B is the set of all ordered pairs
of the elements of both sets.
|
| CaseFreeAminoAcidCompoundSet |
Set of proteinogenic amino acids.
|
| CaseInsensitiveCompound |
Attempts to wrap compounds so it is possible to view them
in a case insensitive manner
|
| CasePreservingProteinSequenceCreator |
A sequence creator which preserves the case of its input string in
the user collection of the returned ProteinSequence.
|
| CathCategory |
The categories found within CATH.
|
| CathDatabase |
General API for interacting with CATH.
|
| CathDomain |
A class which represents a single CATH domain.
|
| CathFactory |
|
| CathFragment |
|
| CathInstallation |
|
| CathNode |
Represents a node in the CATH hierarchy.
|
| CathSegment |
|
| CDSComparator |
|
| CDSSequence |
Represents a exon or coding sequence in a gene.
|
| CECalculator |
This is based on the original Combinatorial Extension (CE) source code from 2003 or 2004 (CE version 2.3),
as has been originally developed by I.
|
| CeCalculatorEnhanced |
This is based on the original Combinatorial Extension (CE) source code from 2003 or 2004 (CE version 2.3),
as has been originally developed by I.
|
| CeCPMain |
A wrapper for CeMain which sets default parameters to be appropriate for finding
circular permutations. |
| CeCPMain.CPRange |
Tiny wrapper for the disallowed regions of an alignment.
|
| CECPParameters |
|
| CECPParameters.DuplicationHint |
|
| CeCPUserArgumentProcessor |
|
| Cell |
|
| CeMain |
The main class of the Java implementation of the Combinatorial Extension Algorithm (CE),
as has been originally developed by I.
|
| CensorStatus |
|
| CensorStatusSelect |
|
| CeParameters |
Contains the parameters that can be sent to CE
|
| CeParameters.ScoringStrategy |
|
| CeSideChainMain |
|
| CeSideChainUserArgumentProcessor |
|
| CeSymm |
Identify the symmetries in a structure by running an alignment of the
structure against itself disabling the diagonal of the identity alignment.
|
| CeSymmIterative |
Iterative version of CeSymm that aims at identifying all symmetry axis of a
structure.
|
| CESymmParameters |
Provides parameters to CeSymm. |
| CESymmParameters.OrderDetectorMethod |
|
| CESymmParameters.RefineMethod |
|
| CESymmParameters.SymmetryType |
The internal symmetry detection can be divided into two types: CLOSE:
includes the circular and dihedral symmetries, and OPEN: includes the
helical and protein repeats symmetries.
|
| CeSymmResult |
This Class stores all the relevant information of an internal symmetry result
obtained with CeSymm.
|
| CeUserArgumentProcessor |
process the arguments from command line
|
| CeUserArgumentProcessor.CeStartupParams |
|
| Chain |
Defines the interface for a Chain.
|
| ChainImpl |
A Chain in a PDB file.
|
| ChainSignature |
|
| ChangeValue |
|
| CharacterStateMatrix<S> |
|
| CharacterStateMatrix.BinaryStates |
It is crucial that the order
ABSENT, UNKNOWN, PRESENT not be changes since
this determines the sort order.
|
| CharacterStateMatrix.Format |
|
| CharacterStateMatrix.GainLossStates |
|
| CharacterStateMatrix.NucleotideStates |
|
| ChargeAdder |
A class to add appropriate charge information to a structure.
|
| Chart |
|
| check_fasta |
|
| ChemComp |
A definition for a Chemical Component, as maintained by the wwPDB.
|
| ChemCompAtom |
stores these fields:
_chem_comp_atom.comp_id
_chem_comp_atom.atom_id
_chem_comp_atom.alt_atom_id
_chem_comp_atom.type_symbol
_chem_comp_atom.charge
_chem_comp_atom.pdbx_align
_chem_comp_atom.pdbx_aromatic_flag
_chem_comp_atom.pdbx_leaving_atom_flag
_chem_comp_atom.pdbx_stereo_config
_chem_comp_atom.model_Cartn_x
_chem_comp_atom.model_Cartn_y
_chem_comp_atom.model_Cartn_z
_chem_comp_atom.pdbx_model_Cartn_x_ideal
_chem_comp_atom.pdbx_model_Cartn_y_ideal
_chem_comp_atom.pdbx_model_Cartn_z_ideal
_chem_comp_atom.pdbx_component_comp_id
_chem_comp_atom.pdbx_residue_numbering
_chem_comp_atom.pdbx_component_atom_id
_chem_comp_atom.pdbx_polymer_type
_chem_comp_atom.pdbx_ref_id
_chem_comp_atom.pdbx_component_id
_chem_comp_atom.pdbx_ordinal
|
| ChemCompBond |
|
| ChemCompConsumer |
|
| ChemCompDescriptor |
Container object for _pdbx_chem_comp_descriptor
|
| ChemCompDistribution |
|
| ChemCompGroupFactory |
|
| ChemCompProvider |
Interface that is implemented by all classes that can provide ChemComp definitions. |
| ChemCompTools |
Some tools for working with chemical compounds.
|
| ChemicalComponentDictionary |
A representation of the Chemical Component Dictionary.
|
| ChiSq |
|
| Cholesky2 |
|
| CholeskyDecomposition |
Cholesky Decomposition.
|
| ChooseDirAction |
Ask the user to provide a directory containting PDB files.
|
| ChromosomeMappingTools |
A class that can map chromosomal positions to mRNA (coding sequence) positions.
|
| ChromosomeSequence |
A ChromosomeSequence is a DNASequence but keeps track of geneSequences
|
| ChromPos |
Created by ap3 on 27/10/2014.
|
| Chsolve2 |
|
| CifFileConverter |
Convert BioJava structures to CifFiles and vice versa.
|
| CifFileReader |
Parse text Cif files and provide capabilities to store them locally.
|
| CIFLabel |
Annotation indicating that a specific field of a bean should be mapped to
a different label
|
| Clash |
Java class for anonymous complex type.
|
| ClasspathResource |
This object represents a classpath resource on the local system.
|
| ClinicalMetaDataOutcome |
|
| CliTools |
Utilities for autoconfiguring javabeans based on command line arguments.
|
| ClustalOmega |
|
| ClusterAltAligs |
A class that clusters alternative alignments according to their
similarity.
|
| ClusterDomains |
|
| CodonCompound |
Define a codon
|
| CollectionTools |
Utilities for working with collections.
|
| ColorBrewer |
The data values were extracted from the RColorBrewer R package.
|
| ColorConverter |
|
| ColorInterpolator |
|
| ColorPaletteChooserDialog |
A ColorPaletteChooserDialog shows a dialog window for selecting a color palette.
|
| ColorPanelSelectionModel |
|
| ColorParser |
|
| ColorUtils |
|
| CombinableDomains |
|
| CombinationsBasedPairwiseDomainSimilarity |
|
| CombinationsBasedPairwiseDomainSimilarityCalculator |
|
| CommandLineArguments |
|
| CommandProcessBuilder |
|
| CommandPrompt |
|
| CommandPrompt.PropertyName |
|
| CompactCharSequence |
http://www.javamex.com/tutorials/memory/ascii_charsequence.shtml
|
| Comparison |
This class provides static methods for the calculation of the percentage of
identity between two aligned sequences.
|
| ComplementCompound |
|
| ComplementSequenceView<C extends ComplementCompound> |
For a given sequence this class will create a view over the top of it
and for every request the code will return the complement of the underlying
base e.g.
|
| Component |
contains information about a certain Component.
|
| ComponentXMLConverter |
|
| Compound |
|
| CompoundNotFoundException |
|
| CompoundSet<C extends Compound> |
|
| CompoundTranslator<F extends Compound,T extends Compound> |
|
| ConcurrencyTools |
Static utility to easily share a thread pool for concurrent/parallel/lazy execution.
|
| confadd |
|
| Confidence |
|
| ConfidenceAssessor |
|
| ConfidenceParser |
|
| ConfigPDBInstallPanel |
|
| ConfigStrucAligParams |
|
| Configuration |
|
| Configuration.EXT_NODE_DATA_RETURN_ON |
|
| Configuration.UI |
|
| ConfigurationException |
|
| ConfigXMLHandler |
XML content handler for serialisation of RegistryConfiguration class
|
| Constants |
|
| Constraints |
This class is used to support the implementation of properties stated in IPeptideProperties.
|
| Contact |
A simple class to store contacts in the form of pairs of indices and a distance associated to them.
|
| ContinuousColorMapper |
Provides a mapping between real numbers and Colors.
|
| ContinuousColorMapperTransform |
Maps colors by performing a transform of the input data and then passing
the transformed value to a ContinuousColorMapper for rendering.
|
| Convert2Charge |
|
| Convert2Hydrophobicity |
|
| Convert2NormalizedVanDerWaalsVolume |
|
| Convert2Polarity |
|
| Convert2Polarizability |
|
| Convert2SecondaryStructure |
|
| Convert2SolventAccessibility |
|
| Convertor |
|
| CookBook |
|
| CookbookMSA |
|
| CoordManager |
a class that manages the conversion of sequence coordinate system to
JPanel drawing coordinates
|
| core_chars |
|
| CoreSuperimposer |
Superimposes the core aligned residues of every structure in a
MultipleAlignment onto a reference structure. |
| count_support |
|
| CountProgressListener |
|
| CountsBasedPairwiseDomainSimilarity |
|
| Coverage |
|
| CoverageCalculationMethod |
|
| CoverageCalculationOptions |
|
| CoverageCalculator |
|
| CoverageExtender |
|
| CoxCC |
|
| CoxCoefficient |
|
| CoxComparatorInterface |
|
| CoxHelper |
The CoxHelper class is provided to start with a tab delimited file in a similar process in R and return the results as a CoxInfo class.
|
| CoxInfo |
Holds the results of a cox analysis where calling dump(), toString() will give an output similar to R
|
| CoxMart |
|
| CoxMethod |
|
| CoxR |
This is a port of the R survival code used for doing Cox Regression.
|
| CoxScore |
|
| CoxVariables |
|
| CoxVariablesOverallModelFitComparator |
|
| CoxVariablesVariableComparator |
|
| CRC64Checksum |
Utility class that calculates a CRC64 checksum on a stream of bytes.
|
| CrystalBuilder |
A class containing methods to find interfaces in a given crystallographic Structure by
reconstructing the crystal lattice through application of symmetry operators
|
| CrystalCell |
A crystal cell's parameters.
|
| CrystalTransform |
Representation of a transformation in a crystal:
- a transformation id (each of the transformations in a space group, 0 to m)
- a crystal translation
The transformation matrix in crystal basis is stored, representing the basic
transformation together with the crystal translation.
|
| Cut |
|
| CutDomain |
|
| CutSites |
|
| CutValues |
|
| Cytoband |
|
| CytobandParser |
Parses the cytoband (karyotype) file from UCSC.
|
| DatabasePDBremark |
|
| DatabasePDBrev |
|
| DatabasePdbrevRecord |
|
| DatabaseReferenceInterface |
If a SequenceProxyReader implements this interface then that external source
has a list of cross reference id(s)
|
| Dataset |
Phosphosite is available under the PhosphoSitePlus® is licensed under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License and is freely available for non-commercial purposes from
http://www.phosphosite.org/staticDownloads.do
Please acknowledge PhosphoSitePlus®, www.phosphosite.org" at appropriate locations.
|
| DataSource |
GenBank gi|gi-number|gb|accession|locus
ENA Data Library gi|gi-number|emb|accession|locus
DDBJ, DNA Database of Japan gi|gi-number|dbj|accession|locus
NBRF PIR pir||entry
Protein Research Foundation prf||name
SWISS-PROT UNIPROT sp|accession|name
Brookhaven Protein Data Bank (1) pdb|entry|chain
Brookhaven Protein Data Bank (2) entry:chain|PDBID|CHAIN|SEQUENCE
Patents pat|country|number
GenInfo Backbone Id bbs|number
General database identifier gnl|database|identifier
NCBI Reference Sequence ref|accession|locus
Local Sequence identifier lcl|identifier
|
| Date |
|
| DateParser |
|
| DBRef |
A class to represent database cross references.
|
| DBReferenceInfo |
If you have a uniprot ID then it is possible to get a collection
of other id(s) that the protein is known by.
|
| DBResultTable |
|
| DBSearchGUI |
|
| decorator |
|
| decoratorX |
|
| DefaultAAIndexProvider |
The default provider for AAINDEX loads substitution matrices from the AAINDEX file in the resources directory
|
| DefaultAutoSuggestProvider |
|
| DefaultMatrixMapper |
Color Mapper which mimics the default coloring of JMatrixPanel pixels.
|
| DefaultOps |
Default implementation of OntologyOps.
|
| DeleteableMsa |
|
| DemoAlignmentFromFasta |
|
| DemoAlignProteins |
|
| DemoAsa |
|
| DemoAtomCache |
Example of how to load PDB files using the AtomCache class.
|
| DemoBerkeleyScop |
A demo for how to use the Berkeley version of SCOP instead of the default UK-SCOP
|
| DemoBioAssemblies |
|
| DemoCATH |
An example for how to access CATH data.
|
| DemoCE |
Example of how to run a structure alignment using the CE algorithm.
|
| DemoCeSymm |
Quick demo of how to call CE-Symm programmatically.
|
| DemoChangeChemCompProvider |
This demo shows how to use an alternative ChemCompProvider.
|
| DemoCommandLineStartup |
|
| DemoContacts |
|
| DemoCrystalInterfaces |
|
| DemoDistanceTree |
This demo contains the CookBook example to create a phylogenetic tree from a
multiple sequence alignment (MSA).
|
| DemoDomainsplit |
|
| DemoFATCAT |
|
| DemoLoadSecStruc |
Demonstration of how to load a Structure with the SS information, either from
the PDB file annotation (Author's assignment) or from the DSSP file in the
PDB servers (DSSP assignment).
|
| DemoLoadStructure |
Example for how to load protein structures (from PDB files).
|
| DemoLoadSubstMax |
|
| DemoMMCIFReader |
An example of how to read MMcif files
|
| DemoMmcifToPdbConverter |
An example of how to convert mmCIF file to PDB file
|
| DemoMmtfReader |
Class to show how to read a Biojava structure using MMTF
|
| DemoMmtfWriter |
|
| DemoMultipleMC |
Demo for running the MultipleMC Algorithm on a protein family.
|
| DemoNWALignment |
|
| DemoQsAlign |
Demo on how to use programatically QsAlign for the alignment of
quaternary structures. |
| DemoQuatSymmetryJmol |
|
| DemoRotationAxis |
A demo for how to use RotationAxis to display the rotation for an
alignment. |
| DemoSCOP |
A class demonstrating the use of the SCOP parsing tools
|
| DemoSecStrucCalc |
Demonstration on how to use the Secondary Structure Prediction (DSSP)
implementation in BioJava and obtain different SS representations and
outputs.
|
| DemoShowBiolAssembly |
|
| DemoShowCATHDomain |
|
| DemoShowLargeAssembly |
|
| DemoShowValidationResults |
|
| DemoSixFrameTranslation |
Created by andreas on 8/10/15.
|
| DemoStructureFromFasta |
|
| DemoSW3DAligner |
|
| DemoSymmetry |
A demo on how to use the quaternary symmetry detection algorithms.
|
| DescriptiveStatistics |
|
| DevelopmentTools |
|
| DirectedBinaryDomainCombination |
|
| DirectedCombinableDomains |
|
| DiscreteQuantizerInterface |
|
| DisplayAFP |
A utility class for visualistion of structure alignments
|
| DistanceBox<T> |
|
| DistanceMatrix |
|
| DistanceMatrix.Format |
|
| DistanceMatrixCalculator |
|
| DistanceTreeEvaluator |
Check the accuracy of a Distance Tree by least squares error (LSE) of the
Tree branch lengths and the original Distance Matrix.
|
| Distribution |
|
| DistributionParser |
|
| DivergingColorPalettePanel |
Creates a color palette of diverging colors defined by ColorBrewer
|
| DNACompoundSet |
|
| DNASequence |
This is class should model the attributes associated with a DNA sequence
|
| DNASequence.DNAType |
The type of DNA sequence
|
| DNASequenceCreator |
A helper class that allows different ways to read a string and create a DNA sequence.
|
| DNAToRNATranslator |
Performs the first stage of transcription by going from DNA to RNA.
|
| DolloParsimony |
|
| dom_dup |
|
| Domain |
|
| Domain |
|
| DomainArchitecture |
|
| DomainArchitectureBasedGenomeSimilarityCalculator |
|
| DomainArchitectureParser |
|
| DomainCountsBasedPairwiseSimilarityCalculator |
|
| DomainCountsDifferenceUtil |
|
| DomainCountsDifferenceUtil.COPY_CALCULATION_MODE |
|
| DomainLengths |
|
| DomainLengthsTable |
|
| domainloss_replacement |
|
| DomainParsimonyCalculator |
|
| DomainProvider |
Decomposes a structure from the PDB into representative domains
|
| DomainProviderFactory |
A simple factory object that returns the system wide default DomainProvider
|
| DomainSimilarity |
|
| DomainSimilarity.DomainSimilarityScoring |
|
| DomainSimilarity.DomainSimilaritySortField |
|
| DomainSimilarity.PRINT_OPTION |
|
| DomainSimilarityCalculator |
|
| DomainSimilarityCalculator.Detailedness |
|
| DomainSimilarityCalculator.GoAnnotationOutput |
|
| DotPlotPanel |
Displays the dot plot trace for an alignment.
|
| DownloadChemCompProvider |
This provider of chemical components can download and cache chemical component definition files from the RCSB PDB web site.
|
| DSSPParser |
Class to parse a DSSP file (output of the DSSP program),
that contains the secondary structure assignment of a structure.
|
| EasyWriter |
|
| EbiDbEntry |
|
| EcodDatabase |
General API for interacting with ECOD.
|
| EcodDomain |
An EcodDomain contains all the information of the ECOD database: id,
classification groups (from higher to lower in the tree: X,H,T,F), PDB code,
chain, residue ranges and status (manual or automatic classification).
|
| EcodFactory |
|
| EcodInstallation |
Provides access to the Evolutionary Classification of Protein Domains (ECOD).
|
| EcodInstallation.EcodParser |
|
| Edit<C extends Compound> |
Interface for carrying out edit operations on a Sequence.
|
| Edit.AbstractEdit<C extends Compound> |
Abstract class which defines all edit operations as a call to discover
what 5' and 3' ends of an editing Sequence should be joined together
with a target Sequence.
|
| Edit.Delete<C extends Compound> |
Implementation which allows for the deletion of bases from a Sequence
|
| Edit.Insert<C extends Compound> |
Edit implementation which allows us to insert a base at any position
in a Sequence.
|
| Edit.Substitute<C extends Compound> |
Allows for the substitution of bases into an existing Sequence.
|
| EigenvalueDecomposition |
Eigenvalues and eigenvectors of a real matrix.
|
| Element |
One way to model the elements
|
| Element |
Element is an enumeration of the elements of the periodic table.
|
| ElementTable |
|
| ElementType |
ElementType is an enumeration of the types of elements found in the periodic table.
|
| EmblId |
This class contains the processed data of embl file
Primary accession number
Sequence version number
Topology: 'circular' or 'linear'
Molecule type
Data class
Taxonomic division
Sequence length
|
| EmblReader |
This class should process the data of embl file
|
| EmblRecord |
this class contains the parsed data of embl file
|
| EmblReference |
This class contains the processed data of embl file that
contains the referenceNumber, referenceComment, referencePosition
referenceCrossReference, referenceGroup, referenceAuthor
referenceTitle, referenceLocation
|
| Entity |
A simple class to represent Entity records in mmCif files
|
| EntityFinder |
Heuristical finding of Entities (called Compounds in legacy PDB format)
in a given Structure.
|
| EntityInfo |
An object to contain the info from the PDB header for a Molecule.
|
| EntityPoly |
Container for _entity_poly records
|
| EntityPolySeq |
Container for _entity_poly_seq records
|
| EntitySrcGen |
Data items in the ENTITY_SRC_GEN category record details of
the source from which the entity was obtained in cases
where the source was genetically manipulated.
|
| EntitySrcNat |
Data items in the ENTITY_SRC_NAT category record details of
the source from which the entity was obtained in cases
where the entity was isolated directly from a natural tissue.
|
| EntitySrcSyn |
PDBX_ENTITY_SRC_SYN records the details about each chemically
synthesized molecule (entity) in the asymmetric unit.
|
| EntityType |
The type of entity (polymer, non-polymer, water, macrolide)
as defined in the mmCIF dictionary: |
| Entry |
Java class for anonymous complex type.
|
| Equals |
A set of helper methods which return true if the two parameters are
equal to each other.
|
| Event |
|
| Event.EventType |
|
| EventParser |
|
| Example1 |
|
| Example2 |
|
| Example3 |
|
| Example4 |
|
| Example5 |
|
| ExonComparator |
Sort Exon where it is a little confusing if exons shoud always be ordered left to right
where a negative stranded gene should go the other direction.
|
| ExonSequence |
A gene contains a collection of Exon sequences
|
| ExperimentalTechnique |
An enum to represent the experimental technique of a PDB structure
|
| ExpressionFigure |
|
| Exptl |
|
| ExternalForwardIterator |
|
| ExternalNodeBasedCoverage |
|
| ExternalNodeBasedCoverageMethod |
|
| ExternalNodeBasedCoverageMethodOptions |
|
| ExternalProgram |
|
| FailedConditionCheckException |
|
| FarmJob |
A job as it can be run on the farm.
|
| FarmJobParameters |
|
| FarmJobRunnable |
Contains the single thread for a job that can run multiple alignments.
|
| fasta_split |
|
| FastaAFPChainConverter |
A collection of static utilities to convert between AFPChains and FastaSequences. |
| FastaGeneWriter |
A Gene sequence has a Positive or Negative Strand where we want to write out to a stream the 5 to 3 prime version.
|
| FastaHeaderFormatInterface<S extends Sequence<?>,C extends Compound> |
|
| FastaParser |
|
| FastaReader<S extends Sequence<?>,C extends Compound> |
Use FastaReaderHelper as an example of how to use this class where FastaReaderHelper should be the
primary class used to read Fasta files
|
| FastaReaderHelper |
|
| FastaSequence |
A FASTA formatted sequence.
|
| FastaSequenceParser |
Used to parse a stream of a fasta file to get the sequence
|
| FastaStructureParser |
Reads a protein sequence from a fasta file and attempts to match it to a
3D structure.
|
| FastaWriter<S extends Sequence<?>,C extends Compound> |
The FastaWriter writes a collection of sequences to an outputStream.
|
| FastaWriterHelper |
The class that should be used to write out fasta file of a sequence collection
|
| Fastq |
FASTQ formatted sequence.
|
| FastqBuilder |
Fluent builder API for creating FASTQ formatted sequences.
|
| FastqReader |
Reader for FASTQ formatted sequences.
|
| FastqTools |
Utility methods for FASTQ formatted sequences.
|
| FastqVariant |
FASTQ sequence format variant.
|
| FastqWriter |
Writer for FASTQ formatted sequences.
|
| FatCat |
|
| FatCatAligner |
A class that does calculations on an AFPChain
|
| FatCatFlexible |
|
| FatCatParameters |
|
| FatCatRigid |
|
| FatCatUserArgumentProcessor |
|
| FCAlignHelper |
|
| Feature |
A Feature corresponds to a single row in a GFF file.
|
| FeatureDbReferenceInfo<S extends AbstractSequence<C>,C extends Compound> |
|
| FeatureHelper |
|
| FeatureI |
A feature on a sequence (for example, an exon or a gene), defined by a location
and a set of attributes encoded as key/value pairs.
|
| FeatureInterface<S extends AbstractSequence<C>,C extends Compound> |
Interface class to handle describing arbitrary features.
|
| FeatureList |
A list of FeatureI objects implemented using a Java ArrayList; corresponds to a GFF file.
|
| FeatureRetriever |
If a SequenceProxyReader implements this interface then that external source
has a list features
|
| FeaturesKeyWordInterface |
Models the keywords that are annotated for a protein sequence at Uniprot.
|
| FileConvert |
Methods to convert a structure object into different file formats.
|
| FileDownloadUtils |
|
| FileParsingParameters |
|
| FileProxyDNASequenceCreator |
This class is a good example of using the SequenceCreatorInterface where during parsing of the stream
the sequence and the offset index are passed to create a Protein sequence that will be loaded in lazily.
|
| FileProxyProteinSequenceCreator |
This class is a good example of using the SequenceCreatorInterface where during parsing of the stream
the sequence and the offset index are passed to create a Protein sequence that will be loaded in lazily.
|
| FileProxyRNASequenceCreator |
This class is a good example of using the SequenceCreatorInterface where during parsing of the stream
the sequence and the offset index are passed to create a Protein sequence that will be loaded in lazily.
|
| FitchParsimony<STATE_TYPE> |
|
| FlatFileCache |
Provides a cache for storing multiple small files in memory.
|
| FontChooser |
|
| ForesterConstants |
|
| ForesterConstants.PhylogeneticTreeFormats |
|
| ForesterUtil |
|
| ForesterWrapper |
This class contains wrapper methods for communication between BioJava and
forester (e.g, Data Structure conversion).
|
| FourBitSequenceReader<C extends Compound> |
Four bit encoding of the bit formats.
|
| FourBitSequenceReader.FourBitArrayWorker<C extends Compound> |
A four bit per compound implementation of the bit array worker code.
|
| FractionalIdentityInProfileScorer<S extends Sequence<C>,C extends Compound> |
Implements an algorithm which computes a score for a sequence alignment pair picked from an alignment
Profile. |
| FractionalIdentityScorer<S extends Sequence<C>,C extends Compound> |
Implements an algorithm which computes a score for a sequence alignment pair.
|
| FractionalSimilarityInProfileScorer<S extends Sequence<C>,C extends Compound> |
Implements an algorithm which computes a score for a sequence alignment pair picked from an alignment
Profile. |
| FractionalSimilarityScorer<S extends Sequence<C>,C extends Compound> |
Implements an algorithm which computes a score for a sequence alignment pair.
|
| FragmentJoiner |
Joins the initial Fragments together to larger Fragments
|
| FragmentPair |
a pair of fragments of two protein structures
|
| Frame |
Indicates a way of translating a sequence.
|
| FuzzyPoint |
Implementation for resolving fuzzy locations.
|
| GapArray |
|
| GapContribution |
|
| GapPenalty |
Defines a data structure for the gap penalties used during a sequence alignment routine.
|
| GapPenalty.Type |
Defines the possible types of gap penalties.
|
| GCStats |
|
| GenbankHeaderFormatInterface<S extends Sequence<?>,C extends Compound> |
|
| GenbankProxySequenceReader<C extends Compound> |
|
| GenbankReader<S extends AbstractSequence<C>,C extends Compound> |
|
| GenbankReaderHelper |
|
| GenbankReference |
For Genbank format file only.
|
| GenbankSequenceParser<S extends AbstractSequence<C>,C extends Compound> |
|
| GenbankWriter<S extends Sequence<?>,C extends Compound> |
|
| GenbankWriterHelper |
The class that should be used to write out genbank file of a sequence
collection
|
| gene_tree_preprocess |
|
| GeneChromosomePosition |
|
| GeneChromosomePositionParser |
A parser that parses a file from the UCSC genome browser that contains mapping of gene name to chromosome positions
|
| GeneFeatureHelper |
|
| GeneIDGFF2Reader |
http://www.bioperl.org/wiki/GTF
Read and write FeatureLists as GFF/GTF formatted files.
|
| GeneIDXMLReader |
|
| GeneMarkGTFReader |
http://www.bioperl.org/wiki/GTF
Read and write FeatureLists as GFF/GTF formatted files.
|
| GeneName |
A simple bean that contains gene name information as available from www.genenames.org
|
| GeneNamesParser |
Parses a file from the www.genenames.org website that contains a mapping of human gene names to other databases
|
| GeneralMsaParser |
|
| GeneralTable<IDENTIFIER_TYPE,VALUE_TYPE> |
|
| GenericFastaHeaderFormat<S extends AbstractSequence<?>,C extends Compound> |
We store the original header if the sequence is parsed from a fasta file and will use that exact
sequence if we write out the sequences to a fasta file.
|
| GenericFastaHeaderParser<S extends AbstractSequence<C>,C extends Compound> |
The default fasta header parser where some headers are well defined based on the source
database which allows us to set the source of the protein sequence and the identifier
that can be used in future implementations to load features from external sources
If the user has a custom header with local data then they can create their own implementation
of a FastaHeaderParserInterface
|
| GenericGenbankHeaderFormat<S extends AbstractSequence<C>,C extends Compound> |
|
| GenericGenbankHeaderParser<S extends AbstractSequence<C>,C extends Compound> |
|
| GenericInsdcHeaderFormat<S extends AbstractSequence<C>,C extends Compound> |
|
| GeneSequence |
|
| genome_counts_for_once_appearing_dcs |
|
| GenomeWideCombinableDomains |
|
| GenomeWideCombinableDomains.GenomeWideCombinableDomainsSortOrder |
|
| get_distances |
|
| get_genome_counts_per_char |
|
| get_loss_nodes |
|
| get_shared_chars |
|
| get_subtree_specific_chars |
|
| GetDistanceMatrix |
|
| GetRepresentatives |
TODO Move this to Representatives.
|
| GFF3FromUniprotBlastHits |
|
| GFF3Reader |
http://www.bioperl.org/wiki/GTF
Read and write FeatureLists as GFF/GTF formatted files.
|
| GFF3Writer |
|
| goac |
|
| GoId |
|
| GoNameSpace |
|
| GoNameSpace.GoNamespaceType |
|
| GOParser |
Simple parser for the Gene Ontology (GO) flatfile format.
|
| GoRelationship |
|
| GoRelationship.Type |
|
| GoSubset |
|
| GoSubset.Type |
|
| GoTerm |
|
| Gotoh |
a class to perform Gotoh algorithm
|
| GoUtils |
|
| GoXRef |
|
| GoXRef.Type |
|
| GradientMapper |
Maps a set of real values onto a gradient.
|
| GradientPanel |
|
| GraphComponentOrderDetector |
The GraphOrderDetector transforms the self-alignment into a Graph and
extracts its maximally connected Components.
|
| GraphComponentRefiner |
The GraphRefiner transforms the self-alignment into a Graph and extracts its
maximally connected Components.
|
| Grid |
A grid to be used for calculating atom contacts through a spatial hashing algorithm.
|
| GridCell |
A grid cell to be used in contact calculation via spatial hashing algorithm.
|
| Group |
This is the data structure for a single Group of atoms.
|
| GroupAsa |
A class to store the results of ASA calculations, it can
hold ASA values per atom present in Group |
| GroupContact |
A pair of residues that are in contact
|
| GroupContactSet |
A set of residue-residue contacts.
|
| GroupIterator |
An iterator over all groups of a structure.
|
| GroupResults |
|
| GroupToSDF |
|
| GroupType |
This contains basic categories for Group types.
|
| gsdi |
|
| GSDI |
|
| GSDII |
|
| GSDIR |
|
| GuanUberbacher<S extends Sequence<C>,C extends Compound> |
Guan and Uberbacher defined an algorithm for pairwise global sequence alignments (from the first until the last
Compound of each Sequence). |
| GUIAlignmentProgressListener |
a GUI that allows to watch progress as multiple alignments are being processed.
|
| GuideTree<S extends Sequence<C>,C extends Compound> |
Implements a data structure for a guide tree used during progressive multiple sequence alignment.
|
| GuideTreeNode<S extends Sequence<C>,C extends Compound> |
Defines a data structure for the node in a guide tree used during progressive multiple sequence alignment.
|
| GUIFarmJobRunnable |
|
| GuiWrapper |
A class to wrap some of the strucutre.gui classes using Reflection
|
| Hashcoder |
Contains helper methods for generating a HashCode without having to resort to
the commons lang hashcode builders.
|
| HasResultXMLConverter |
|
| HBond |
Container that represents a hidrogen bond.
|
| HeaderInfo |
|
| HelicalRepeatUnit |
|
| Helix |
|
| HelixAxisAligner |
|
| HelixExtender |
|
| HelixLayers |
|
| HelixSolver |
|
| Hello3d |
|
| HelpDialog |
|
| HetatomImpl |
Generic Implementation of a Group interface.
|
| HetatomImpl.PerformanceBehavior |
Behaviors for how to balance memory vs.
|
| HierarchicalClusterer<S extends Sequence<C>,C extends Compound> |
Defines a clustering algorithm that converts a distance matrix into a tree.
|
| Hit |
This class models a search Hit.
|
| HmmerDemo |
The cookbook recipe for how to request Pfam annotations for a protein sequence using the Hmmer3 service
|
| HmmerDomain |
Provides the details of a domain hit
|
| HmmerRest |
|
| HmmerResult |
The results of a Hmmer search for a single sequence
|
| HmmerScan |
Interface for performing Hmmscans on sequences.
|
| HmmPfamOutputParser |
|
| HmmPfamOutputParser.FilterType |
|
| HmmPfamOutputParser.ReturnType |
|
| HmmscanPerDomainTableParser |
|
| HmmscanPerDomainTableParser.FilterType |
|
| HmmscanPerDomainTableParser.INDIVIDUAL_SCORE_CUTOFF |
|
| HmmscanPerDomainTableParser.ReturnType |
|
| Hsp<S extends Sequence<C>,C extends Compound> |
This class models a search Hsp.
|
| HSVColorSpace |
|
| IcosahedralSampler |
Represents an even coverage of quaternion space by 60 points.
|
| Icosahedron |
|
| Identifier |
|
| IdentifierParser |
|
| IdxComparator |
|
| IgnoreField |
Annotation indicating that a specific field of a bean should be ignored
|
| IllegalFormatUseException |
|
| IlluminaFastqReader |
|
| IlluminaFastqWriter |
|
| ImageLoader |
|
| IndexPair |
|
| InferenceManager |
|
| InputStreamProvider |
A class that provides an InputStream from a File.
|
| InsdcLocations |
A collection of locations which are used whenever we work with INSDC; some
of which could be deprecated (from INSDC's point of view) yet appear
in records.
|
| InsdcLocations.BondLocation |
Used to represent bond locations equivalent to bond(7,8) or bond(7).
|
| InsdcLocations.GroupLocation |
Deprecated in INSDC yet still appears; equivalent to the order()
directive except no 5' to 3' ordering is defined.
|
| InsdcLocations.OneOfLocation |
Deprecated in INSDC; refers to a set of locations of which one
location could be valid e.g.
|
| InsdcLocations.OrderLocation |
Used to describe a 5' to 3' ordering but no firm assurance it is correct
|
| InsdcParser<S extends AbstractSequence<C>,C extends Compound> |
Parser for working with INSDC style locations.
|
| IntegerOntology |
|
| InterfaceFinder |
A class containing methods to find interfaces in a given structure.
|
| IntMatrix |
|
| IntronSequence |
|
| InvalidTermException |
Thrown to indicate that an ontology term is not acceptable or
appropriate in a given context
|
| inverted_dcs |
|
| IOUtils |
|
| IOUtils.ReaderProcessor |
Closure interface used when working with
IOUtils#processReader(String).
|
| IPeptideProperties |
An interface to generate some basic physico-chemical properties of protein sequences.
The following properties could be generated:
|
| IProfeatProperties |
|
| IProfeatProperties.ATTRIBUTE |
Enumeration of the seven different attributes
|
| IProfeatProperties.DISTRIBUTION |
Enumeration of the distribution for the first, first 25%, first 50%, first 75% and 100% of the grouping
|
| IProfeatProperties.GROUPING |
Enumeration of the three different groupings for each attributes
|
| IProfeatProperties.TRANSITION |
Enumeration of the transition between groupA and groupB
|
| Isotope |
|
| IteratingPhylogenyParser |
|
| IUPACParser |
Available translations
1 - UNIVERSAL
2 - VERTEBRATE_MITOCHONDRIAL
3 - YEAST_MITOCHONDRIAL
4 - MOLD_MITOCHONDRIAL
5 - INVERTEBRATE_MITOCHONDRIAL
6 - CILIATE_NUCLEAR
9 - ECHINODERM_MITOCHONDRIAL
10 - EUPLOTID_NUCLEAR
11 - BACTERIAL
12 - ALTERNATIVE_YEAST_NUCLEAR
13 - ASCIDIAN_MITOCHONDRIAL
14 - FLATWORM_MITOCHONDRIAL
15 - BLEPHARISMA_MACRONUCLEAR
16 - 2CHLOROPHYCEAN_MITOCHONDRIAL
21 - TREMATODE_MITOCHONDRIAL
23 - SCENEDESMUS_MITOCHONDRIAL
Taken from NCBI with slight modification and put into the classpath resource. |
| IUPACParser.IUPACTable |
Holds the concept of a codon table from the IUPAC format
|
| JAutoSuggest |
A JTextField that can make suggestions for auto-complete.
|
| JFatCatClient |
|
| JMatrixPanel |
a JPanel that can display a difference of distance matrix and paths that have been
taken for the alignment
|
| JmolAlignedPositionListener |
|
| JmolPanel |
|
| JmolPanel.JmolLoggerAdapter |
|
| JmolSymmetryScriptGenerator |
|
| JmolSymmetryScriptGeneratorC1 |
|
| JmolSymmetryScriptGeneratorCn |
|
| JmolSymmetryScriptGeneratorDn |
|
| JmolSymmetryScriptGeneratorH |
|
| JmolSymmetryScriptGeneratorI |
|
| JmolSymmetryScriptGeneratorO |
|
| JmolSymmetryScriptGeneratorPointGroup |
|
| JmolSymmetryScriptGeneratorT |
|
| JmolTools |
|
| JmolViewerImpl |
|
| JNLPProxy |
|
| JobKillException |
|
| JoiningSequenceReader<C extends Compound> |
This reader actually proxies onto multiple types of sequence in order
to allow a number of sequence objects to act as if they are one sequence.
|
| JointFragments |
A utility class that defines which set of atoms are considered
to be on equivalent positions.
|
| JournalArticle |
PDB-specific
|
| JPrintPanel |
|
| Jronn |
This class gives public API to RONN functions.
|
| Jronn.Range |
Holder for the ranges, contain pointers to starting and ending position
on the sequence which comprises a disordered region.
|
| KaplanMeierFigure |
|
| KeyedWeakReference |
Subclass of WeakReference which includes and extra field (the key)
which can be used to help cleanup once this reference has been
enqueued.
|
| KMFigureInfo |
|
| Ladder |
A Ladder is a set of one or more consecutive bridges of identical type.
|
| LevelOrderTreeIterator |
|
| LightweightProfile<S extends Sequence<C>,C extends Compound> |
Defines a minimal data structure for reading and writing a sequence alignment.
|
| LightweightProfile.StringFormat |
List of output formats.
|
| LinearColorInterpolator |
|
| LinearColorInterpolator.InterpolationDirection |
|
| ListStringWrapper |
|
| LocalPDBDirectory |
|
| LocalPDBDirectory.FetchBehavior |
Controls when the class should fetch files from the ftp server
|
| LocalPDBDirectory.ObsoleteBehavior |
Behaviors for when an obsolete structure is requested.
|
| LocalProteinDomainParser |
Protein Domain Parser is a an algorithm that attempts at assigning domains for 3D protein structures.
|
| LocalScopDatabase |
Classes which implement ScopDatabase in a way which allows them to serve queries
without accessing the internet should implement this interface instead.
|
| Location |
Sets of integers used to represent the location of features on sequence.
|
| Location |
A location on a sequence.
|
| Location.Tools |
Helper methods for use with the Location classes.
|
| LocationHelper |
Helper methods for use with the Location classes.
|
| LocIterator |
Move a sliding window over a Location.
|
| LogBranchLengthBasedScoringMethod |
|
| LogColorMapper |
Performs a log10 transform on input before passing the values off to another
colorMapper.
|
| LUDecomposition |
LU Decomposition.
|
| Mafft |
|
| MainFrame |
|
| MainFrameApplet |
|
| MainFrameApplication |
|
| MainPanel |
|
| map_lengths |
|
| Mapping |
|
| MappingResults |
|
| MapToStringTransformer |
Transforms Map to String.
|
| Maths |
|
| Matrices |
Matrices contains static methods to operate and transform matrices used in 3D
geometry (transformation matrices and rotation matrices).
|
| Matrix |
Jama = Java Matrix class.
|
| Matrix |
***********************************************************************
Compilation: javac Matrix.java Execution: java Matrix
A bare-bones collection of static methods for manipulating matrices.
|
| MatrixAligner<S extends Sequence<C>,C extends Compound> |
Defines an Aligner which builds a score matrix during computation. |
| MatrixListener |
|
| mcc |
|
| MeanModelComparator |
|
| MeanQuantizer |
|
| MemoryMonitor |
Tracks Memory allocated & used, displayed in graph form.
|
| MenuCreator |
Create the menus for structure alignment GUI windows (JFrames).
|
| MenuCreator |
Create the menu for BiojavaJmol
|
| MenuCreator.DotPlotListener |
Creates a frame to display a DotPlotPanel.
|
| Messages |
|
| meta_ontologizer |
|
| MetaDataInfo |
|
| MetalBondConsumer |
Created by andreas on 6/9/16.
|
| MetalBondDistance |
A bean that contains cutoffs for correctly detecting metal bonds.
|
| MetalBondParser |
Created by andreas on 6/6/16.
|
| MetaOntologizer |
|
| MismatchedBasePairParameters |
This class allows for finding inter-strand base pairs that are not necessarily canonical Watson-Crick pairs.
|
| MMcifConsumer |
An interface for the events triggered by a MMcifParser.
|
| MMCIFFileReader |
How to parse an mmCif file:
|
| MMCIFFileTools |
Some tools for mmCIF file writing.
|
| MMcifParser |
Interface that needs to be implemented by an MMcifParser
|
| MmtfActions |
A class of functions for reading and writing Biojava structures using MMTF
|
| MMTFFileReader |
A class to read MMTF files and cache them locally.
|
| MmtfStructureReader |
A biojava specific structure inflator for MMTF.
|
| MmtfStructureWriter |
Class to take Biojava structure data and covert to the DataApi for encoding.
|
| MmtfSummaryDataBean |
Class to store the summary data for a given structure.
|
| MmtfUtils |
A utils class of functions needed for Biojava to read and write to mmtf.
|
| Model |
An internal utility class for StructureImpl to make it easier to manage poly and nonpoly chains.
|
| ModelingUtils |
|
| ModelledSubgroup |
Java class for anonymous complex type.
|
| ModelLoader |
|
| ModelLoader.Model |
Represent a RONN model
|
| ModelLoader.Threshold |
Represents a Threshold
|
| ModificationCategory |
define modification categories.
|
| ModificationCondition |
Conditions of a protein modification, e.g.
|
| ModificationConditionImpl |
|
| ModificationLinkage |
|
| ModificationOccurrenceType |
|
| ModifiedAminoAcidCompoundSet |
|
| ModifiedCompound |
Root interface for all modifications in structure.
|
| ModifiedCompoundImpl |
|
| ModifiedCompoundXMLConverter |
|
| MogAngleOutlier |
Java class for anonymous complex type.
|
| MogBondOutlier |
Java class for anonymous complex type.
|
| MolecularSequence |
|
| MolecularSequence.TYPE |
|
| MomentsOfInertia |
The moment of inertia, otherwise known as the angular mass or rotational
inertia, of a rigid body determines the torque needed for a desired angular
acceleration about a rotational axis.
|
| MomentsOfInertia.SymmetryClass |
|
| Msa |
|
| msa_compactor |
|
| Msa.MSA_FORMAT |
|
| MsaCompactor |
|
| MsaFormatException |
|
| MsaInferrer |
|
| MsaMethods |
|
| MsaProperties |
|
| MsaRenderer |
|
| MultipleAlignment |
A MultipleAlignment is a Data Structure to store the core information of a
multiple structure alignment, as a return type.
|
| MultipleAlignmentCalc |
A class that obtains structures via DAS and aligns them.
|
| MultipleAlignmentCoordManager |
Generalization of the Coodinate Manager to include an arbitrary number of
sequences (lines) for MultipleAlignment visualization.
|
| MultipleAlignmentDisplay |
Utility functions to generalize the visualization of MultipleAlignments in
molecular viewers.
|
| MultipleAlignmentEnsemble |
A MultipleAlignmentEnsemble is a collection of MultipleAlignments
that share the same structures (Atoms) and creation properties (algorithm,
version, creation time, etc.). |
| MultipleAlignmentEnsembleImpl |
|
| MultipleAlignmentGUI |
A JFrame that allows to trigger a multiple structure alignment,
either from files in a directory or after manual upload.
|
| MultipleAlignmentImpl |
|
| MultipleAlignmentJmol |
|
| MultipleAlignmentJmolDisplay |
Utility Class that provides helper methods for the visualization of
MultipleAlignments. |
| MultipleAlignmentScorer |
|
| MultipleAlignmentTools |
|
| MultipleAlignmentWriter |
This class contains functions for the conversion of MultipleAlignment
to various String outputs. |
| MultipleAlignmentXMLConverter |
Helper methods to convert all the hierarchy levels of a MultipleAlignment
into an XML format.
|
| MultipleAlignmentXMLParser |
|
| MultipleAligPanel |
A JPanel that can display the sequence alignment of a
MultipleAlignment in a nice way and interact with Jmol by
selecting the aligned atoms of the sequence selection. |
| MultipleAligPanelMouseMotionListener |
|
| MultipleMcMain |
Main class of the Java implementation of the Combinatorial Extension -
Monte Carlo (CEMC) Algorithm,
as it was originally described by C.Guda, E.D.Scheeff, P.E.
|
| MultipleMcOptimizer |
This class takes a MultipleAlignment seed previously generated and runs a
Monte Carlo optimization in order to improve the overall score and highlight
common structural motifs.
|
| MultipleMcParameters |
Contains the parameters to be sent to the MC optimization.
|
| MultipleSequenceAlignment<S extends Sequence<C>,C extends Compound> |
Implements a minimal data structure for reading and writing a sequence alignment.
|
| MultipleStatusDisplay |
|
| MultipleStructureAligner |
Interface for the Multiple Structure Alignment Algorithms.
|
| MultipleSuperimposer |
Interface for Multiple Alignment superposition algorithms.
|
| MultipleUris |
|
| MultiThreadedDBSearch |
Performs a multi threaded database search for an input protein structure
|
| MutableAlignedSequence<S extends Sequence<C>,C extends Compound> |
|
| MutableProfile<S extends Sequence<C>,C extends Compound> |
Defines a mutable (editable) data structure for a Profile. |
| MutableProfilePair<S extends Sequence<C>,C extends Compound> |
Defines a mutable (editable) data structure for a ProfilePair. |
| MutableSequencePair<S extends Sequence<C>,C extends Compound> |
Defines a mutable (editable) data structure for the results of pairwise sequence alignment.
|
| Mutator |
A class that can change one amino acid to another.
|
| MyAlignmentLoadListener |
Loads an alignment in an XML format and displays its content in a
new Jmol panel.
|
| MyDistMaxListener |
Shows the interatomic Distance Matrices of all the Structures aligned in different Frames.
|
| MyExportListener |
|
| MyJmolStatusListener |
|
| MyOpenPdbFileListener |
|
| MySaveFileListener |
Save an alignment to a specified File by the user.
|
| MyTableRowSorter |
|
| MyValidationEventHandler |
|
| Name2Count |
|
| NCBIQBlastAlignmentProperties |
This class wraps a QBlast search request parameter Map by adding several convenient parameter addition
methods.
|
| NCBIQBlastOutputProperties |
This class wraps a QBlast output parameter Map by adding several convenient parameter addition methods.
|
| NCBIQBlastService |
Provides a simple way of submitting BLAST request to the QBlast service at NCBI.
|
| NCBIQBlastServiceDemo |
|
| NeedlemanWunsch<S extends Sequence<C>,C extends Compound> |
Needleman and Wunsch defined an algorithm for pairwise global sequence alignments (from the first until the last
Compound of each Sequence). |
| NeighborJoining |
|
| NeighborJoiningF |
|
| NeighborJoiningR |
|
| neTest |
|
| NexusBinaryStatesMatrixParser |
|
| NexusCharactersParser |
|
| NexusConstants |
|
| NexusFormatException |
|
| NexusPhylogeniesParser |
|
| NHXFormatException |
|
| NHXParser |
|
| NHXParser.TAXONOMY_EXTRACTION |
|
| NHXtags |
|
| nj |
|
| NodeData |
|
| NodeDataField |
|
| NodeVisualData |
|
| NodeVisualData.FontType |
|
| NodeVisualData.NodeFill |
|
| NodeVisualData.NodeShape |
|
| NucleotideCompound |
|
| NucleotideImpl |
A nucleotide group is almost the same as a Hetatm group.
|
| NullOutputStream |
The stream that void its input
|
| NumbersAtRiskPanel |
|
| ObjectFactory |
This object contains factory methods for each
Java content interface and Java element interface
generated in the org.biojava.nbio.structure.validation package.
|
| obo_tool |
|
| OboFileEventListener |
an interface for events that occur during parsing of .obo files
|
| OboFileHandler |
A file handler for .obo files
|
| OboFileParser |
A class to parse the content of an OBO file.
|
| OboFileParser.SOPair |
|
| OboParser |
Parses an OBO file.
|
| OBOparser |
|
| OBOparser.ReturnType |
|
| Octahedron |
|
| OntologizerResult |
|
| OntologizerResult.TYPE |
|
| Ontology |
An ontology.
|
| Ontology.Impl |
A basic in-memory implementation of an ontology
|
| OntologyException |
Thrown to indicate an error in an Ontology object
|
| OntologyFactory |
A factory for Ontology instances.
|
| OntologyOps |
This is an interface for optimizing ontology operators.
|
| OntologyTerm |
A term in an ontology which identifies another ontology.
|
| OntologyTerm.Impl |
Simple in-memory implementation of a remote ontology term.
|
| OntoTools |
Tools for manipulating ontologies.
|
| OperatorResolver |
A class to resolve the operators for transformations
|
| OptimalCECPMain |
A wrapper for CeMain which sets default parameters to be appropriate for finding
circular permutations. |
| OptimalCECPParameters |
Contains the parameters that can be sent to CE
|
| Options |
|
| Options.CLADOGRAM_TYPE |
|
| Options.NODE_LABEL_DIRECTION |
|
| Options.PHYLOGENY_GRAPHICS_TYPE |
|
| OrderDetector |
A method to decide the order of symmetry (number of subunits)
given a structure self-alignment, calculated by CE-Symm.
|
| OrderedPair<T> |
An ordered pair represents a component of a cartesian product.
|
| ORonn |
Fully re-factored and enhanced version of RONN.
|
| ORonnModel |
Fully re-factored version of RONN model.
|
| OutputHitsGFF |
|
| Pair<T> |
A Pair of objects.
|
| PairInProfileScorer<S extends Sequence<C>,C extends Compound> |
Defines an algorithm which computes a score for a sequence alignment pair picked from an alignment Profile. |
| PairwiseDistanceCalculator |
|
| PairwiseDistanceCalculator.PWD_DISTANCE_METHOD |
|
| PairwiseDomainSimilarity |
|
| PairwiseDomainSimilarityCalculator |
|
| PairwiseGenomeComparator |
|
| PairwiseSequenceAligner<S extends Sequence<C>,C extends Compound> |
|
| PairwiseSequenceScorer<S extends Sequence<C>,C extends Compound> |
Defines an algorithm which computes a score for a pair of sequences.
|
| PaletteIcon |
Creates a color palette icon from a palette defined by ColorBrewer
|
| ParameterGUI |
|
| ParseFastaFileDemo |
Created by andreas on 6/17/15.
|
| ParseGO |
|
| ParseListener |
Low-level event based parser callback.
|
| ParserBasedPhylogenyFactory |
|
| ParserException |
General abstraction of different parsing errors
|
| ParserUtils |
|
| PartitionRefiner<S extends Sequence<C>,C extends Compound> |
Defines an algorithm which computes a new alignment Profile by splitting a current alignment and realigning.
|
| PassthroughIdentifier |
A stub StructureIdentifier, representing the full structure in all cases.
|
| PaupLogParser |
|
| pccx |
|
| PDBBioAssemblyParser |
Parses REMARK 350 records in a PDB file and creates transformations to
construct the quaternary structure of a protein from an asymmetric unit
|
| PDBCrystallographicInfo |
A class to hold crystallographic information about a PDB structure.
|
| PDBDirPanel |
A class to define where a structure for the alignment is coming from
|
| PDBDomainProvider |
Class to fetch domains through the RCSB's REST API.
|
| PDBFileParser |
This class implements the actual PDB file parsing.
|
| PDBFileReader |
The wrapper class for parsing a PDB file.
|
| PDBHeader |
A class that contains PDB Header information.
|
| PdbIdLists |
Utility classes for retrieving lists of PDB IDs.
|
| PdbPair |
A pair for structure alignment
|
| PdbPairsMessage |
|
| PdbPairXMLConverter |
|
| PDBParseException |
An exception during the parsing of a PDB file.
|
| PDBRecord |
An interface implemented by all classes that represent PDB records.
|
| PDBServerPanel |
A class to define where a structure for the alignment is coming from
|
| PDBStatus |
Methods for getting the status of a PDB file (current, obsolete, etc)
and for accessing different versions of the structure.
|
| PDBStatus.Status |
Represents the status of PDB IDs.
|
| PDBTemporaryStorageUtils |
Internal use only.
|
| PDBTemporaryStorageUtils.LinkRecord |
Temporary data storage for LINK records.
|
| PDBUploadPanel |
A JPanel to upload 2 custom PDB files.
|
| PdbxAuditRevisionHistory |
Bean to hold data for _pdbx_audit_revision_history mmCIF category.
|
| PdbxChemCompDescriptor |
|
| PdbxChemCompIdentifier |
_pdbx_chem_comp_identifier.comp_id
_pdbx_chem_comp_identifier.type
_pdbx_chem_comp_identifier.program
_pdbx_chem_comp_identifier.program_version
_pdbx_chem_comp_identifier.identifier
|
| PdbxDatabaseStatus |
Bean to hold data for _pdbx_database_status mmCIF category.
|
| PdbxEntityNonPoly |
A bean for the Pdbx_entity_nonpoly category.
|
| PdbxNonPolyScheme |
A bean for the PDBX_NONPOLY_SCHEME category, which provides residue level nomenclature
mapping for non-polymer entities.
|
| PdbxPolySeqScheme |
A bean for the PDBX_POLY_SEQ_SCHEME category, which provides residue level nomenclature
mapping for polymer entities.
|
| PdbxStructAssembly |
|
| PdbxStructAssemblyGen |
|
| PdbxStructAssemblyGenXMLContainer |
|
| PdbxStructAssemblyXMLContainer |
|
| PdbxStructOperList |
The bean for pdbx_struct_oper_list category
|
| PdbxStructOperListXMLContainer |
|
| PDPDistanceMatrix |
|
| PDPDomain |
|
| PDPParameters |
|
| PDPProvider |
Decomposes a structure into representative PDP domains.
|
| PeptideProperties |
This is an adaptor class which enable the ease of generating protein properties.
|
| PeptideProperties.SingleLetterAACode |
Enumeration of 20 standard amino acid code
|
| PeptidePropertiesImpl |
This class contains the actual implementation of IPeptideProperties and is wrapped around by PeptideProperties for ease of use.
|
| PermutationGenerator |
|
| PermutationGroup |
|
| pfam_go |
|
| pfam2go_extractor |
|
| pfamacc2go |
|
| pfamacc2pfamid |
|
| PfamToGoMapping |
|
| PfamToGoParser |
|
| phylo2coloredgraphics |
|
| phylo2graphics |
|
| PhylogeneticInferenceOptions |
|
| PhylogeneticInferrer |
|
| PhylogeneticInferrer.MSA_PRG |
|
| PhylogeniesWebserviceClient |
|
| Phylogeny |
|
| PhylogenyBranch |
|
| PhylogenyData |
|
| PhylogenyDataPhyloXmlParser |
|
| PhylogenyDataUtil |
|
| PhylogenyDecorator |
|
| PhylogenyDecorator.FIELD |
|
| PhylogenyFactory |
|
| PhylogenyMethods |
|
| PhylogenyMethods.DESCENDANT_SORT_PRIORITY |
|
| PhylogenyMethods.PhylogenyNodeField |
|
| PhylogenyNode |
Warning.
|
| PhylogenyNode.NH_CONVERSION_SUPPORT_VALUE_STYLE |
|
| PhylogenyNodeIterator |
|
| PhylogenyParser |
|
| PhylogenyParserException |
|
| PhylogenyWriter |
|
| PhylogenyWriter.FORMAT |
|
| PhyloInferenceDialog |
|
| phylostrip |
|
| phyloxml_converter |
|
| PhyloXmlDataFormatException |
|
| PhyloXmlException |
|
| PhyloXmlHandler |
|
| PhyloXmlMapping |
|
| PhyloXmlNodeWriter |
|
| PhyloXmlParser |
|
| PhyloXmlUtil |
|
| PlainFastaHeaderParser<S extends AbstractSequence<C>,C extends Compound> |
The plain fasta header takes everything in the header as a single entity.
|
| Point |
Holds a single point part of a location
|
| Point |
|
| Point.Resolver<T extends Point> |
Used to resolve a position about a point
|
| PointParser |
|
| Polygon |
|
| PolygonParser |
|
| Polyhedron |
|
| PolymerType |
Enumerates the classification of polymers.
|
| PositionInQueueXMLConverter |
|
| PostOrderStackObject |
|
| PostorderTreeIterator |
|
| PowerSet<T> |
In mathematics, the power set (or powerset) of any set S, written P(S), is
the set of all subsets of S, including the empty set and S itself.
|
| PredictDisorder |
|
| PreorderTreeIterator |
|
| PrettyXMLWriter |
Implementation of XMLWriter which emits nicely formatted documents
to a PrintWriter.
|
| Prism |
|
| ProcessPool |
|
| ProcessRunning |
|
| ProfeatProperties |
This is an adaptor class which enable the ease of generating profeat properties.
|
| ProfeatPropertiesImpl |
|
| Profile<S extends Sequence<C>,C extends Compound> |
Defines a data structure for the results of sequence alignment.
|
| Profile.StringFormat |
List of output formats.
|
| ProfilePair<S extends Sequence<C>,C extends Compound> |
Defines a data structure for the results of the alignment of a pair of Profiles. |
| ProfileProfileAligner<S extends Sequence<C>,C extends Compound> |
Defines an Aligner for a pair of Profiles. |
| ProfileProfileScorer<S extends Sequence<C>,C extends Compound> |
Defines an algorithm which computes a score for a pairing of alignment profiles.
|
| ProfileView<S extends Sequence<C>,C extends Compound> |
Defines a data structure for a view of sequence alignment.
|
| Program |
Java class for anonymous complex type.
|
| Programs |
Java class for anonymous complex type.
|
| PropertiesMap |
|
| Property |
|
| Property.AppliesTo |
|
| PropertyParser |
|
| Protein |
|
| ProteinComplexSignature |
|
| ProteinCountsBasedPairwiseDomainSimilarityCalculator |
|
| ProteinDomain |
|
| ProteinDomainParser |
|
| ProteinId |
|
| ProteinMappingTools |
|
| ProteinModification |
This interface defines information about a specific protein
modification.
|
| ProteinModificationIdentifier |
Identify attachment modification in a 3-D structure.
|
| ProteinModificationImpl |
This class contains information about a specific protein
modification.
|
| ProteinModificationImpl.Builder |
Uses Builder pattern to build a ProteinModification.
|
| ProteinModificationRegistry |
This class serves as a instance registry by maintaining
a pool of ProteinModification instances.
|
| ProteinModificationXmlReader |
|
| ProteinSequence |
The representation of a ProteinSequence
|
| ProteinSequenceCreator |
Used to create a ProteinSequence from a String to allow for details
about the location of the sequence etc.
|
| ProxySequenceReader<C extends Compound> |
|
| QRDecomposition |
QR Decomposition.
|
| QsAlign |
Quaternary Structure Alignment (QS-Align).
|
| QsAlignParameters |
The parameter bean for the QsAlign algorithm. |
| QsAlignResult |
Result of a Quaternary Structure Alignment QsAlign. |
| QsRelation |
The Quaternary Structure Relation describes the pairwise relation between two
quaternary structures.
|
| Qualifier |
|
| QualitativeColorPalettePanel |
Creates a color palette of qualitative colors defined by ColorBrewer
|
| QualityFeature<S extends AbstractSequence<C>,C extends Compound> |
DNA Sequences produced by modern sequencers usually have quality informaion
attached to them.
|
| QuantityFeature<S extends AbstractSequence<C>,C extends Compound> |
It is common to have a numerical value or values associated with a feature.
|
| QuatSuperpositionScorer |
|
| QuatSymmetryDetector |
Detects the symmetry (global, pseudo, internal and local) of protein
structures.
|
| QuatSymmetryParameters |
The QuatSymmetryParameters specify the options used for the detection of
quaternary symmetry in structures using the QuatSymmetryDetector. |
| QuatSymmetryResults |
|
| QuatSymmetryScores |
|
| QuatSymmetrySolver |
|
| QuatSymmetrySubunits |
A bean to represent information about the set of Subunits being
considered for symmetry detection. |
| Queue |
|
| RandomThing |
|
| RasmolCommandListener |
a utility class that listens to Ramsol script commands in the @link BiojavaJmol class |
| RCSBDescription |
Corresponds to the wrapper element in an RCSB describeMol XML file.
|
| RCSBDescriptionFactory |
|
| RCSBLigand |
Corresponds to a ligand in a ligandInfo XML file.
|
| RCSBLigands |
Corresponds to the wrapper element "ligandInfo" in an RCSB ligandInfo XML file.
|
| RCSBLigandsFactory |
|
| RCSBMacromolecule |
Corresponds to a macromolecule in an RCSB describeMol XML file.
|
| RCSBPolymer |
Corresponds to a polymer in a describeMol XML file.
|
| RCSBTaxonomy |
Corresponds to a taxonomy in a describeMol XML file.
|
| RCSBUpdates |
|
| ReadUtils |
Package-level static utilities for parsing XML.
|
| RectangularPrism |
|
| ReducedChemCompProvider |
|
| Reference |
|
| ReferenceInterface |
|
| ReferenceParser |
|
| ReferenceSuperimposer |
|
| Refine |
|
| RefinerFailedException |
Refinement of the self-alignment failed.
|
| reinv_count |
|
| RemoteDomainProvider |
A DomainProvider that uses a mixture of SCOP and PDP domains.
|
| RemoteHmmerScan |
Makes remote calls to the HMMER web service at the EBI web site and returns Pfam domain annotations for an input protein sequence.
|
| RemotePairwiseAlignmentOutputProperties |
RemotePairwiseAlignmentOutputProperties: the simplest representation of an object capable of holding
output formatting informations to be fed to a RemotePairwiseAlignmentService-implemented object.
|
| RemotePairwiseAlignmentProperties |
RemotePairwiseAlignmentProperties is a interface that contains the barest of
methods for setting and getting Alignment properties.
|
| RemotePairwiseAlignmentService |
This interface specifies minimal information needed to execute a pairwise alignment on a remote service.
|
| RemotePDPProvider |
A class that provided PDP assignments that are loaded from a remote web server
|
| RemoteScopInstallation |
A class that fetches information about SCOP from a remote data-source.
|
| RemoteTerm |
A term in another ontology.
|
| RemoteTerm.Impl |
Simple in-memory implementation of a remote ontology term.
|
| RenderableDomainArchitecture |
|
| RenderableMsaSequence |
|
| RenderablePhylogenyData |
|
| RenderableVector |
|
| RenderStyle |
|
| RepresentativeXMLConverter |
|
| ResampleableMsa |
|
| RescoreRefiner<S extends Sequence<C>,C extends Compound> |
Defines an algorithm which computes a new alignment Profile by rescoring all pairs in an alignment and
realigning.
|
| ResidualsCoxph |
|
| ResidualsCoxph.Type |
|
| ResidueGroup |
A ResidueGroup is a set of residues that are part of a maximally connected
component of the self-Alignment Graph in symmetry analysis.
|
| ResidueNumber |
Everything that is needed to uniquely describe a residue position
|
| ResidueRange |
A chainName, a start residue, and an end residue.
|
| ResidueRangeAndLength |
A chain, a start residue, and an end residue.
|
| ResidueRenderer |
|
| ResidueType |
Enumerates the possible classifications of residues.
|
| ResourceManager |
A class that manages the Strings that are defined in the spice.properties file.
|
| RestUtil |
This is to access the Web API for Biology (WABI) at DDBJ.
|
| Result |
This class models a search result.
|
| ResultFactory |
Designed by Paolo Pavan.
|
| ReversedSequenceView<C extends Compound> |
For a given sequence this class will return the base at the reversed
position i.e.
|
| rio |
|
| RIO |
|
| RIO.REROOTING |
|
| RIOException |
|
| RiskInfo |
|
| RNACompoundSet |
|
| RNASequence |
RNASequence where RNACompoundSet are the allowed values
|
| RNASequenceCreator |
Used to create a RNA sequence
|
| RnaSequenceView |
Attempts to do on the fly translation of RNA by not requesting the compounds
until asked.
|
| RNAToAminoAcidTranslator |
|
| RonnConstraint |
A collection of various constrain values used by RONN
|
| RonnConstraint.Threshold |
|
| Rotation |
|
| RotationAxis |
Calculates the rotation axis for an alignment
|
| RotationAxisAligner |
|
| RotationGroup |
|
| RotationSolver |
|
| RunnableProcess |
|
| SandboxStyleStructureProvider |
The "Sandbox" style of organizing files is to have a directory structure like below, i.e.
|
| SangerFastqReader |
|
| SangerFastqWriter |
|
| SankoffParsimony<STATE_TYPE> |
IN PROGRESS!
DO NOT USE!
|
| Sarray |
|
| ScaleableMatrixPanel |
A JPanel that can display the underlying distance matrix
data of the protein structure alignment algorithm.
|
| ScaledSubstitutionMatrix |
The biojava-alignment module represents substitution matrices with short
values.
|
| SchemaGenerator |
|
| SCOPAutoSuggestProvider |
|
| ScopCategory |
The various categories provided by SCOP.
|
| ScopDatabase |
General API how to interact with SCOP
|
| ScopDescription |
Contains data from
dir.des.scop.txt_1.75
|
| ScopDescriptions |
|
| ScopDomain |
Container for the information for a domain.
|
| ScopDomains |
|
| ScopFactory |
Controls the global ScopDatabase being used.
|
| ScopInstallation |
This class provides access to the SCOP protein structure classification.
|
| ScopInstallationInstance |
|
| ScopIOException |
Indicates that an I/O error occurred with SCOP lazy initialization.
|
| ScopMirror |
Helper class to store paths to the four SCOP files
The string "%s" is replaced with the version number.
|
| ScopNode |
|
| ScopNodes |
|
| ScopSelectPanel |
|
| Scorer |
Defines an algorithm which computes a score.
|
| ScoresCache |
Interface for classes which implement a temporary cache for various numeric
scores, e.g.
|
| ScoringMethodForExternalNode |
|
| SDI |
|
| SDIException |
|
| SDIR |
|
| SDIutil |
|
| SDIutil.ALGORITHM |
|
| SDIutil.TaxonomyComparisonBase |
|
| SearchIO |
Designed by Paolo Pavan.
|
| SecStrucCalc |
Calculate and assign the secondary structure (SS) to the
Groups of a Structure object.
|
| SecStrucElement |
A secondary structure element (SSE) is an object representing a block of
sequential residues that share the same secondary structure type.
|
| SecStrucInfo |
Container for the secondary structure information of a single residue.
|
| SecStrucState |
This class extends the basic container for secondary structure annotation,
including all the information used in the DSSP algorithm.
|
| SecStrucTools |
This class contains methods for obtaining and converting secondary structure
information from BioJava Structures. |
| SecStrucType |
This enum contains all of the secondary structure types found in the DSSP
output.
|
| Segment |
|
| SegmentComparator |
|
| Selection |
|
| SelectionImpl |
|
| SelectMultiplePanel |
A Text Panel that allows the user to specify multiple structure
identifiers, space separated.
|
| SelectPDBPanel |
A Panel that allows user to specify PDB & chain ID, as well as sub-ranges
|
| SeqMisMatch |
Created by andreas on 9/11/15.
|
| SeqMisMatchImpl |
Created by andreas on 9/11/15.
|
| SeqRes2AtomAligner |
Aligns the SEQRES residues to the ATOM residues.
|
| Sequence<C extends Compound> |
Main interface for defining a collection of Compounds and accessing them
using biological indexes
|
| Sequence |
|
| SequenceAccessionTools |
|
| SequenceAsStringHelper<C extends Compound> |
This is a common method that can be used across multiple storage/proxy implementations to
handle Negative strand and other interesting elements of sequence data.
|
| SequenceComparator |
Used to sort sequences
|
| SequenceCreatorInterface<C extends Compound> |
|
| SequenceDatabaseEntry |
|
| SequenceDataRetriver |
|
| SequenceDbWsTools |
|
| SequenceDisplay |
A sequence display that can show the results of a protein structure alignment.
|
| SequenceFileProxyLoader<C extends Compound> |
This class represents the storage container of a sequence stored in a fasta file where
the initial parsing of the file we store the offset and length of the sequence.
|
| SequenceFunctionOrderDetector |
Calls Spencer's method for determining order.
|
| SequenceFunctionRefiner |
Creates a refined alignment with the CE-Symm alternative self-alignment.
|
| SequenceHeaderParserInterface<S extends Sequence<?>,C extends Compound> |
|
| SequenceLocation<S extends AbstractSequence<C>,C extends Compound> |
A location in a sequence that keeps a reference to its parent sequence
|
| SequenceMixin |
Provides a set of static methods to be used as static imports when needed
across multiple Sequence implementations but inheritance gets in the way.
|
| SequenceMixin.SequenceIterator<C extends Compound> |
A basic sequence iterator which iterates over the given Sequence by
biological index.
|
| SequenceMouseListener |
a mouse listener for the AbstractChainRenderer class
it listens to all mouse events and triggeres appropriate
SequenceListener and FeatureListener events
|
| SequenceOptimizationHints |
A static class that provides optimization hints for memory or performance handling of sequence data.
|
| SequenceOptimizationHints.SequenceCollection |
|
| SequenceOptimizationHints.SequenceUsage |
|
| SequencePair<S extends Sequence<C>,C extends Compound> |
Defines a data structure for the results of pairwise sequence alignment.
|
| SequenceParser |
|
| SequenceParserInterface |
|
| SequenceProxyView<C extends Compound> |
|
| SequenceReader<C extends Compound> |
|
| SequenceRelation |
|
| SequenceRelation.SEQUENCE_RELATION_TYPE |
|
| SequenceRelationParser |
|
| SequenceScalePanel |
A class that draws a Sequence as a rectangle, a scale display over it.
|
| SequenceTools |
|
| SequenceUtil |
Utility class for operations on sequences
|
| SequenceView<C extends Compound> |
|
| SequenceWriter |
|
| SequenceWriter.SEQ_FORMAT |
|
| SequentialColorPalettePanel |
Creates a color palette of sequential colors defined by ColorBrewer
|
| SerializableCache<K,V> |
A class that provides all that is necessary to create a Serializable Cache
|
| set_comparator |
|
| shared_chars_in_ext_nodes |
|
| ShortSegmentRemover |
|
| ShowPDBIDListener |
|
| ShowStructureInJmol |
Demo how to load and display a structure in Jmol
|
| SiftsChainEntry |
An entry in the chain-level SIFTS mapping between UniProt and the PDB.
|
| SiftsChainToUniprotMapping |
A mapping between UniProt entries and PDB chains.
|
| SiftsEntity |
|
| SiftsMappingProvider |
|
| SiftsResidue |
|
| SiftsSegment |
|
| SiftsXMLParser |
|
| SigEva |
|
| simple_node_processor |
|
| SimpleAlignedSequence<S extends Sequence<C>,C extends Compound> |
Implements a data structure for a Sequence within an alignment. |
| SimpleDomain |
|
| SimpleGapPenalty |
Implements a data structure for the gap penalties used during a sequence alignment routine.
|
| SimpleLocation |
Very basic implementation of the Location interface which defines a series
of simple constructors.
|
| SimpleMMcifConsumer |
A MMcifConsumer implementation that builds an in-memory representation of the
content of a mmcif file as a BioJava Structure object.
|
| SimpleMMcifParser |
A simple mmCif file parser
Usage:
|
| SimplePoint |
Basic implementation of the Point interface.
|
| SimpleProfile<S extends Sequence<C>,C extends Compound> |
Implements a data structure for the results of sequence alignment.
|
| SimpleProfilePair<S extends Sequence<C>,C extends Compound> |
Implements a data structure for the results of the alignment of a pair of Profiles. |
| SimpleProfileProfileAligner<S extends Sequence<C>,C extends Compound> |
|
| SimpleSequencePair<S extends Sequence<C>,C extends Compound> |
Implements a data structure for the results of pairwise sequence alignment.
|
| SimpleSubstitutionMatrix<C extends Compound> |
Implements a data structure which holds the score (penalty or bonus) given during alignment for the exchange of one
Compound in a sequence for another. |
| SimpleTwoBitFileProvider |
Created by yana on 4/4/17.
|
| SingleCompoundSequenceReader<C extends Compound> |
An implementation of the SequenceReader interface which for every
call will return only 1 compound (given to it during construction; a String
is also valid but will require a CompoundSet).
|
| SingleLinkageClusterer |
An implementation of a single linkage clusterer
See http://en.wikipedia.org/wiki/Single-linkage_clustering
|
| SingularValueDecomposition |
Singular Value Decomposition.
|
| Site |
Created by ap3 on 31/10/2014.
|
| Site |
Holds the data of sites presented in PDB files.
|
| SmallAnnotation |
Annotation that is optimized for memory usage.
|
| SmallMap |
Lightweight implementation of Map which uses little memory to store a
small number of mappings, at the expense of scalability.
|
| SmithWaterman<S extends Sequence<C>,C extends Compound> |
Smith and Waterman defined an algorithm for pairwise local sequence alignments (best match of sections from each
Sequence). |
| SmithWaterman3Daligner |
Provides a 3D superimposition of two structures based on their sequence
alignment.
|
| SmithWaterman3DParameters |
|
| SmithWatermanUserArgumentProcessor |
|
| SmithWatermanUserArgumentProcessor.SmithWatermanStartupParams |
|
| SoftHashMap<K,V> |
A in memory cache using soft references.
|
| SolexaFastqReader |
|
| SolexaFastqWriter |
|
| SpaceGroup |
A crystallographic space group.
|
| SpaceGroupMapElements |
|
| SpaceGroupMapRoot |
|
| SparseSquareMatrix |
A sparse, square matrix, implementing using two arrays of sparse
vectors, one representation for the rows and one for the columns.
|
| SparseVector |
A sparse vector, implemented using a symbol table.
|
| Species |
|
| SphereSampler |
Sample possible orientations.
|
| SplitFasta |
Utility to write each Fasta entry to a unique file
|
| SqrtColorMapper |
Performs a sqrt transform on input before passing the values off to another
colorMapper.
|
| SSBondImpl |
A simple bean to store disulfide bridge information, the SSBOND records in the PDB files.
|
| Sset |
|
| StainType |
|
| StandardAminoAcid |
A class that provides a set of standard amino acids.
|
| StandardRescoreRefiner<S extends Sequence<C>,C extends Compound> |
|
| StartCodonSequence |
Used to map the start codon feature on a gene
|
| StartupParameters |
a simple bean that contains the parameters that can get set at startup
|
| StaticMemberPlaceHolder |
|
| StatusDisplay |
|
| StdArrayIO |
Standard array IO.
|
| StockholmFileAnnotation |
Stores all the content parsed from the #=GF lines
|
| StockholmFileAnnotation.StockholmFileAnnotationReference |
|
| StockholmFileParser |
|
| StockholmStructure |
Stores all the content of a Stockholm file.
|
| StockholmStructure.DatabaseReference |
|
| Stoichiometry |
A utility object that describes Stoichiometry (composition of a protein assembly),
determined via clustering procedure SubunitClusterer,
and implements human-readable representation using various strategies. |
| Stoichiometry.StringOverflowStrategy |
What to do when the number of SubunitCluster exceeds the length of the alphabet. |
| StopCodonSequence |
Used to map the stop codon sequence on a gene
|
| Strand |
Provides a way of representing the strand of a sequence, location
hit or feature.
|
| StrataInfo |
Information needed to represent a survival curve
|
| StrCompAlignment |
|
| StreamListener |
Event based parser callback.
|
| StringInt |
|
| StringInt.DescendingIntComparator |
|
| StringManipulationHelper |
A utility class for common String manipulation tasks.
|
| StringProxySequenceReader<C extends Compound> |
An example of a ProxySequenceReader that is created from a String.
|
| StrucAligParameters |
A class that contains all the parameters of the structure alignment algorithm.
|
| Struct |
a bean to contain the data of the _struct lines
|
| StructAsym |
Contains the data for _struct_asym
|
| StructConn |
A bean that stores data from the mmcif category _struct_conn
|
| StructKeywords |
|
| StructNcsOper |
A class containing the _struct_ncs_oper data
|
| StructRef |
A class to containt the _struct_ref field data
|
| StructRefSeq |
|
| StructRefSeqDif |
A class to store sequence mismatch annotations
|
| StructSite |
Created by Matt on 11/1/2015.
|
| StructSiteGen |
Created by Matt on 10/31/2015.
|
| Structure |
Interface for a structure object.
|
| StructureAlignment |
|
| StructureAlignmentDisplay |
|
| StructureAlignmentFactory |
|
| StructureAlignmentJmol |
A class that provides a simple GUI for Jmol
|
| StructureAlignmentOptimizer |
|
| StructureAtom |
Everything that is needed to uniquely describe a atom.
|
| StructureAtomLinkage |
|
| StructureAtomXMLConverter |
|
| StructureException |
An exception during the parsing of a PDB file.
|
| StructureGroup |
Information of a group (residue or ligand) involved in a modification.
|
| StructureGroupXMLConverter |
|
| StructureIdentifier |
An identifier that uniquely identifies a whole Structure or
arbitrary substructure. |
| StructureImpl |
Implementation of a PDB Structure.
|
| StructureInterface |
An interface between 2 molecules (2 sets of atoms).
|
| StructureInterfaceCluster |
|
| StructureInterfaceList |
A list of interfaces between 2 molecules (2 sets of atoms)
|
| StructureIO |
A class that provides static access methods for easy lookup of protein structure related components
|
| StructureIO.StructureFiletype |
|
| StructureIOFile |
StructureIOFile extends StructureProvider with methods specific to
parsing files from the filesystem.
|
| StructureLoaderThread |
|
| StructureName |
A utility class that makes working with names of structures, domains and ranges easier.
|
| StructureName.Source |
|
| StructurePairAligner |
Perform a pairwise protein structure superimposition.
|
| StructurePairSelector |
To be implemented by JPanels that are part of the GUI to trigger structure aligmnents.
|
| StructureProvider |
A class that can provide a protein structure object from somewhere.
|
| StructureSequenceMatcher |
A utility class with methods for matching ProteinSequences with
Structures.
|
| StructureTools |
A class that provides some tool methods.
|
| StructureUtil |
|
| StructureViewer |
|
| SubstitutionMatrix<C extends Compound> |
Defines a data structure which holds the score (penalty or bonus) given during alignment for the exchange of one
Compound in a sequence for another. |
| SubstitutionMatrixHelper |
Static utility to access substitution matrices that come bundled with BioJava.
|
| SubstitutionMatrixScorer<S extends Sequence<C>,C extends Compound> |
Scores using a substitution matrix.
|
| SubstructureIdentifier |
This is the canonical way to identify a part of a structure.
|
| subtree_feature_count |
|
| Subunit |
A Subunit consists of a set of residues from a Structure, which may
correspond to an entire Chain, a Domain, or any subset or combination of
residues from them.
|
| SubunitCluster |
|
| SubunitClusterer |
|
| SubunitClustererMethod |
The SubunitClustererMethod ennummerates all methods that can be used to
cluster Subunit in the SubunitCluster. |
| SubunitClustererParameters |
The SubunitClustererParameters specifies the options used for the clustering
of the subunits in structures using the SubunitClusterer. |
| SubunitExtractor |
The SubunitExtractor extracts the information of each protein Chain
in a Structure and converts them into a List of Subunit. |
| SuperPosition |
The SuperPosition interface defines and documents the required methods for
any superpostion algorithm implementation, so that the input and expected
output are uniform.
|
| SuperPositionAbstract |
The SuperPositionAbstract contains common code shared by all SuperPosition
algorithm implementations.
|
| SuperPositionQCP |
Implementation of the Quaternion-Based Characteristic Polynomial algorithm
for RMSD and Superposition calculations.
|
| SuperPositionQuat |
The SuperPositionQuat implements a quaternion based algorithm to superpose
arrays of Points in 3D.
|
| SuperPositions |
SuperPositions is a Class that provides static helper methods and an easy
access to the whole family of SuperPosition algorithms. |
| SuperPositionSVD |
A class that calculates the superposition between two sets of points using an
SVD Matrix Decomposition.
|
| support_statistics |
|
| support_transfer |
|
| SupportCount |
|
| surfacing |
|
| SurfacingConstants |
|
| SurfacingUtil |
|
| SurvFitInfo |
Contains info for graphing km figures
|
| SurvFitKM |
Ported from survfitKM.S When combining multiple entries with same time not
sure how the weighting adds up
|
| SurvFitKM.ConfLower |
|
| SurvFitKM.ConfType |
|
| SurvFitKM.Error |
|
| SurvFitKM.Method |
|
| SurvivalInfo |
Data class to represent a single sample where time and event/censor status is required
Additionally each variable and data associated with that variable.
|
| SurvivalInfoComparator |
|
| SurvivalInfoHelper |
Used to work with SurvivalInfo
|
| SurvivalInfoIndex |
Not used and probably should be deleted
|
| SurvivalInfoValueComparator |
|
| SymbolTable<Key extends java.lang.Comparable<Key>,Value> |
Sorted symbol table implementation using a java.util.TreeMap.
|
| SymmClash |
Java class for anonymous complex type.
|
| SymmetricalDistanceMatrixParser |
|
| SymmetricalDistanceMatrixParser.InputMatrixType |
|
| Symmetry |
|
| SymmetryAxes |
Data Structure that stores all the symmetry axis that describe
the symmetry of a structure.
|
| SymmetryAxes.Axis |
Represents an axis of symmetry
|
| SymmetryCalc |
Calculates a symmetry analysis and displays the results.
|
| SymmetryDisplay |
Class that provides visualizations methods for symmetry alignments.
|
| SymmetryGui |
A JFrame that allows to trigger a symmetry analysis, either from files
in a directory or after manual upload
Adapted from the AlignmentGui class in biojava.
|
| SymmetryListener |
Action Listener for the symmetry menu.
|
| SymmetryPerceptionMethod |
|
| SymmetryRefiner |
Interface for all symmetry refinement implementations.
|
| SymmetryTools |
Utility methods for symmetry (quaternary and internal) detection and result
manipulation.
|
| SymmOptimizer |
Optimizes a symmetry alignment by a Monte Carlo score optimization of the
repeat multiple alignment.
|
| SymoplibParser |
A class containing static methods to parse the symop.lib file from the
CCP4 package.
|
| SynchronizedOutFile |
|
| Synonym |
|
| SystematicSolver |
|
| SystemCommandExecutor |
|
| SystemInfo |
|
| TabDelimParser |
Parse tab-delimited ontology files into Ontology objects.
|
| Table |
Provides a way of separating us from the specific IUPACParser.IUPACTable even
though this is the only implementing class for the interface. |
| Table.CaseInsensitiveTriplet |
Class used to hold three nucleotides together and allow for equality
to be assessed in a case insensitive manner.
|
| Table.Codon |
|
| table2fasta |
|
| tax_code_cleaner |
|
| Taxonomy |
|
| TaxonomyColors |
|
| TaxonomyDataManager |
|
| TaxonomyID |
A sequence can be associated with a species or Taxonomy ID
|
| TaxonomyParser |
|
| TaxonomyUtil |
|
| Term |
A term in an ontology.
|
| Term.Impl |
Simple in-memory implementation of an ontology term.
|
| TertiaryBasePairParameters |
This class also finds the base pairing and base-pair step parameters but has a broader definition
of a base pair so that non-canonical-WC base pairs will be detected and reported.
|
| Test |
|
| Test |
|
| Test |
|
| TestDNANeedlemanWunsch |
|
| TestGo |
|
| TestGSDI |
|
| TestPccx |
|
| TestPhylogenyReconstruction |
|
| TestRIO |
|
| TestSurfacing |
|
| Tetrahedron |
|
| TextFeature<S extends AbstractSequence<C>,C extends Compound> |
A implmentation of AbstractFeature
|
| Time |
|
| Timer |
A simple timer, calculates the time interval between two events.
|
| TolParser |
|
| TolXmlHandler |
|
| TolXmlMapping |
|
| TranscriptionEngine |
Used as a way of encapsulating the data structures required to parse DNA to a
Protein sequence.
|
| TranscriptionEngine.Builder |
This class is the way to create a TranslationEngine.
|
| TranscriptSequence |
This is the sequence if you want to go from a gene sequence to a protein sequence.
|
| TransfAlgebraicAdapter |
|
| TransformType |
|
| TranslationException |
Thrown from AbstractCompundTranslator
|
| TreeColorSet |
|
| TreeConstructor |
The TreeConstructor uses the forester library to build different types of
phylogenetic trees.
|
| TreeConstructorType |
The TreeConstructorType specifies the aligorithm used to construct the tree
(clustering algorithm).
|
| TreeFontSet |
|
| TreeMapSpaceGroupWrapper |
|
| TreePanel |
|
| TreePanelUtil |
|
| TreeSetStringWrapper |
|
| TreeSplitMatrix |
|
| TreeType |
The TreeType specifies the optimization criteria used to generate the tree.
|
| Triple |
A triple in an ontology.
|
| Triple.Impl |
Basic in-memory implementation of a Triple in an ontology
This can be used to implement Ontology.createTriple
|
| TwoBitFacade |
A facade that makes it easier to work with a 2bit file.
|
| TwoBitParser |
downloaded from http://storage.bioinf.fbb.msu.ru/~roman/TwoBitParser.java
Class is a parser of UCSC Genome Browser file format .2bit used to store
nucleotide sequence information.
|
| TwoBitSequenceReader<C extends NucleotideCompound> |
Implementation of the 2bit encoding.
|
| TwoBitSequenceReader.TwoBitArrayWorker<C extends NucleotideCompound> |
Extension of the BitArrayWorker which provides the 2bit implementation
code.
|
| TxSearch |
This is to access the Web API for Biology (WABI) at DDBJ.
|
| TxSearch.RANKS |
|
| TxSearch.TAX_NAME_CLASS |
|
| TxSearch.TAX_RANK |
|
| UncompressInputStream |
This class decompresses an input stream containing data compressed with
the unix "compress" utility (LZC, a LZW variant).
|
| UniProtEntry |
|
| UniprotProxySequenceReader<C extends Compound> |
Pass in a Uniprot ID and this ProxySequenceReader when passed to a ProteinSequence will get the sequence data and other data elements
associated with the ProteinSequence by Uniprot.
|
| UniProtTaxonomy |
|
| UniprotToFasta |
|
| UnitCellBoundingBox |
A class to contain the BoundingBoxes of all polymeric molecules in a full unit cell.
|
| UnitQuaternions |
UnitQuaternions is a static Class that contains methods for calculating and
using unit quaternions.
|
| Uri |
|
| UriParser |
|
| URLConnectionTools |
A class that takes care about opening URLConnections and sets the proper timeouts
|
| URLIdentifier |
Represents a structure loaded from a URL (including a file URL)
A few custom query parameters are supported:
format=[pdb|cif] Specify the file format (will otherwise be
guessed from the extension)
pdbId=[String] Specify the PDB ID (also guessed from the filename)
chainID=[String] A single chain from the structure
residues=[String] Residue ranges, in a form understood by
SubstructureIdentifier
|
| UrlTreeReader |
|
| UserArgumentProcessor |
|
| UserConfiguration |
A container to persist config to the file system
|
| Utils |
This is a utility class that contains utility methods which will facilitates the coding of other methods
|
| Variable |
|
| Variable.Impl |
|
| WabiTools |
|
| WaldTest |
|
| WaldTestInfo |
|
| WeakValueHashMap |
Map implementation which keeps weak references to values.
|
| WebservicesManager |
|
| WebservicesManager.WsPhylogenyFormat |
|
| WebserviceUtil |
|
| WebStartClientDemo |
|
| WebStartDBSearch |
A Web Start wrapper for a FarmJobRunnable.
|
| WebStartDBSearchResults |
|
| WebStartMain |
|
| wiki_examples |
|
| WindowedSequence<C extends Compound> |
A sliding window view of a sequence which does not implement any
interfaces like Sequence because they do not fit how this works. |
| WindowsUtils |
|
| WorkSheet |
Need to handle very large spreadsheets of expression data so keep memory
footprint low
|
| WrapLayout |
FlowLayout subclass that fully supports wrapping of components.
|
| WwPDBValidationInformation |
Java class for anonymous complex type.
|
| XmlElement |
|
| XMLHelper |
|
| XMLUtil |
Utility classes for the XML serialization and de-serialization of SCOP.
|
| XMLWriter |
Simple interface for building XML documents.
|
| ZipChemCompProvider |
This chemical component provider retrieves and caches chemical component definition files from a
zip archive specified in its construction.
|