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 non-deterministic 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.

Parameters:
Get(frag_pos)

Get fragger for sequence at index frag_pos..frag_pos+frag_length-1.

Parameters:frag_pos (int) – Start-index (note that sequence-indexing starts at 0)
Returns:A Fragger object.
Raises:ValueError if index out-of-bounds.
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) – Start-index (note that sequence-indexing starts at 0)
  • pos_end (int) – End-index or -1 if it should go to the sequence-end.
Returns:

A list of Fragger objects.

Raises:

ValueError if indices out-of-bounds.

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