You are reading the documentation for version 1.3 of ProMod3.
You may also want to read the documentation for:
2.0
2.1
3.0
3.1
3.2
Modelling Algorithms
A collection of algorithms that can be useful in modelling
Rigid Blocks
RMSD is a typical measure for similarity of two structures. Given an atom atom
mapping between two structures, the minimum RMSD and the according superposition
can efficiently be calculated using an approach based on singular value
decomposition. This approach is problematic if there are very dissimilar regions
or when domain movement events occur. We can therefore implement an iterative
superposition. The two structures undergo an initial superposition. For every
iteration we then select a subset of atoms that are within a certain distance
threshold that serve as input for the next superposition. This iterative
superpostion typically converges to the largest common subpart but is
nondeterministic since it depends on the initial superposition.
The RigidBlocks algorithm is based on only the CA positions and performs this
iterative superposition multiple times by using a sliding window to select the
initial subset and gathers all unique results. These results can be very
similar and only differ by single positions. The algorithm therefore reduces
the amount of solutions by merging them based on a threshold of similarity.
The similarity is defined by the fraction of positions in solution A that are
also present in solution B. As a final result, the algorithm therefore detects
common rigid subsets of positions.

promod3.modelling. RigidBlocks (bb_list_one, bb_list_two[, window_length = 12, max_iterations=20, distance_thresh=3.0, cluster_thresh=0.9])
Performs the RigidBlock algorithm on given input
Parameters: 
 bb_list_one (
promod3.loop.BackboneList ) – First piece structural information from which CA
positions will be extracted
 bb_list_two (
promod3.loop.BackboneList ) – Second piece of structural information from which CA
positions will be extracted
 window_length (
int ) – Length of sliding window to generate initial subsets
 max_iterations (
int ) – Maximal numbers of iterations for every single
iterative superposition
 distance_thresh (
float ) – Maximal distance two CA positions can have to be
considered in the same rigid block and to select
the common subset for the next iteration of the
iterative superposition
 cluster_thresh (
float ) – Threshold of similarity to perform the final merging
of the solutions

Returns:  tuple with the first element being a
list of list defining the
indices of the common subsets (rigid blocks) relative
to the input promod3.loop.BackboneList objects
and the second element being a list of
ost.geom.Mat4 defining the transformations to
superpose the according positions in bb_list_one
onto bb_list_two


promod3.modelling. RigidBlocks (aln[, seq_one_idx=0, seq_two_idx=1, window_length = 12, max_iterations=20, distance_thresh=3.0, cluster_thresh=0.9])
Performs the RigidBlock algorithm on given input
Parameters: 
 aln (
ost.seq.AlignmentHandle ) – An alignment with attached ost.mol.EntityView
objects from which the positions are extracted
 seq_idx_one (
int ) – The idx of the first sequence from which the CA
positions will be extracted
 seq_idx_two (
int ) – The idx of the second sequence from which the CA
positions will be extracted
 window_length (
int ) – Length of sliding window to generate initial subsets
 max_iterations (
int ) – Maximal numbers of iterations for every single
iterative superposition
 distance_thresh (
float ) – Maximal distance two CA positions can have to be
considered in the same rigid block and to select
the common subset for the next iteration of the
iterative superposition
 cluster_thresh (
float ) – Threshold of similarity to perform the final merging
of the solutions

Returns:  tuple with the first element being a
list of list defining the
column indices of the common subsets (rigid blocks)
relative to the input ost.seq.AlignmentHandle
and the second element being a list of
ost.geom.Mat4 defining the transformations to
superpose the according positions from the first
sequence onto the second sequence.


promod3.modelling. RigidBlocks (pos_one, pos_two[, window_length = 12, max_iterations=20, distance_thresh=3.0, cluster_thresh=0.9])
Performs the RigidBlock algorithm on given input
Parameters: 
 pos_one (
ost.geom.Vec3List ) – First piece position information
 pos_two (
ost.geom.Vec3List ) – Second piece of position information
 window_length (
int ) – Length of sliding window to generate initial subsets
 max_iterations (
int ) – Maximal numbers of iterations for every single
iterative superposition
 distance_thresh (
float ) – Maximal distance two CA positions can have to be
considered in the same rigid block and to select
the common subset for the next iteration of the
iterative superposition
 cluster_thresh (
float ) – Threshold of similarity to perform the final merging
of the solutions

Returns:  tuple with the first element being a
list of list defining the
indices of the common subsets (rigid blocks) relative
to the input ost.geom.Vec3List objects
and the second element being a list of
ost.geom.Mat4 defining the transformations to
superpose the according positions in pos_one
onto pos_two

De Novo Modelling
ProMod3 provides algorithms for sampling and fragment detection.
Here we provide an object, that facilitates fragment detection and caching,
as well as a convenient function to combine the functionalities into an
example pipeline.

class
promod3.modelling. FraggerHandle (sequence, profile=None, psipred_pred=None, fragment_length=9, fragments_per_position=100, rmsd_thresh=0.0, structure_db=None, torsion_sampler_coil=None, torsion_sampler_helix=None, torsion_sampler_extended=None)
Handler for Fragger objects linked to a
specific chain.
Tries to get the most accurate fragments given your input.
You can only provide a SEQRES, the returned fragments are
then searched by using sequence similarity as the only target value.
You can massively increase the accuracy of the found fragments by
providing a secondary structure prediction and / or sequence profile.
Following features influence the fragment search given your input:
 sequence:
 Sequence Similarity with BLOSUM62
 sequence, psipred_pred:
 Sequence Similarity with BLOSUM62
 Secondary Structure Agreement
 Secondary Structure Dependent Torsion Probabilities
 sequence, profile:
 Sequence Profile Score
 Structure Profile Score
 sequence, psipred_pred, profile:
 Secondary Structure Agreement
 Secondary Structure Dependent Torsion Probabilities
 Sequence Profile Score
 Structure Profile Score
The FraggerHandle internally uses the promod3.loop.FraggerMap for caching. You
can therefore request fragments for a certain position several times and the
search is performed only once. This also allows to save the FraggerHandle to
disk. When loading the FraggerHandle again, you need to provide all parameters
again. These parameters must be exactly the same than the ones you used when
initially constructing the FraggerHandle, especially the structure database.
Weird things are happening otherwise.

Get (frag_pos)
Get fragger for sequence at index frag_pos..frag_pos+frag_length1.
Parameters:  frag_pos (int ) – Startindex (note that sequenceindexing starts at 0) 
Returns:  A Fragger object. 
Raises:  ValueError if index outofbounds. 

GetList (pos_start=0, pos_end=1)
Get List of fraggers covering sequence indices pos_start..pos_end.
This will return an empty list if range is smaller than fragment_length.
Parameters: 
 pos_start (
int ) – Startindex (note that sequenceindexing starts at 0)
 pos_end (
int ) – Endindex or 1 if it should go to the sequenceend.

Returns:  A list of Fragger objects.

Raises:  ValueError if indices outofbounds.


LoadCached (filename)
Load fragger objects stored with SaveCached() .
Note that here we require that the same structure db is set as was
used when filename was saved.

SaveCached (filename)
Save cached fraggers.

promod3.modelling. GenerateDeNovoTrajectories (sequence, num_trajectories=200, avg_sampling_per_position=600, profile=None, psipred_prediction=None, fragment_handler=None, scorer=None, scorer_env=None, scoring_weights=None)
Example de novo modelling pipeline based on Fragment sampling and
backbone scoring. Take this as a starting point for more advanced
de novo procedures.
Parameters: 
 sequence (
str ) – The sequence you want to sample
 num_trajectories (
int ) – The number of sampling trajectories you
want to generate
 avg_sampling_per_position – Number of Monte Carlo sampling steps
the total number is:
len(sequence) * avg_sampling_per_position
 profile (
ost.seq.ProfileHandle ) – The sequence profile for sequence. This increases the
fragment search performance.
 psipred_prediction (
promod3.loop.PsipredPrediction ) – The psipred prediction for sequence. This
increases the fragment search performance
 fragment_handler (
promod3.modelling.FraggerHandle ) – You can provide already initialized fragments.
If you pass this parameter, profile and
psipred_prediction get neglected and do
not influence the fragment search, the
ones you initialized fragment_handler with
get used instead.
 scorer (
promod3.scoring.BackboneOverallScorer ) – Scorer doing the backbone scoring. If not provided, a
default one gets loaded with default objects with
following keys: clash, reduced, cb_packing, hbond, cbeta,
torsion and pairwise
 scorer_env (
promod3.scoring.BackboneScoreEnv ) – The scoring env that relates to scorer
This environment will be changed!
 scoring_weights (
dict ) – Linear weights for different scores. If not provided,
the output of ScoringWeights.GetWeights() is used.
Please note, that the weights must be consistent
with the keys of the scores in scorer

Returns:  A promod3.loop.LoopCandidates object containing
num_trajectories elements for further processing


Contents
Search
Enter search terms or a module, class or function name.
Previous topic
Sidechain Reconstruction
Next topic
sidechain  Sidechain Modelling
You are here
