| Modifier and Type | Method and Description |
|---|---|
static void |
DemoAlignmentFromFasta.getAlignmentFromFasta() |
static void |
DemoAlignmentFromFasta.main(String[] args) |
static void |
DemoQuatSymmetryJmol.main(String[] args) |
static void |
AFPFromFasta.main(String[] args) |
static void |
DemoQsAlign.main(String[] args) |
static void |
DemoMmtfWriter.main(String[] args) |
static void |
DemoMmtfReader.main(String[] args)
Main function to run the demo
|
static void |
DemoAsa.main(String[] args) |
static void |
DemoCeSymm.main(String[] args) |
static void |
DemoContacts.main(String[] args) |
static void |
DemoMultipleMC.main(String[] args) |
static void |
DemoLoadSecStruc.main(String[] args) |
static void |
DemoSecStrucCalc.main(String[] args) |
| Modifier and Type | Method and Description |
|---|---|
static Atom[] |
Calc.centerAtoms(Atom[] atomSet)
Center the atoms at the Centroid.
|
static Atom[] |
Calc.centerAtoms(Atom[] atomSet,
Atom centroid)
Center the atoms at the Centroid, if the centroid is already know.
|
static Atom |
Calc.createVirtualCBAtom(AminoAcid amino)
creates a virtual C-beta atom. this might be needed when working with GLY
thanks to Peter Lackner for a python template of this method.
|
Chain |
StructureImpl.findChain(String chainId)
Request a particular chain from a structure.
|
Chain |
Structure.findChain(String authId)
Deprecated.
|
Chain |
StructureImpl.findChain(String chainName,
int modelnr)
Request a particular chain from a particular model
|
Chain |
Structure.findChain(String authId,
int modelnr)
Deprecated.
|
Group |
StructureImpl.findGroup(String chainName,
String pdbResnum)
Request a particular group from a structure.
|
Group |
Structure.findGroup(String authId,
String pdbResnum)
Request a particular group from a structure.
|
Group |
StructureImpl.findGroup(String chainName,
String pdbResnum,
int modelnr)
Request a particular group from a structure.
|
Group |
Structure.findGroup(String authId,
String pdbResnum,
int modelnr)
Request a particular group from a structure.
|
static List<Structure> |
StructureIO.getBiologicalAssemblies(String pdbId)
Returns all biological assemblies for the given PDB id,
using multiModel=
If only one biological assembly is required use
StructureIO.getBiologicalAssembly(String) or StructureIO.getBiologicalAssembly(String, int) instead. |
static List<Structure> |
StructureIO.getBiologicalAssemblies(String pdbId,
boolean multiModel)
Returns all biological assemblies for the given PDB id.
|
static Structure |
StructureIO.getBiologicalAssembly(String pdbId)
Returns the first biological assembly that is available for the given PDB id,
using multiModel=
For more documentation on quaternary structures see:
http://pdb101.rcsb.org/learn/guide-to-understanding-pdb-data/biological-assemblies |
static Structure |
StructureIO.getBiologicalAssembly(String pdbId,
boolean multiModel)
Returns the first biological assembly that is available for the given PDB id.
|
static Structure |
StructureIO.getBiologicalAssembly(String pdbId,
int biolAssemblyNr)
Returns the biological assembly for the given PDB id and bioassembly identifier,
using multiModel=
|
static Structure |
StructureIO.getBiologicalAssembly(String pdbId,
int biolAssemblyNr,
boolean multiModel)
Returns the biological assembly for the given PDB id and bioassembly identifier.
|
Chain |
StructureImpl.getChainByPDB(String chainId)
Request a chain by its public id (author id) for the first model.
|
Chain |
Structure.getChainByPDB(String authId)
Deprecated.
use
Structure.getPolyChainByPDB(String) instead |
Chain |
StructureImpl.getChainByPDB(String authId,
int modelnr)
Request a chain by its public id (author id) for the given model index.
|
Chain |
Structure.getChainByPDB(String authId,
int modelIdx)
Deprecated.
use
Structure.getPolyChainByPDB(String,int) instead |
Group |
Chain.getGroupByPDB(ResidueNumber resNum)
Get a group by its PDB residue numbering.
|
Group |
ChainImpl.getGroupByPDB(ResidueNumber resNum)
Get a group by its PDB residue numbering.
|
static Group |
StructureTools.getGroupByPDBResidueNumber(Structure struc,
ResidueNumber pdbResNum)
Get a group represented by a ResidueNumber.
|
Group[] |
Chain.getGroupsByPDB(ResidueNumber pdbresnumStart,
ResidueNumber pdbresnumEnd)
Get all groups that are located between two PDB residue numbers.
|
Group[] |
ChainImpl.getGroupsByPDB(ResidueNumber start,
ResidueNumber end)
Get all groups that are located between two PDB residue numbers.
|
Group[] |
Chain.getGroupsByPDB(ResidueNumber pdbresnumStart,
ResidueNumber pdbresnumEnd,
boolean ignoreMissing)
Get all groups that are located between two PDB residue numbers.
|
Group[] |
ChainImpl.getGroupsByPDB(ResidueNumber start,
ResidueNumber end,
boolean ignoreMissing) |
static double |
Calc.getPhi(AminoAcid a,
AminoAcid b)
Calculate the phi angle.
|
static double |
Calc.getPsi(AminoAcid a,
AminoAcid b)
Calculate the psi angle.
|
static Structure |
StructureTools.getReducedStructure(Structure s,
String chainId)
Deprecated.
Use
StructureIdentifier.reduce(Structure) instead (v. 4.2.0) |
static Structure |
StructureTools.getStructure(String name)
Short version of
StructureTools.getStructure(String, PDBFileParser, AtomCache)
which creates new parsers when needed |
static Structure |
StructureIO.getStructure(String name)
Loads a structure based on a name.
|
static Structure |
StructureTools.getStructure(String name,
PDBFileParser parser,
AtomCache cache)
Flexibly get a structure from an input String.
|
static double |
Calc.getTMScore(Atom[] atomSet1,
Atom[] atomSet2,
int len1,
int len2)
Calculate the TM-Score for the superposition.
|
static double |
Calc.getTMScore(Atom[] atomSet1,
Atom[] atomSet2,
int len1,
int len2,
boolean normalizeMin)
Calculate the TM-Score for the superposition.
|
Structure |
PassthroughIdentifier.loadStructure(AtomCache cache)
Passthrough identifiers don't know how to load a structure
|
Structure |
SubstructureIdentifier.loadStructure(AtomCache cache)
Loads the complete structure based on
SubstructureIdentifier.getPdbId(). |
Structure |
StructureIdentifier.loadStructure(AtomCache cache)
Loads a structure encompassing the structure identified.
|
Structure |
URLIdentifier.loadStructure(AtomCache cache)
Load the structure from the URL
|
Structure |
BioAssemblyIdentifier.loadStructure(AtomCache cache) |
Structure |
PassthroughIdentifier.reduce(Structure input) |
Structure |
SubstructureIdentifier.reduce(Structure s)
Takes a complete structure as input and reduces it to residues present in
the specified ranges
The returned structure will be a shallow copy of the input, with shared
Chains, Residues, etc.
|
Structure |
StructureIdentifier.reduce(Structure input)
Takes a complete structure as input and reduces it to the substructure
represented by this StructureIdentifier.
|
Structure |
URLIdentifier.reduce(Structure input) |
Structure |
BioAssemblyIdentifier.reduce(Structure input) |
static void |
Calc.rotate(Group group,
double[][] rotationmatrix)
Rotate a Group.
|
static void |
Calc.rotate(Structure structure,
double[][] rotationmatrix)
Rotate a structure.
|
SubstructureIdentifier |
StructureIdentifier.toCanonical()
Convert to a canonical SubstructureIdentifier.
|
SubstructureIdentifier |
BioAssemblyIdentifier.toCanonical() |
| Modifier and Type | Method and Description |
|---|---|
AFPChain |
BioJavaStructureAlignment.align(Atom[] ca1,
Atom[] ca2) |
AFPChain |
StructureAlignment.align(Atom[] ca1,
Atom[] ca2)
Run an alignment while specifying the atoms to be aligned.
|
abstract AFPChain |
AbstractStructureAlignment.align(Atom[] ca1,
Atom[] ca2) |
AFPChain |
BioJavaStructureAlignment.align(Atom[] ca1,
Atom[] ca2,
Object params) |
AFPChain |
StructureAlignment.align(Atom[] ca1,
Atom[] ca2,
Object params)
run an alignment and also send a bean containing the parameters.
|
abstract AFPChain |
AbstractStructureAlignment.align(Atom[] ca1,
Atom[] ca2,
Object params) |
void |
StructurePairAligner.align(Atom[] ca1,
Atom[] ca2,
StrucAligParameters params)
calculate the protein structure superimposition, between two sets of
atoms.
|
MultipleAlignment |
MultipleStructureAligner.align(List<Atom[]> atomArrays)
Run an alignment while specifying the atoms to be aligned.
|
MultipleAlignment |
MultipleStructureAligner.align(List<Atom[]> atomArrays,
Object params)
Run an alignment and also send a bean containing the parameters.
|
void |
StructurePairAligner.align(Structure s1,
String chainId1,
Structure s2,
String chainId2)
Align two chains from the structures.
|
void |
StructurePairAligner.align(Structure s1,
String chainId1,
Structure s2,
String chainId2,
StrucAligParameters params)
Aligns two chains from the structures using user provided parameters.
|
void |
StructurePairAligner.align(Structure s1,
Structure s2)
Calculate the alignment between the two full structures with default
parameters
|
void |
StructurePairAligner.align(Structure s1,
Structure s2,
StrucAligParameters params)
Calculate the alignment between the two full structures with user
provided parameters
|
static StructureAlignment |
StructureAlignmentFactory.getAlgorithm(String name) |
static Group[] |
AFPTwister.twistOptimized(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2)
superimposing according to the optimized alignment
|
static Group[] |
AFPTwister.twistPDB(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2)
calculate the total rmsd of the blocks output a merged pdb file for both
proteins protein 1, in chain A protein 2 is twisted according to the
twists detected, in chain B
|
| Modifier and Type | Method and Description |
|---|---|
AFPChain |
CeMain.align(Atom[] ca1,
Atom[] ca2) |
AFPChain |
OptimalCECPMain.align(Atom[] ca1,
Atom[] ca2,
Object param)
Finds the optimal alignment between two proteins allowing for a circular
permutation (CP).
|
AFPChain |
CeMain.align(Atom[] ca1,
Atom[] ca2,
Object param)
Align ca2 onto ca1.
|
AFPChain |
CeCPMain.align(Atom[] ca1,
Atom[] ca2,
Object param)
Aligns ca1 and ca2 using a heuristic to check for CPs.
|
AFPChain |
OptimalCECPMain.alignOptimal(Atom[] ca1,
Atom[] ca2,
Object param,
AFPChain[] alignments)
Finds the optimal alignment between two proteins allowing for a circular
permutation (CP).
|
AFPChain |
OptimalCECPMain.alignPermuted(Atom[] ca1,
Atom[] ca2,
Object param,
int cp)
Aligns ca1 with ca2 permuted by cp residues.
|
double |
CECalculator.calc_rmsd(Atom[] pro1,
Atom[] pro2,
int strLen,
boolean storeTransform)
superimpose and get rmsd
|
double |
CeCalculatorEnhanced.calc_rmsd(Atom[] pro1,
Atom[] pro2,
int strLen,
boolean storeTransform,
boolean show)
superimpose and get rmsd
|
AFPChain |
CeCalculatorEnhanced.extractFragments(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2) |
AFPChain |
CECalculator.extractFragments(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2) |
static AFPChain |
CeCPMain.filterDuplicateAFPs(AFPChain afpChain,
CECalculator ceCalc,
Atom[] ca1,
Atom[] ca2duplicated)
Takes as input an AFPChain where ca2 has been artificially duplicated.
|
static AFPChain |
CeCPMain.filterDuplicateAFPs(AFPChain afpChain,
CECalculator ceCalc,
Atom[] ca1,
Atom[] ca2duplicated,
CECPParameters params) |
void |
CeCalculatorEnhanced.nextStep(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2) |
void |
CECalculator.nextStep(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2) |
static AFPChain |
CeCPMain.postProcessAlignment(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2m,
CECalculator calculator)
Circular permutation specific code to be run after the standard CE alignment
|
static AFPChain |
CeCPMain.postProcessAlignment(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2m,
CECalculator calculator,
CECPParameters param)
Circular permutation specific code to be run after the standard CE alignment
|
| Modifier and Type | Method and Description |
|---|---|
String |
FarmJobRunnable.alignPair(String name1,
String name2) |
String |
FarmJobRunnable.alignPair(String name1,
String name2,
String algorithmName) |
StructureIdentifier |
StructureName.getBaseIdentifier()
StructureName wraps another StructureIdentifier.
|
String |
PdbPair.getPDBCode1() |
String |
PdbPair.getPDBCode2() |
String |
StructureName.getPdbId()
Get the PDB ID for this name, if any.
|
Structure |
StructureName.loadStructure(AtomCache cache) |
Structure |
StructureName.reduce(Structure input) |
SubstructureIdentifier |
StructureName.toCanonical() |
| Modifier and Type | Method and Description |
|---|---|
AFPChain |
FatCatRigid.align(Atom[] ca1,
Atom[] ca2) |
AFPChain |
FatCatFlexible.align(Atom[] ca1,
Atom[] ca2) |
protected AFPChain |
FatCat.align(Atom[] ca1,
Atom[] ca2,
FatCatParameters params,
boolean doRigid) |
AFPChain |
FatCatRigid.align(Atom[] ca1,
Atom[] ca2,
Object param) |
AFPChain |
FatCatFlexible.align(Atom[] ca1,
Atom[] ca2,
Object param) |
AFPChain |
FatCat.alignFlexible(Atom[] ca1,
Atom[] ca2,
FatCatParameters params) |
AFPChain |
FatCat.alignRigid(Atom[] ca1,
Atom[] ca2) |
AFPChain |
FatCat.alignRigid(Atom[] ca1,
Atom[] ca2,
FatCatParameters params) |
| Modifier and Type | Method and Description |
|---|---|
void |
FatCatAligner.align(Atom[] ca1,
Atom[] ca2,
boolean doRigid,
FatCatParameters params) |
static void |
AFPCalculator.extractAFPChains(FatCatParameters params,
AFPChain afpChain,
Atom[] ca1,
Atom[] ca2) |
static void |
AFPOptimizer.optimizeAln(FatCatParameters params,
AFPChain afpChain,
Atom[] ca1,
Atom[] ca2)
optimize the alignment by dynamic programming
|
void |
StructureAlignmentOptimizer.runOptimization(int maxi)
run the optimization
|
| Constructor and Description |
|---|
StructureAlignmentOptimizer(int b1,
int end1,
Atom[] c1,
int b2,
int end2,
Atom[] c2,
int iniLen,
int[][] iniSet)
optimize the structural alignment by update the equivalent residues
and then run dynamic programming
input: len1 the length of structure 1; c1: the structure information of 1
len2 the length of structure 2; c2: the structure information of 2
iniLen and iniSet is the length and list of initial equivalent residues
|
| Modifier and Type | Method and Description |
|---|---|
static Structure |
DisplayAFP.createArtificalStructure(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2)
Create a "fake" Structure objects that contains the two sets of atoms aligned on top of each other.
|
static StructureAlignmentJmol |
StructureAlignmentDisplay.display(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2)
Display an AFPChain alignment
|
static StructureAlignmentJmol |
DisplayAFP.display(AFPChain afpChain,
Group[] twistedGroups,
Atom[] ca1,
Atom[] ca2,
List<Group> hetatms1,
List<Group> hetatms2)
Note: ca2, hetatoms2 and nucleotides2 should not be rotated.
|
static MultipleAlignmentJmol |
MultipleAlignmentJmolDisplay.display(MultipleAlignment multAln)
Display a MultipleAlignment with a JmolPanel.
|
static Atom[] |
DisplayAFP.getAtomArray(Atom[] ca,
List<Group> hetatms)
Returns the first atom for each group
|
static Atom |
DisplayAFP.getAtomForAligPos(AFPChain afpChain,
int chainNr,
int aligPos,
Atom[] ca,
boolean getPrevious)
Return the atom at alignment position aligPos. at the present only works with block 0
|
Structure |
SelectPDBPanel.getStructure1() |
Structure |
SelectPDBPanel.getStructure2() |
static void |
DisplayAFP.showAlignmentPanel(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2,
AbstractAlignmentJmol jmol) |
static void |
MultipleAlignmentJmolDisplay.showMultipleAligmentPanel(MultipleAlignment multAln,
AbstractAlignmentJmol jmol)
Creates a new Frame with the MultipleAlignment Sequence Panel.
|
| Constructor and Description |
|---|
MultipleAligPanel(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2,
AbstractAlignmentJmol jmol)
Constructor using an afpChain and the atom arrays for pairwise
alignments.
|
| Modifier and Type | Method and Description |
|---|---|
void |
MultipleAlignmentEnsembleImpl.updateAtomArrays()
Force the atom arrays to regenerate based on
MultipleAlignmentEnsembleImpl.getStructureIdentifiers(). |
| Modifier and Type | Method and Description |
|---|---|
MultipleAlignment |
MultipleMcMain.align(List<Atom[]> atomArrays) |
MultipleAlignment |
MultipleMcMain.align(List<Atom[]> atomArrays,
Object parameters) |
MultipleAlignment |
MultipleMcOptimizer.optimize()
Optimization method based in a Monte-Carlo approach.
|
| Modifier and Type | Method and Description |
|---|---|
static void |
MultipleAlignmentScorer.calculateScores(MultipleAlignment alignment)
Calculates and puts the RMSD and the average TM-Score of the
MultipleAlignment.
|
static Structure |
MultipleAlignmentTools.getAlignedStructure(List<Atom[]> atomArrays)
Get an artificial Structure containing a different model for every
input structure, so that the alignment result can be viewed in Jmol.
|
static double |
MultipleAlignmentScorer.getAvgTMScore(List<Atom[]> transformed,
List<Integer> lengths)
Calculates the average TMScore all the possible pairwise structure
comparisons of the given a set of superimposed Atoms and the original
structure lengths.
|
static double |
MultipleAlignmentScorer.getAvgTMScore(MultipleAlignment alignment)
Calculates the average TMScore of all the possible pairwise structure
comparisons of the given alignment.
|
static double |
MultipleAlignmentScorer.getMCScore(MultipleAlignment alignment,
double gapOpen,
double gapExtension,
double dCutoff)
Calculates the MC score, specific for the MultipleAlignment algorithm.
|
static double |
MultipleAlignmentScorer.getRefTMScore(List<Atom[]> transformed,
List<Integer> lengths,
int reference)
Calculates the average TMScore from all structures to a reference
structure, given a set of superimposed atoms.
|
static double |
MultipleAlignmentScorer.getRefTMScore(MultipleAlignment alignment,
int ref)
Calculates the average TMScore from all structures to a reference
structure, given a set of superimposed atoms.
|
static List<Atom[]> |
MultipleAlignmentDisplay.getRotatedAtoms(MultipleAlignment multAln)
New structures are downloaded if they were not cached in the alignment
and they are entirely transformed here with the superposition information
in the Multiple Alignment.
|
void |
MultipleSuperimposer.superimpose(MultipleAlignment alignment)
Superimpose all structures from a
MultipleAlignment. |
void |
ReferenceSuperimposer.superimpose(MultipleAlignment alignment) |
void |
CoreSuperimposer.superimpose(MultipleAlignment alignment) |
static String |
MultipleAlignmentWriter.to3DFormat(MultipleAlignment alignment,
int queryIndex,
int templateIndex)
Outputs a pairwise alignment in I-TASSER's 3D Format for target-template
alignment. http://zhanglab.ccmb.med.umich.edu/I-TASSER/option4.html
The format is closely related to a standard PDB file, but contains only
CA atoms and adds two columns for specifying the alignment:
ATOM 2001 CA MET 1 41.116 -30.727 6.866 129 THR
ATOM 2002 CA ALA 2 39.261 -27.408 6.496 130 ARG
ATOM 2003 CA ALA 3 35.665 -27.370 7.726 131 THR
ATOM 2004 CA ARG 4 32.662 -25.111 7.172 132 ARG
ATOM 2005 CA GLY 5 29.121 -25.194 8.602 133 ARG
Column 1 -30: Atom & Residue records of query sequence.
|
static Structure |
MultipleAlignmentTools.toMultimodelStructure(MultipleAlignment multAln,
List<Atom[]> transformedAtoms) |
| Modifier and Type | Method and Description |
|---|---|
JointFragments[] |
FragmentJoiner.approach_ap3(Atom[] ca1,
Atom[] ca2,
FragmentPair[] fraglst,
StrucAligParameters params) |
void |
AlternativeAlignment.calculateSuperpositionByIdx(Atom[] ca1,
Atom[] ca2) |
void |
FragmentJoiner.extendFragments(Atom[] ca1,
Atom[] ca2,
JointFragments[] fragments,
StrucAligParameters params) |
void |
FragmentJoiner.extendFragments(Atom[] ca1,
Atom[] ca2,
JointFragments fragments,
StrucAligParameters params) |
void |
AlternativeAlignment.finish(StrucAligParameters params,
Atom[] ca1,
Atom[] ca2) |
static double |
FragmentJoiner.getRMS(Atom[] ca1,
Atom[] ca2,
JointFragments frag)
get the RMS of the JointFragments pair frag
|
void |
AlternativeAlignment.refine(StrucAligParameters params,
Atom[] ca1,
Atom[] ca2)
Refinement procedure based on superposition and dynamic programming.
|
| Modifier and Type | Method and Description |
|---|---|
static QsAlignResult |
QsAlign.align(List<Subunit> s1,
List<Subunit> s2,
SubunitClustererParameters cParams,
QsAlignParameters aParams) |
static QsAlignResult |
QsAlign.align(Structure s1,
Structure s2,
SubunitClustererParameters cParams,
QsAlignParameters aParams) |
| Modifier and Type | Method and Description |
|---|---|
AFPChain |
SmithWaterman3Daligner.align(Atom[] ca1,
Atom[] ca2) |
AFPChain |
SmithWaterman3Daligner.align(Atom[] ca1,
Atom[] ca2,
Object parameters) |
| Modifier and Type | Method and Description |
|---|---|
static Map<Integer,Integer> |
AlignmentTools.alignmentAsMap(AFPChain afpChain)
Creates a Map specifying the alignment as a mapping between residue indices
of protein 1 and residue indices of protein 2.
|
static AFPChain |
AlignmentTools.createAFPChain(Atom[] ca1,
Atom[] ca2,
ResidueNumber[] aligned1,
ResidueNumber[] aligned2)
Fundamentally, an alignment is just a list of aligned residues in each
protein.
|
static Structure |
AFPAlignmentDisplay.createArtificalStructure(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2) |
static AFPChain |
AlignmentTools.deleteColumn(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2,
int block,
int pos)
Delete an alignment position from the original alignment object.
|
static AFPChain |
AlignmentTools.deleteHighestDistanceColumn(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2)
Find the alignment position with the highest atomic distance between the
equivalent atomic positions of the arrays and remove it from the
alignment.
|
static Structure |
AlignmentTools.getAlignedStructure(Atom[] ca1,
Atom[] ca2)
Get an artifical Structure containing both chains.
|
static double |
RotationAxis.getAngle(AFPChain afpChain)
Calculate the rotation angle for a structure
|
Atom[] |
AtomCache.getAtoms(String name)
Returns the CA atoms for the provided name.
|
Atom[] |
AtomCache.getAtoms(StructureIdentifier name) |
List<Structure> |
AtomCache.getBiologicalAssemblies(String pdbId,
boolean multiModel)
Returns all biological assemblies for given PDB id.
|
Structure |
AtomCache.getBiologicalAssembly(String pdbId,
boolean multiModel)
Returns the default biological unit (bioassemblyId=1, known in PDB as pdb1.gz).
|
Structure |
AtomCache.getBiologicalAssembly(String pdbId,
int bioAssemblyId,
boolean multiModel)
Returns the biological assembly for a given PDB ID and bioAssemblyId, by building the
assembly from the biounit annotations found in
Structure.getPDBHeader()
Note, the number of available biological unit files
varies. |
Atom[] |
AtomCache.getRepresentativeAtoms(String name)
Returns the representative atoms for the provided name.
|
Atom[] |
AtomCache.getRepresentativeAtoms(StructureIdentifier name) |
static Matrix |
AFPAlignmentDisplay.getRotMax(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2) |
Structure |
AtomCache.getStructure(String name)
Request a Structure based on a name.
|
Structure |
AtomCache.getStructure(StructureIdentifier strucId)
Get the structure corresponding to the given
StructureIdentifier. |
Structure |
AtomCache.getStructureForCathDomain(StructureName structureName)
Returns a
Structure corresponding to the CATH identifier supplied in structureName, using the the CathDatabase
at CathFactory.getCathDatabase(). |
Structure |
AtomCache.getStructureForCathDomain(StructureName structureName,
CathDatabase cathInstall)
Returns a
Structure corresponding to the CATH identifier supplied in structureName, using the specified CathDatabase. |
Structure |
AtomCache.getStructureForDomain(ScopDomain domain)
Returns the representation of a
ScopDomain as a BioJava Structure object. |
Structure |
AtomCache.getStructureForDomain(ScopDomain domain,
ScopDatabase scopDatabase)
Returns the representation of a
ScopDomain as a BioJava Structure object. |
Structure |
AtomCache.getStructureForDomain(ScopDomain domain,
ScopDatabase scopDatabase,
boolean strictLigandHandling)
Returns the representation of a
ScopDomain as a BioJava Structure object. |
Structure |
AtomCache.getStructureForDomain(String scopId)
Returns the representation of a
ScopDomain as a BioJava Structure object. |
Structure |
AtomCache.getStructureForDomain(String scopId,
ScopDatabase scopDatabase)
Returns the representation of a
ScopDomain as a BioJava Structure object. |
Structure |
AtomCache.getStructureForPdbId(String pdbId)
Loads a structure directly by PDB ID
|
static int |
AlignmentTools.getSymmetryOrder(AFPChain afpChain,
int maxSymmetry,
float minimumMetricChange)
Guesses the order of symmetry in an alignment
Uses
AlignmentTools.getSymmetryOrder(Map alignment, Map identity, int, float)
to determine the the symmetry order. |
static double |
AFPChainScorer.getTMScore(AFPChain align,
Atom[] ca1,
Atom[] ca2) |
static double |
AFPChainScorer.getTMScore(AFPChain align,
Atom[] ca1,
Atom[] ca2,
boolean normalizeMin) |
static Atom |
AFPAlignmentDisplay.getTranslation(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2) |
protected Structure |
AtomCache.loadStructureFromCifByPdbId(String pdbId) |
protected Structure |
AtomCache.loadStructureFromPdbByPdbId(String pdbId) |
static Group[] |
AlignmentTools.prepareGroupsForDisplay(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2)
Rotate the Atoms/Groups so they are aligned for the 3D visualisation
|
static AFPChain |
AlignmentTools.replaceOptAln(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2,
int blockNum,
int[] optLens,
int[][][] optAln) |
static AFPChain |
AlignmentTools.replaceOptAln(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2,
Map<Integer,Integer> alignment)
Takes an AFPChain and replaces the optimal alignment based on an alignment map
Parameters are filled with defaults (often null) or sometimes
calculated.
|
static AFPChain |
AlignmentTools.replaceOptAln(int[][][] newAlgn,
AFPChain afpChain,
Atom[] ca1,
Atom[] ca2)
It replaces an optimal alignment of an AFPChain and calculates all the new alignment scores and variables.
|
static AFPChain |
AlignmentTools.splitBlocksByTopology(AFPChain a,
Atom[] ca1,
Atom[] ca2) |
static void |
AlignmentTools.updateSuperposition(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2)
After the alignment changes (optAln, optLen, blockNum, at a minimum),
many other properties which depend on the superposition will be invalid.
|
| Constructor and Description |
|---|
RotationAxis(AFPChain afpChain)
Calculate the rotation axis for the first block of an AFPChain
|
| Modifier and Type | Method and Description |
|---|---|
static String |
AFPChainXMLParser.flipAlignment(String xml)
Takes an XML representation of the alignment and flips the positions of name1 and name2
|
static AFPChain |
AFPChainFlipper.flipChain(AFPChain o)
Flip the position of name1 and name2 (as well as all underlying data) in an AFPChain.
|
static AFPChain |
AFPChainXMLParser.fromXML(String xml,
String name1,
String name2,
Atom[] ca1,
Atom[] ca2)
new utility method that checks that the order of the pair in the XML alignment is correct and flips the direction if needed
|
| Modifier and Type | Method and Description |
|---|---|
Structure |
CathDomain.loadStructure(AtomCache cache) |
Structure |
CathDomain.reduce(Structure input) |
| Modifier and Type | Method and Description |
|---|---|
boolean |
SubunitCluster.divideInternally(SubunitClustererParameters clusterParams)
Analyze the internal symmetry of the SubunitCluster and divide its
Subunit into the internal repeats (domains) if they are
internally symmetric. |
MultipleAlignment |
SubunitCluster.getMultipleAlignment()
The multiple alignment is calculated from the equivalent residues in the
SubunitCluster.
|
boolean |
SubunitCluster.mergeStructure(SubunitCluster other,
SubunitClustererParameters params)
Merges the other SubunitCluster into this one if their representative
Atoms are structurally similar (according to the criteria in params).
|
| Modifier and Type | Method and Description |
|---|---|
Structure |
PDPProvider.getDomain(String pdpDomainName,
AtomCache cache)
Get the structure for a particular PDP domain
|
Structure |
RemotePDPProvider.getDomain(String pdpDomainName,
AtomCache cache)
Get the structure for a particular PDP domain
|
SortedSet<String> |
RemoteDomainProvider.getDomainNames(String name) |
SortedSet<String> |
DomainProvider.getDomainNames(String name)
Get a list of constituent domain identifiers
|
Structure |
PDPDomain.loadStructure(AtomCache cache) |
static void |
RemotePDPProvider.main(String[] args) |
static void |
RemoteDomainProvider.main(String[] args) |
Structure |
PDPDomain.reduce(Structure input) |
static List<Domain> |
LocalProteinDomainParser.suggestDomains(Atom[] ca)
Suggest domains for a set of Calpha atoms
|
static List<Domain> |
LocalProteinDomainParser.suggestDomains(Structure s)
Suggest domains for a protein structure
|
| Modifier and Type | Method and Description |
|---|---|
PDPDistanceMatrix |
GetDistanceMatrix.getDistanceMatrix(Atom[] protein)
A set of Calpha atoms that are representing the protein
|
| Modifier and Type | Method and Description |
|---|---|
Structure |
EcodDomain.loadStructure(AtomCache cache) |
Structure |
EcodDomain.reduce(Structure input) |
| Modifier and Type | Method and Description |
|---|---|
Structure |
PDBUploadPanel.getStructure1() |
Structure |
PDBServerPanel.getStructure1() |
Structure |
PDBDirPanel.getStructure1() |
Structure |
ScopSelectPanel.getStructure1() |
Structure |
StructurePairSelector.getStructure1() |
Structure |
PDBUploadPanel.getStructure2() |
Structure |
PDBServerPanel.getStructure2() |
Structure |
PDBDirPanel.getStructure2() |
Structure |
ScopSelectPanel.getStructure2() |
Structure |
StructurePairSelector.getStructure2() |
List<Structure> |
SelectMultiplePanel.getStructures() |
| Modifier and Type | Method and Description |
|---|---|
static AFPChain |
FastaAFPChainConverter.cpFastaToAfpChain(File fastaFile,
Structure structure,
int cpSite)
Takes a structure and sequence corresponding to an alignment between a structure or sequence and itself (or even a structure with a sequence), where the result has a circular permutation site
cpSite residues to the right. |
static AFPChain |
FastaAFPChainConverter.cpFastaToAfpChain(ProteinSequence first,
ProteinSequence second,
Structure structure,
int cpSite)
Takes a structure and sequence corresponding to an alignment between a structure or sequence and itself (or even a structure with a sequence), where the result has a circular permutation site
cpSite residues to the right. |
static AFPChain |
FastaAFPChainConverter.cpFastaToAfpChain(String first,
String second,
Structure structure,
int cpSite) |
static AFPChain |
FastaAFPChainConverter.fastaFileToAfpChain(File fastaFile,
Structure structure1,
Structure structure2)
Reads the file
fastaFile, expecting exactly two sequences which give a pairwise alignment. |
static AFPChain |
FastaAFPChainConverter.fastaStringToAfpChain(String sequence1,
String sequence2,
Structure structure1,
Structure structure2)
Returns an AFPChain corresponding to the alignment between
structure1 and structure2, which is given by the gapped protein sequences sequence1 and sequence2. |
static AFPChain |
FastaAFPChainConverter.fastaToAfpChain(Map<String,ProteinSequence> sequences,
Structure structure1,
Structure structure2)
Uses two sequences each with a corresponding structure to create an AFPChain corresponding to the alignment.
|
static AFPChain |
FastaAFPChainConverter.fastaToAfpChain(ProteinSequence sequence1,
ProteinSequence sequence2,
Structure structure1,
Structure structure2)
Returns an AFPChain corresponding to the alignment between
structure1 and structure2, which is given by the gapped protein sequences sequence1 and sequence2. |
static AFPChain |
FastaAFPChainConverter.fastaToAfpChain(SequencePair<Sequence<AminoAcidCompound>,AminoAcidCompound> alignment,
Structure structure1,
Structure structure2)
Provided only for convenience.
|
static AFPChain |
FastaAFPChainConverter.fastaToAfpChain(String sequence1,
String sequence2,
Structure structure1,
Structure structure2)
TODO Write comment
|
Structure |
StructureProvider.getStructureById(String pdbId)
Get the structure for a PDB ID
|
Structure |
SandboxStyleStructureProvider.getStructureById(String pdbId) |
static void |
FastaAFPChainConverter.main(String[] args)
Prints out the XML representation of an AFPChain from a file containing exactly two FASTA sequences.
|
void |
FastaStructureParser.process()
Parses the fasta file and loads it into memory.
|
| Modifier and Type | Method and Description |
|---|---|
Structure |
ScopDomain.loadStructure(AtomCache cache) |
Structure |
ScopDomain.reduce(Structure input) |
| Modifier and Type | Method and Description |
|---|---|
List<SecStrucState> |
SecStrucCalc.calculate(Structure s,
boolean assign)
Predicts the secondary structure of this Structure object,
using a DSSP implementation.
|
static List<SecStrucState> |
DSSPParser.fetch(String pdb,
Structure structure,
boolean assign)
Fetch and parse the DSSP file of the specified pdb code
from the PDB web server and return the secondary structure
annotation as a List of
SecStrucState objects. |
static List<SecStrucState> |
DSSPParser.parseFile(String dsspPath,
Structure structure,
boolean assign)
Parse a DSSP output file and return the secondary structure
annotation as a List of
SecStrucState objects. |
static List<SecStrucState> |
DSSPParser.parseInputStream(InputStream dsspIs,
Structure structure,
boolean assign)
Parse a DSSP output file and return the secondary structure
annotation as a List of
SecStrucState objects. |
static List<SecStrucState> |
DSSPParser.parseString(String dsspOut,
Structure structure,
boolean assign)
Parse a DSSP format String and return the secondary structure
annotation as a List of
SecStrucState objects. |
| Modifier and Type | Method and Description |
|---|---|
static AbstractAlignmentJmol |
SymmetryDisplay.display(CeSymmResult symmResult)
Displays a single structure in a cartoon representation with each
symmetric repeat colored differently.
|
static MultipleAlignmentJmol |
SymmetryDisplay.displayFull(CeSymmResult symm)
Displays a multiple alignment of the whole structure transformations
colored by blocks, corresponding to the symmetric protodomains.
|
static MultipleAlignmentJmol |
SymmetryDisplay.displayRepeats(CeSymmResult symm)
Displays a multiple alignment of the symmetry repeats
|
static String |
SymmetryDisplay.printSymmetryAxes(CeSymmResult symm)
Generates a String that displays the symmetry axes of a structure.
|
static String |
SymmetryDisplay.printSymmetryAxes(CeSymmResult symm,
boolean allAxes)
Generates a String that displays the symmetry axes of a structure.
|
static String |
SymmetryDisplay.printSymmetryGroup(CeSymmResult symm)
Given a symmetry alignment, it draws the symmetry group axes and the
polyhedron box around the structure.
|
| Modifier and Type | Method and Description |
|---|---|
protected static CeSymmResult |
CeSymm.align(Atom[] atoms,
CESymmParameters params) |
static CeSymmResult |
CeSymm.analyze(Atom[] atoms)
Analyze the symmetries of the input Atom array using the DEFAULT
parameters.
|
static CeSymmResult |
CeSymm.analyze(Atom[] atoms,
CESymmParameters params)
Analyze the symmetries of the input Atom array using the provided
parameters.
|
static CeSymmResult |
CeSymm.analyzeLevel(Atom[] atoms,
CESymmParameters params)
Analyze a single level of symmetry.
|
CeSymmResult |
CeSymmIterative.execute(Atom[] atoms)
This method uses iteratively CeSymm to calculate all symmetries in the
input array of atoms and organize them in a multiple alignment of the
repeats.
|
List<StructureIdentifier> |
CeSymmResult.getRepeatsID()
Return the symmetric repeats as structure identifiers, if the result is
symmetric and it was refined, return null otherwise.
|
MultipleAlignment |
SymmOptimizer.optimize()
Optimization method based in a Monte-Carlo approach.
|
MultipleAlignment |
SequenceFunctionRefiner.refine(AFPChain selfAlignment,
Atom[] atoms,
int order) |
MultipleAlignment |
SymmetryRefiner.refine(AFPChain selfAlignment,
Atom[] atoms,
int order)
Returns a refined symmetry alignment, where the repeat residues are
aligned consistently in a MultipleAlignment.
|
MultipleAlignment |
GraphComponentRefiner.refine(AFPChain selfAlignment,
Atom[] atoms,
int order) |
static AFPChain |
SequenceFunctionRefiner.refineSymmetry(AFPChain afpChain,
Atom[] ca1,
Atom[] ca2,
int k)
Refines a CE-Symm alignment so that it is perfectly symmetric.
|
static Map<Integer,Integer> |
SequenceFunctionRefiner.refineSymmetry(Map<Integer,Integer> alignment,
int k)
Refines a CE-Symm alignment so that it is perfectly symmetric.
|
| Modifier and Type | Method and Description |
|---|---|
static List<Structure> |
SymmetryTools.divideStructure(CeSymmResult symmetry)
Method that converts the symmetric units of a structure into different
structures, so that they can be individually visualized.
|
static MultipleAlignment |
SymmetryTools.fromAFP(AFPChain symm,
Atom[] atoms)
Converts a refined symmetry AFPChain alignment into the standard
representation of symmetry in a MultipleAlignment, that contains the
entire Atom array of the strcuture and the symmetric repeats are orgaized
in different rows in a single Block.
|
static QuatSymmetryResults |
SymmetryTools.getQuaternarySymmetry(CeSymmResult result)
Given a symmetry result, it calculates the overall global symmetry,
factoring out the alignment and detection steps of
QuatSymmetryDetector algorithm. |
static MultipleAlignment |
SymmetryTools.toRepeatsAlignment(CeSymmResult result)
Method that converts a symmetry alignment into an alignment of the
repeats only, as new independent structures.
|
static void |
SymmetryTools.updateSymmetryScores(MultipleAlignment symm)
Update the scores (TM-score and RMSD) of a symmetry multiple alignment.
|
static void |
SymmetryTools.updateSymmetryTransformation(SymmetryAxes axes,
MultipleAlignment msa)
Calculates the set of symmetry operation Matrices (transformations) of
the new alignment, based on the symmetry relations in the SymmetryAxes
object.
|
Copyright © 2000–2018 BioJava. All rights reserved.