schrodinger.protein.protassign.hbond_cluster module¶

Module containing the hbond_cluster class; used by ProtAssign.

schrodinger.protein.protassign.hbond_cluster.calculate_clash_term(distance, cutoff, base=50)¶: Return clash term

schrodinger.protein.protassign.hbond_cluster.calculate_distance_term(distance)¶: Return distance dependent part of the hydrogen-bond potential functions.

schrodinger.protein.protassign.hbond_cluster.calculate_angle_term(angle)¶

Return angle dependent part of the hydrogen bond potential.

Parameters

angle – Angle in degrees formed by H-D-A, with Hydrogen, Donor and Acceptor
angle – float

Returns

Score

Return type

float

schrodinger.protein.protassign.hbond_cluster.score_metal_donor(ct: schrodinger.structure._structure.Structure, metal: Tuple[int, int], donor: Tuple[int, int], use_xtal=False) → float¶: Score a metal-donor interaction. Donors should not be pointing towards metals. If so, this will result in a penalty

schrodinger.protein.protassign.hbond_cluster.score_acceptor_acceptor(ct: schrodinger.structure._structure.Structure, iacceptor: int, jacceptor: int, use_xtal: bool = False, acceptor_acceptor_clash_cutoff: float = 2.7) → float¶

Scoring function for acceptor-acceptor interactions.

These interactions are considered worse than clasher-donor hydrogen clashes, and its base penalty is thus higher. It is set so the scoring function is more robust and provides the correct flip for the Gln-541 state of 2X9E that interact with the ligand.

Returns: Score

schrodinger.protein.protassign.hbond_cluster.score_donor_acceptor(ct, donor_heavy, donor_hydrogen, acceptor_heavy, use_xtal=False)¶

class schrodinger.protein.protassign.hbond_cluster.hbond_cluster¶

Bases: object

__init__()¶

setup_xtal(ct, interaction_matrix, clustering_distance)¶

optimize(ct: schrodinger.structure._structure.Structure, interaction_matrix: Dict[int, Set[int]], static_donors: List[Tuple[int, int]], static_acceptors: List[int], static_clashers: List[int], max_comb: int, num_sequential_cycles: int, use_propka: bool, pH: float = 7.0, annotated_ct: Optional[schrodinger.structure._structure.Structure] = None, dcell=None)¶

Optimize hydrogen bond network and protonation states of changeables in this cluster

Parameters

ct – Structure containing changeables to optimize
interaction_matrix – Interaction lookup dict for changeable-changeable interactions
static_donors – List of static donor atom indices
static_acceptors – List of static acceptor atom indices
static_clashers – List of static clasher atom indices
max_comb – Maximum number of combinations at which an exhaustive search is performed.
num_sequential_cycles – Number of optimization cycles when using heuristic search.
use_propka – Use PROPKA to determine pKa values of changeables
pH – pH of system when using PROPKA for pKa determination
annotated_ct – Annotated structure that may contain xtal mates for faster optimization. Passing this, skips the creation of crystal mates and structure annotation during the self-scoring phase.
dcell – Pre-calculated distance cell to improve performance

solve_network_exact_and_diversify(ct, interaction_matrix, ncombinations, delta_energy=2.0)¶

Solve the network exact

Parameters

ct (Structure) – Structure
interaction_matrix (Dict[int, Set[int]]) – Changeable interaction lookup table
ncombinations (int) – Number of maximum combinations to return
delta_energy (float) – Maximum energy difference of combinations generated compared to the global minimum

Returns

List of combinations with first element being the global optimum combination or empty list if no optimum found

Return type

List[List[int]]

score_combination(ct, interaction_matrix, states)¶

single_point(ct, interaction_matrix, static_donors, static_acceptors, static_clashers, xtal_ct=None)¶

setup_local_static_alt(ct, static_acceptors, static_donors, static_clashers)¶

setup_local_static(ct, static_acceptors, static_donors, static_clashers)¶

pre_score_self(ct, dcell=None)¶

Calculate the self score for each state. Interactions are calculated between the changeable and its static environment.

Parameters

ct – Structure to calculate self-scores of
dcell – Pre-calculated distance cell to improve performance

pre_score_pairs(ct, interaction_matrix: Dict[int, Set[int]])¶

score_pair(ct, iacceptors, idonors, iclashers, icharge, jacceptors, jdonors, jclashers, jcharge, use_xtal=False)¶

score_exhaustively(ct, interaction_matrix, find_all_solutions=True, tolerate_clashes=False)¶

score_sequentially(ct: schrodinger.structure._structure.Structure, interaction_matrix: Dict[int, Set[int]], num_sequential_cycles: int)¶

This routine uses an algorithm similar to Prime’s iteration to convergence. Starting from a random configuration, each species is optimized in turn, keeping the others fixed in their current state. This continues until the system reaches convergence (no more changes in the most optimal state for all residues).

Parameters

ct – input/output structure, will be modified
interaction_matrix – Interaction lookup table
num_sequential_cycles – Number of cycles of randomization and optimization to conduct

expand_solutions(ct, interaction_matrix)¶: This takes an existing set of good solutions and generates more by deconverging them and then iterating them back to convergence. Generates at least 10 new solutions.

recombine_solutions(ct, interaction_matrix)¶: This is similar to score_sequentially, but begins with some pre-existing good solutions in self.combinations, and then creates hybrids to try to improve on them.

deconverge(ct, interaction_matrix, comb, problem_cutoff=50.0)¶: This starts with what is assumed to be a good solution, and then randomizes the states, but not to anything that produces a problem.

iterate_to_convergence(ct, interaction_matrix, comb, problem_cutoff=50.0)¶: This iterates the combination ‘comb’ to convergence. Maximum of 10 cycles.

create_hybrid(local_combinations: List[Tuple[Tuple[List[int], float, float], List[int]]], interaction_matrix: Dict[int, Set[int]], random_scaffold: bool = False) → Optional[List[int]]¶

This takes the lowest energy solution, and for each problematic region it searches other solutions (in random order) for any which may have had better luck for just that part of the overall cluster. It then splices those solutions into the lowest energy one. If random_scaffold, then it selects a random solution as the basis in stead of the lowest energy one.

Parameters

local_combinations – List of combinations, where a combination is specified as a tuple holding the combination, total charge, and total energy, and another list of problem children.
interaction_matrix – Interaction lookup table for changeables
random_scaffold – Choose a random starting combination, otherwise start with the first combiation

trim_redundant_combinations()¶

assign_combination(ct, icombination, add_labels, label_pkas, verbose=False)¶

Assign a given combination to this cluster

Parameters

ct (schrodinger.Structure) – The structure to operate on
icombination – The index of the combination to assign or if this number is larger then the stored combinations, just keep the current state
add_labels (bool) – Whether to add labels to atoms to be seen in maestro with the current protonation state
label_pka (bool) – Whether to add labels for the pKa of each residue
verbose (bool) – Whether to report additional information to the log file about the combination chosen

determine_gap(icombination, ichangeable)¶

Create a dictionary with the energy gaps to each of the various states. States that differ by only a hydrogen rotation are not considered unique

Parameters

icombination (integer) – the combination to use as the zero point. In most situations this will be the lowest energy combination ( 0 when sorted)
ichangeable (integer) – The residue number ( or position number) within the cluster which will be analyzed

Rparam

dictionary where the key is the name of the state or “Default” when the state is one of the staggers

Return type

dictionary with a key of string and value of a float

schrodinger.protein.protassign.hbond_cluster.create_hbond_clusters_from_changeables(ct, changeables, interaction_matrix, use_xtal, max_cluster_size)¶