schrodinger.protein.assignment module¶

Module for optimizing hydroxyl, thiol and water orientiations, Chi-flips of asparagine, glutamine and histidine, and protonation states of aspartic acid, glutamic acid, and histidine.

Usage: ProtAssign(st)

schrodinger.protein.assignment.get_annotated_atom(residue)¶: Returns annotated atom of residue _StructureAtom or None

schrodinger.protein.assignment.get_annotated_atom_property(residue)¶: Returns property dict of annotated atom or an empty dict if atom is not present

schrodinger.protein.assignment.get_pka(residue)¶: Return predicted pKa of residue

schrodinger.protein.assignment.set_pka(residue, pka)¶: Set predicted pKa of residue

schrodinger.protein.assignment.shift_pka(residue, amount)¶: Shift the predicted pKa of residue

schrodinger.protein.assignment.get_interaction_label(label, suffix)¶: Create property label for a given interaction.

schrodinger.protein.assignment.set_interaction_label(residue, label, suffix=None)¶: Set a label of the annoted atom of residue to True

schrodinger.protein.assignment.has_interaction_label(residue, label, suffix=None)¶: Check if the annotated atom of the residue has a label

schrodinger.protein.assignment.residue_to_label(residue_or_atom)¶: Create string from residue or atom.

schrodinger.protein.assignment.log_interaction(residue1, residue2, name, distance=None, angle=None)¶: Log the interaction between two residues and its distance and angle optionally

schrodinger.protein.assignment.get_bulk_solvent_accessible_atoms(st, radius=2.5, radius2=3.0, spacing=0.5, include_water=False)¶

Return bulk solvent accessible atoms.

Bulk solvent accessible atoms are determined by creating a grid and setting occupied voxels to 1 using a fixed radius for each atom and then checking if any non-occupied voxels are present within a slightly larger radius.

Parameters

st (Structure) – Structure to determine bulk solvent accessible atoms. The atom property BULK_SOLVENT_ACCESSIBLE_PROPERTY will be set for each atom.
radius (float) – Initial radius
radius2 (float) –
spacing (float) – Spacing of grid. Lower spacing makes the calculation more accurate but requires more compute time and memory.
include_water (bool) – Whether to keep waters or not when calculating bulk solvent accessible atoms.

Returns

List of atom indices that are bulk solvent accessible

Return type

List[int]

schrodinger.protein.assignment.get_unsatisfied_donors(st, include_bsa=True)¶

Return unsatisfied buried donors

Parameters

st (Structure) – Structure to analyze
include_bsa (bool) – Include bulk solvent accessible atoms

Returns

List of unsatisfied donor atoms

Return type

List[_StructureAtom]

schrodinger.protein.assignment.get_carboxyl_atoms(residue)¶

Get carboxyl atom groups from residue. Returns multiple groups if multiple are present. The first atom will be the carbon. It specifically adds Glu and Asp even if they are protonated and uses a SMARTS pattern otherwise to extract the carboxyl group.

Parameters: residue (_Residue) – Residue to check
Returns: List of carboxyl atoms
Return type: List[List[_StructureAtom]]

schrodinger.protein.assignment.get_residue_neighborhoods(st, residues, distance_cell)¶

schrodinger.protein.assignment.protonate_histidine(histidine)¶

schrodinger.protein.assignment.charge_arginine_sidechains(st)¶

Make arginine sidechains charged. Assumes bond orders have been assigned correctly.

Looks for the nitrogen that has a double bond to the CZ atom, and changes the formal charge to 1 and retypes atom.

class schrodinger.protein.assignment.HistidinepKaPredictor¶

Bases: object

Empirical histidine pKa predictor

INTERNAL_PKA = 6.5¶

METAL_PKA_SHIFT = -4.0¶

STATIC_DONOR_PKA_SHIFT = -3.0¶

FORCED_ACCEPTOR_PKA_SHIFT = -3.0¶

PI_CATION_PKA_SHIFT = -1.0¶

PI_PI_PKA_SHIFT = 1.0¶

CARBOXYLIC_ACID_PKA_SHIFT = 1.0¶

DOUBLE_SIDED_HBOND_PKA_SHIFT = 1.0¶

MAX_STATIC_DONOR_INTERACTION_DISTANCE = 3.0¶

MIN_STATIC_DONOR_INTERACTION_ANGLE = 120¶

MAX_STATIC_ACCEPTOR_INTERACTION_DISTANCE = 2.5¶

MIN_STATIC_ACCEPTOR_INTERACTION_ANGLE = 120¶

MAX_METAL_INTERACTION_DISTANCE = 3.5¶

MAX_PI_PI_INTERACTION_DISTANCE = 4.5¶

MAX_PI_PI_INTERACTION_ANGLE = 30¶

MAX_PI_CATION_INTERACTION_DISTANCE = 4.5¶

MAX_PI_CATION_INTERACTION_ANGLE = 30¶

MAX_PI_ARG_INTERACTION_DISTANCE = 5.5¶

MAX_CARBOXYLIC_ACID_INTERACTION_DISTANCE = 3.8¶

MIN_CARBOXYLIC_ACID_INTERACTION_ANGLE = 140¶

NITROGEN_PDBNAMES = {' ND1', ' NE2'}¶

CARBON_PDBNAMES = {' CD2', ' CE1'}¶

SIDECHAINS_PDBNAMES = {' CD2', ' CE1', ' CG ', ' ND1', ' NE2'}¶

predict(st, protassign=None, flip=False)¶

Predict histidine pKa with empirical rules. Currently this requires the structure being annotated by ProtAssign.

Parameters

st (Structure) – ProtAssign annotated structure
protassign (schrodinger.protein.assignment.ProtAssign) – ProtAssign instance to calculate forced acceptor interactions
flip (bool) – Calculate pKa of flipped version of histidne

Returns None but annotates ANNOTATED_ATOM of each histidine with found interactions and predicted pKa

metal_interactions()¶

cation_pi_interactions()¶

arginine_interactions()¶

pi_pi_interactions()¶: Check if histidine is involved in pi-pi interaction

carboxyl_interactions()¶: Check if histidine is interacting with a carboxyl group.

static_donor_interactions()¶: Check if histidine is interacting with a static donor

identify_forced_amide_states()¶: Identify amide residues that are forced in a state due to them interacting with a static donor. This is done in a single pass and not iteratively.

static_acceptor_interactions()¶: Check if histidine is interacting with a static acceptor

class schrodinger.protein.assignment.AsparticAcidpKaPredictor¶

Bases: schrodinger.protein.assignment._CarboxylicAcidpKaPredictor

Aspartic acid emperical pKa predictor

INTERNAL_PKA = 3.4¶

PDBRES_NAMES = {'ASH ', 'ASP '}¶

CARBON_PDBNAME = ' CG '¶

OXYGEN_PDBNAMES = [' OD1', ' OD2']¶

SIDECHAIN_PDBNAMES = [' OD1', ' OD2', ' CG ']¶

class schrodinger.protein.assignment.GlutamicAcidpKaPredictor¶

Bases: schrodinger.protein.assignment._CarboxylicAcidpKaPredictor

Glutamic acid emperical pKa predictor

INTERNAL_PKA = 4.2¶

PDBRES_NAMES = {'GLH ', 'GLU '}¶

CARBON_PDBNAME = ' CD '¶

OXYGEN_PDBNAMES = [' OE1', ' OE2']¶

SIDECHAIN_PDBNAMES = [' OE1', ' OE2', ' CD ']¶

exception schrodinger.protein.assignment.PropKaException(value)¶

Bases: Exception

__init__(value)¶

schrodinger.protein.assignment.report(message_level=1, message='')¶

schrodinger.protein.assignment.measure(ct, atom1=None, atom2=None, atom3=None, atom4=None, use_xtal=False, max_dist=10.0)¶

schrodinger.protein.assignment.calculate_interaction_matrix(ct: schrodinger.structure._structure.Structure, iatoms: List[int], distance: float, use_xtal: bool = False) → Dict[int, set]¶

Create an interaction matrix based on the CHANGEABLE_INDEX_PROPERTY atom property

Parameters

ct – Structure with annotated atoms having set the CHANGEABLE_INDEX_PROPERTY corresponding the the index of the changeable
iatoms – List of atom indices which take part in interaction
distance – Max distance between interacting atoms
use_xtal – Take into account crystal symmetry mates
use_xtal – bool

Returns

interaction matrix allowing double indexing: interact[i, j]

class schrodinger.protein.assignment.Interactors(acceptors: typing.List[int] = <factory>, donors: typing.List[typing.Tuple[int, int]] = <factory>, clashers: typing.List[int] = <factory>)¶

Bases: object

Container for atom indices of hydrogen-bond acceptors, donors, and clashers

acceptors: List[int]¶

donors: List[Tuple[int, int]]¶

clashers: List[int]¶

remap(mapper: Dict[int, int])¶

Remap atom indices of interactors.

Parameters: mapper – Dictionary mapping old atom indices to new indices

__init__(acceptors: typing.List[int] = <factory>, donors: typing.List[typing.Tuple[int, int]] = <factory>, clashers: typing.List[int] = <factory>) → None¶

schrodinger.protein.assignment.annotate_structure_interactors(ct: schrodinger.structure._structure.Structure, interactors: schrodinger.protein.assignment.Interactors) → None¶

Set atom property for each interactor class

Parameters

ct – Structure to annotate
interactors – All interactors to annotate

Returns

None but sets atom properties

schrodinger.protein.assignment.generate_annotated_ct(ct, donors, acceptors, clashers, use_xtal=False)¶

Generate an annotated Structure that contains crystal mates. The annotated heavily speeds up the self scoring step for large and xtal structures

Parameters

ct (Structure) – Structure to annotate
donors (List[Tuple[int, int]]) – List of donor pairs
acceptors (List[int]) – List of acceptor atom indices
clashers (List[int]) – List of clasher atom indices
use_xtal (bool) – Create crystal mates in annotated output structure

Returns

New annotated structure with property ANNOTATED_PROPERTY set to True

Return type

Structure

schrodinger.protein.assignment.check_residue_flip_state(res: schrodinger.structure._structure.Residue) → tuple¶

Determine whether a residue cannot be flipped, is, or is not flipped.

Parameters: res – a protein residue
Returns: a tuple of (state, msg), where state describes whether the residue is flipped (True), is not flipped (False), or cannot be flipped (None); if None, msg will contain an explanation
Return type: tuple[bool or NoneType, str]

schrodinger.protein.assignment.get_residue_flip_state(res: schrodinger.structure._structure.Residue) → Optional[bool]¶

Return the flip state of a protein residue.

A truncated version of check_residue_flip_state().

Parameters: res – a protein residue
Returns: the flip state of a residue

schrodinger.protein.assignment.get_residue_string(residue_or_atom) → str¶

Return a string describing a residue from a residue or atom.

The string will match the format: <chain>:<residue PDB code> <residue number>[<insertion code>]

Parameters: residue_or_atom (_Residue or _StructureAtom) – a residue or atom
Returns: a string describing the residue

schrodinger.protein.assignment.get_atom_string(atom)¶: Return a string describing atom

schrodinger.protein.assignment.get_heavy_neighbors(atom: schrodinger.structure._structure.StructureAtom) → list¶

Parameters: atom – an atom
Returns: a list of heavy (non-H) atoms covalently bound to atom
Return type: list[structure._StructureAtom]

schrodinger.protein.assignment.get_residue_from_changeable(ct, changeable)¶

class schrodinger.protein.assignment.WaterStateEnumerator(ct, oxygen, interactors: schrodinger.protein.assignment.Interactors)¶

Bases: object

Enumerate discrete water states that are hydrogen bonding with nearby acceptors and donors

The goal is to sample likely states while also limiting the number of states as solving the combinatorial problem gets harder with more and more states.

OH_LENGTH = 1.0¶

HOH_ANGLE = 109.5¶

MIN_HYDROGEN_NONSTATIC_DONOR_DISTANCE = 2.5¶

__init__(ct, oxygen, interactors: schrodinger.protein.assignment.Interactors)¶

Parameters

ct (Structure) – Annotated structure with donor/acceptor and static flags.
oxygen (_StructureAtom) – Oxygen atom of water
acceptors – Interactor atom indices

enumerate_acceptor_acceptor_states()¶

Enumerate states where water is donating to two acceptors at the same time

Returns: List of water states
Return type: List[_WaterState]

enumerate_donor_donor_states()¶

Enumerate states where water is accepting from two donors at the same time

Returns: List of water states
Return type: List[_WaterState]

enumerate_acceptor_states()¶

Enumerate states where water is donating to a single acceptor

Returns: List of water states
Return type: List[_WaterState]

enumerate_donor_states()¶

Enumerate states where water is accepting from a single donor

Returns: List of water states
Return type: List[_WaterState]

rotate_hydrogens_along_axis(axis, angle)¶

Rotate the water hydrogens along an axis by an angle. Does not return anything but moves hydrogens in place.

Parameters

axis (3 floats) – Axis along to rotate to
angle (float) – Angle to rotate in degrees

class schrodinger.protein.assignment.NetworkSolver(cluster, interact, upper_bound)¶

Bases: object

Wrapper around toulbar2 that exactly solves the hydrogen bond network problem

PRECISION = 5¶

MAX_TIME = 30¶

TOULBAR2 = 'toulbar2'¶

__init__(cluster, interact, upper_bound)¶

Parameters

cluster (ProtAssign.hbond_cluster) – Hydrogen bond network cluster that will be optimized
interact (Dict[int, Dict[int, bool]]) – Changeable interaction lookup table.
upper_bound (float) – Upper energy bound for the network energy. Required for toulbar2

setup_toulbar2_inputs()¶: Setup the input file for toulbar2. Essentially the file contains data on the variables involved, and the self and pair scores, all in a json file.

parse_and_delete_output_file(out)¶

Parse and then delete toulbar2 output file that contains the chosen state for each changeable

Parameters: out (str) – File name of output file
Returns: List of chosen state of each changeable
Return type: List[List[int]]

optimal_solution()¶

Run toulbar2 to get the optimal solution

Returns: Optimal state combination. If toulbar2 fails returns None
Return type: List[int] or None

explore_solutions(upper_bound=None, number=1000)¶

Run toulbar2 to greedily obtain a number of solutions with an energy below a certain upper bound. Note that there are no guarantees here about diversity, though each solution will be unique.

Parameters

upper_bound (float) – upper bound energy. All solutions will have an energy lower than this
number (int) – Max number of solutions to find

Returns

List of state combinations

Return type

List[List[int]]

class schrodinger.protein.assignment.ProtAssign(ct, interactive=False, do_flips=True, asl='', noprot_asl='', atoms=[], use_xtal=False, sample_waters=True, sample_acids=True, freeze_existing=False, include_initial=False, max_comb=10000, num_sequential_cycles=30, max_cluster_size=None, seed: Optional[int] = None, logging_level=1, quiet_flag=False, debug_flag=False, add_labels=True, label_pkas=False, pH: Union[str, float] = 7.4, use_propka=True, user_states=[], minimize=False, ligand_sts=None, include_epik_states=False)¶

Bases: object

class changeable(ct, iatom)¶

Bases: object

asl = 'none'¶

max_hbond_distance = 3.5¶

hbond_min_angle = 150.0¶

hbond_heavy_min_angle = 80.0¶

hbond_heavy_max_angle = 140.0¶

__init__(ct, iatom)¶

pre_treat_1(ct)¶

pre_treat_2(ct)¶

pre_treat(ct)¶

enumerate_states(ct, interactors: schrodinger.protein.assignment.Interactors, pH, do_flips=True, include_initial=False)¶

lock_protonation()¶

add_current_to_states(ct)¶

assign_state(ct, istate, add_labels=True, label_pkas=False, state_gap=None, verbose=False)¶

assign_state_gap(atom, state_gaps, report_gaps=True)¶

Write the Gap in energy between the lowest energy state and the state with different protonation states or heavy atom positions to the output ct

Parameters

atom (structure.StructureAtom) – The atom that should have properties written to it
state_gaps (A dictionary where the keys are strings (state names) and the values are floats (energy in kcals of the lowest energy combination that has that state)) – The energy gaps between states for a given changeable position.
report_gaps (bool) – Whether to report the gaps to the log file as well

update_atom_indices(ct: schrodinger.structure._structure.Structure, new_indices: Dict[int, int])¶

get_new_index(ct: schrodinger.structure._structure.Structure, atom_index: int, new_indices: Dict[int, int])¶

get_view_atoms()¶

swap_atoms(ct, atom1, atom2)¶

get_penalty(istate)¶

get_adjustable_atoms()¶

change_pka(pka, pH)¶

change_empirical_pka(pH)¶

get_close_interactors(ct: schrodinger.structure._structure.Structure, dcell) → schrodinger.protein.assignment.Interactors¶

Return acceptors, donors and clashers that are close to this changeable heavy atoms.

Parameters

ct – Structure with annotated atoms signfying interaction class
dcell (DistanceCell) – Distance cell to query for neighboring atoms

Returns

List of acceptors, donor heavy-hydrogen pairs, and clashers atom indices

class ligand_changeable(ct, iatom)¶

Bases: schrodinger.protein.assignment.ProtAssign.changeable

type = 'LIGAND'¶

__init__(ct, iatom)¶

property nstates¶

pre_treat_1(ct)¶: Add all the protonation states to the ct. After this method the ct is a superposition of ligand states.

pre_treat_2(ct)¶: Further annotates structure and stores data for bookkeeping and improved computational performance. Assumes pre_treat_1 has been called before.

add_protonation_state(ligand_st)¶

get_heavies()¶

get_adjustable_atoms()¶

get_view_atoms()¶

enumerate_states(ct, interactors: schrodinger.protein.assignment.Interactors, pH, do_flips=True, include_initial=False)¶

Enumerate ligand states

The input structure is supposed to have its different protonation states available as a superposition, i.e. all protonation states of the ligand are fully integrated into the structure.

A ligand state is a protonation state of the ligand and a combination of non-shared hydrogen coordinates. A non-shared hydrogen is a rotatable hydrogen that is only present in a subset of ligand protonation states.

get_het_from_state(istate: int) → int¶: Get the protonation state index from the state index.

get_rotatable_id_to_atom(ct, hetid: int) → Dict[int, int]¶: Return a dictionary that maps a rotatable index to its atom index

update_hydrogen_xyz_from_state(ct, istate: int)¶

Update the non-shared rotatable hydrogen coordinates for a specific state.

Returns None but updates xyz coordinates of non-shared rotatable hydrogens.

get_state_sites(ct, istate: int) → Tuple[List[int], List[Tuple[int, int]], List[int], int]¶: Updates non-shared rotatable hydrogen positions and returns atom indices for acceptors, donors, clashers and (unused) charge

assign_state(ct, istate, add_labels=True, label_pkas=False, state_gaps=None, verbose=False) → List[int]¶: Sets the ligand to a certain state and internally updates atom indices. Returns list of atom indices that need to be deleted to obtain the right state.

update_atom_indices(ct, new_indices: Dict[int, int])¶: Update stored atom indices for bookkeeping.

get_penalty(istate: int) → float¶: Get penalty for ligand state, which is currently fully defined by the ligand protonation state. Return 0 if no penalty.

class amide_changeable(ct, iatom)¶

Bases: schrodinger.protein.assignment.ProtAssign.changeable

This is the primary amide -NH2 group of ASN and GLN residues.

asl = '((res.ptype "ASN " AND atom.ptype " CG ") OR (res.ptype "GLN " AND atom.ptype " CD "))'¶

OXYGEN_PDBNAMES = [' OD1', ' OE1']¶

NITROGEN_PDBNAMES = [' ND2', ' NE2']¶

CARBON_PDBNAMES = [' CG ', ' CD ']¶

__init__(ct, iatom)¶

pre_treat_2(ct)¶

enumerate_states(ct: schrodinger.structure._structure.Structure, interactors: schrodinger.protein.assignment.Interactors, pH, do_flips: bool = True, include_initial=False)¶

Generate states for amides

Max 2 states are generated by swapping the oxygen and nitrogen and readjusting the hydrogens to the nitrogen.

Parameters

ct – Structure to generate states for
do_flips – Include the flipped state of the amide

Other parameters are not used

set_state_coordinates(ct, istate)¶: Set coordinates of nitrogen, oxygen, and hydrogens to pre-calculated state coordinates.

assign_state(ct, istate, add_labels=True, label_pkas=False, state_gaps=None, verbose=False)¶

Assign state to amide residue.

The state is changed by setting the coordinates of the nitrogen, oxygen and 2 hydrogens to pre-calculated positions.

Parameters

ct (Structure) – Structure to change
istate (int) – State index to assign
add_labels (bool) – Add labels to the carbon atom to indicate flip
state_gaps (List[float]) – List of state gaps
verbose – Does nothing
verbose – bool

update_atom_indices(ct, new_indices)¶

get_heavies()¶

get_state_sites(ct, istate)¶

Return state sites consisting of acceptors, donors, clashers and charge.

Returns: List of acceptor, donor, clasher atom indices and charge
Return type: Tuple[List[int], List[int, int], List[int], float]

get_view_atoms()¶

get_penalty(istate)¶

get_adjustable_atoms()¶

class histidine_changeable(ct, iatom)¶

Bases: schrodinger.protein.assignment.ProtAssign.changeable

Imidazole group of Histidine residues.

asl = '((res.ptype "HIS ","HID ","HIE ","HIP ")) AND ((atom.ptype " CG "))'¶

__init__(ct, iatom)¶

pre_treat_1(ct)¶

pre_treat_2(ct)¶

enumerate_states(ct, interactors: schrodinger.protein.assignment.Interactors, pH: Optional[float], do_flips=True, include_initial=False)¶

Enumerate histidine states and create penalties for certain states.

Parameters

ct (Structure) – Structure to generate states for
interactors – Interactor atom indices
pH – pH of system to determine pH-related penalties. Set to None if using a pKa-predictor
do_flips (bool) – Include flipped histidine states in pool
include_initial – Does nothing here

lock_protonation()¶

assign_state(ct, istate, add_labels=True, label_pkas=False, state_gaps=None, verbose=False)¶

update_atom_indices(ct, new_indices)¶

get_heavies()¶

get_state_sites(ct, istate)¶

get_view_atoms()¶

get_penalty(istate)¶

get_adjustable_atoms()¶

change_pka(pka, pH)¶

change_empirical_pka(pH)¶

class carboxyl_changeable(ct, iatom)¶

Bases: schrodinger.protein.assignment.ProtAssign.changeable

asl = '(res.ptype "ASP ","ASH " AND atom.ptype " CG ") OR (res.ptype "GLU ","GLH " AND atom.ptype " CD ")'¶

__init__(ct, iatom)¶

pre_treat_1(ct)¶

pre_treat_2(ct)¶

enumerate_states(ct, interactors: schrodinger.protein.assignment.Interactors, pH, do_flips=True, include_initial=False)¶

lock_protonation()¶

assign_state(ct, istate, add_labels=True, label_pkas=False, state_gaps=None, verbose=False)¶

update_atom_indices(ct, new_indices)¶

get_heavies()¶

get_state_sites(ct, istate)¶

get_view_atoms()¶

get_penalty(istate)¶

get_adjustable_atoms()¶

change_pka(pka, pH)¶

change_empirical_pka(pH)¶

class rotatable_changeable(ct, iatom)¶

Bases: schrodinger.protein.assignment.ProtAssign.changeable

asl = '((res.ptype "CYS ","CYT ") AND (atom.ptype " SG ") AND (atom.formal -1)) OR ((res.ptype "TYR ") AND (atom.ptype " OH ") AND (atom.formal -1)) OR (( atom.ele H AND not /C0-H0/ AND not /N0-H0/ ) AND NOT (res.ptype "HOH","DOD","SPC","ASH","GLH","ASP","GLU" ))'¶

type = 'ROTATABLE'¶

__init__(ct, iatom)¶

pre_treat_1(ct)¶

pre_treat_2(ct)¶

enumerate_states(ct, interactors: schrodinger.protein.assignment.Interactors, pH, do_flips=True, include_initial=False)¶

lock_protonation()¶

add_current_to_states(ct)¶

assign_state(ct, istate, add_labels=True, label_pkas=False, state_gaps=None, verbose=False)¶

update_atom_indices(ct, new_indices)¶

get_heavies()¶

get_state_sites(ct, istate)¶

get_view_atoms()¶

get_penalty(istate)¶

get_adjustable_atoms()¶

change_pka(pka, pH)¶

change_empirical_pka(pH)¶

class amine_changeable(ct, iatom)¶

Bases: schrodinger.protein.assignment.ProtAssign.changeable

asl = '((res.ptype "LYS ","LYN ") AND (atom.ptype " NZ "))'¶

type = 'AMINE'¶

__init__(ct, iatom)¶

pre_treat_1(ct)¶

pre_treat_2(ct)¶

enumerate_states(ct: schrodinger.structure._structure.Structure, interactors: schrodinger.protein.assignment.Interactors, pH: float, do_flips: bool = True, sample_neutral_states: bool = False, include_initial: bool = False)¶

Generate states for lysines.

States are generated by rotating hydrogens for acceptor/donor interactions and by optionally including the neutral state.

Parameters

ct – Structure to generate states for
interactors – Interactor atom indices
pH – pH of system
do_flips – Does nothing
sample_neutral_states – Include neutral states. Since PROPKA’s pKa prediction is unreliable for Lys, currently we have no method of confidently assess whether it is neutral. So it’s turned off by default.
include_initial (bool) – Include the initial state of the Lys

lock_protonation()¶

assign_state(ct, istate, add_labels=True, label_pkas=False, state_gaps=None, verbose=False)¶

update_atom_indices(ct, new_indices)¶

get_heavies()¶

get_state_sites(ct, istate)¶

get_view_atoms()¶

get_penalty(istate)¶

change_pka(pka, pH)¶

change_empirical_pka(pH)¶

class water_changeable(ct, iatom)¶

Bases: schrodinger.protein.assignment.ProtAssign.changeable

asl = '(water) AND (atom.ele O)'¶

redundancy_tolerance = 0.5¶

__init__(ct, iatom)¶

property nstates¶: Return number of enumerated states

enumerate_states(ct: schrodinger.structure._structure.Structure, interactors: schrodinger.protein.assignment.Interactors, pH: float, do_flips: bool = True, include_initial: bool = False)¶

Generate discrete states for water, where a state is defined by the coordinates of its two hydrogens.

Parameters

ct – Structure
interactors – Interactor atom indices
pH – Does nothing here
do_flips – Does nothing here
include_initial – Include the current water orientation in the state list

add_current_to_states(ct)¶

assign_state(ct, istate, add_labels=True, label_pkas=False, state_gaps=None, verbose=False)¶

update_atom_indices(ct, new_indices)¶

get_heavies()¶

get_state_sites(ct, istate)¶

get_view_atoms()¶

get_penalty(istate)¶

get_adjustable_atoms()¶

class hbond_cluster¶

Bases: object

__init__()¶

setup_xtal(ct, interact, clustering_distance)¶

optimize(ct: schrodinger.structure._structure.Structure, interact: 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
interact – 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, interact, ncombinations, delta_energy=2.0)¶

Solve the network exact

Parameters

ct (Structure) – Structure
interact (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, interact, states)¶

single_point(ct, interact, 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, interact: Dict[int, Set[int]])¶

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

score_acceptor_acceptor(ct: schrodinger.structure._structure.Structure, iacceptor: int, jacceptor: int, use_xtal=False) → 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

score_donor_acceptor(ct, donor_heavy, donor_hydrogen, acceptor_heavy, use_xtal=False)¶

static 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

static calculate_distance_term(distance)¶: Return distance dependent part of the hydrogen-bond potential functions.

static 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

static calculate_clash_term(distance, cutoff, base=50)¶: Return clash term

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

score_sequentially(ct: schrodinger.structure._structure.Structure, interact: 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
interact – Interaction lookup table
num_sequential_cycles – Number of cycles of randomization and optimization to conduct

expand_solutions(ct, interact)¶: 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, interact)¶: 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, interact, 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, interact, 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]]], interact: 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.
interact – 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

__init__(ct, interactive=False, do_flips=True, asl='', noprot_asl='', atoms=[], use_xtal=False, sample_waters=True, sample_acids=True, freeze_existing=False, include_initial=False, max_comb=10000, num_sequential_cycles=30, max_cluster_size=None, seed: Optional[int] = None, logging_level=1, quiet_flag=False, debug_flag=False, add_labels=True, label_pkas=False, pH: Union[str, float] = 7.4, use_propka=True, user_states=[], minimize=False, ligand_sts=None, include_epik_states=False)¶

Parameters

pH – The pH at which states are determined
seed – Seed for random number generator
ligand_sts (List[Structure]) – Ligand states to consider during optimization.

fix_elements(ct)¶

freeze_existing_hydrogens(ct)¶

identify_changeables(ct)¶

setup(ct)¶

empirical_pka_predictor(ct)¶: Predict pKa of histidine and Asp/Glu based on empirical rules

remove_zero_order_bonds(ct)¶

extend_targeted_to_hyds(ct)¶

delete_atoms(ct, iatoms: List[int])¶: Delete atoms and update stored atom indices

run_propka(changeables, ct, use_xtal=False)¶

generate_mates(ct)¶

apply_pkas(changeables, changes, pH)¶: Update pKa’s coming from PROPKA

find_protonation_state_changes(ct, clusters='all')¶

annotate_structure(ct: schrodinger.structure._structure.Structure) → schrodinger.protein.assignment.Interactors¶

Annotate atoms in structure by their interaction class and whether or not they are static

Returns: Interactor atom indices

enumerate_changeable_states(ct)¶

Enumerate all states for each changeable. Crystal symmetry mates are taken into account if requested.

Updates the acceptors, donors and clashers attributes

lock_protonation_states(ct)¶

cluster(ct)¶: Cluster changeables based on their heavies.

set_user_states(ct)¶

assign_state_of_changeable(ct, ichangeable, istate)¶

increment_state_of_changeable(ct, ichangeable)¶

decrement_state_of_changeable(ct, ichangeable)¶

assign_best_combinations(ct, last_time=False)¶

Assign the best combinations to the ct and report output

Parameters

ct (schrodinger.Structure) – The structure to operate on
last_time (bool) – Whether or not this is the last time through when we should be extra verbose

assign_cluster_combination(ct, icluster, icombination)¶

single_point_cluster(ct, icluster)¶

optimize_cluster(ct, icluster, assign=True)¶

optimize(ct)¶

recalculate_empirical_pkas(ct, iteration)¶: Only recalculate pKa’s of histidines for forced acceptor interactions

recalculate_propka_pkas(ct)¶

minimize_hydrogens(ct)¶

restore_zobs(ct)¶

cleanup(ct)¶

summarize_pkas()¶

schrodinger.protein.assignment.annotate_atom_indices(ct)¶: Add atom index as an atom property to each atom

schrodinger.protein.assignment.identify_species(ct, species: List[Type], target_atoms) → List[schrodinger.protein.assignment.ProtAssign.changeable]¶: Identify all changeables, i.e. elements in the network that can be changed apart from ligand changeables.

schrodinger.protein.assignment.identify_ligand_changeables(ct, ligand_sts: List[schrodinger.structure._structure.Structure]) → List[schrodinger.protein.assignment.ProtAssign.ligand_changeable]¶

Identify ligand changeables given a list of structures.

Ligand changeables are identified by comparing the residue ID of given ligand structures with residues that are present in the Structure.

schrodinger.protein.assignment.identify_nonshared_rotatable(ct, ligand_changeables: List[schrodinger.protein.assignment.ProtAssign.ligand_changeable], changeable: schrodinger.protein.assignment.ProtAssign.changeable) → bool¶

Check if changeable is part of ligand and whether it can be its own changeable or needs to be sampled within the ligand states.

Returns: True if changeable is a non-shared rotatable across ligand states, False otherwise

schrodinger.protein.assignment.update_rotatable_changeable_indices(ct, iatoms: List[int], changeables: List[schrodinger.protein.assignment.ProtAssign.rotatable_changeable])¶

Update the atom indices of the shared changeables, in this case specifically for rotatables.

Parameters: ct – Structure
Current_state_indices: Ligand atom indices of current state

schrodinger.protein.assignment.filter_nonshared_rotatables(ct, changeables: List[schrodinger.protein.assignment.ProtAssign.changeable]) → List[schrodinger.protein.assignment.ProtAssign.changeable]¶: Given a list of changeables, filter rotatable_changeable instances if they are not shared across all ligand states, as these nonshared rotatables will be dealed with by the ligand_changeable itself.

schrodinger.protein.assignment.annotate_ligand_atoms(ligand_sts: List[schrodinger.structure._structure.Structure], ligand_id: str)¶: Annotate atoms of ligand structures with an ID and state ID

schrodinger.protein.assignment.update_ligand_rotatables_annotation(ct, iatoms: List[int])¶: Update atom properties of rotatable hydrogens in the ligand reindexing them

schrodinger.protein.assignment.add_ligand_sts(ct, ligand_sts: List[schrodinger.structure._structure.Structure])¶

Extend structure with ligand states

Checks if a ligand state is already part of the structure to determine whether to add based on specific atom properties.

schrodinger.protein.assignment.get_ligand_atom_indices(ct, ligand_id: str) → List[int]¶: Return atom indices annotated by ligand_id

schrodinger.protein.assignment.further_annotate_ligand_atoms(ct, iatoms: List[int])¶: Further annotate ligand atoms notably hydrogen Assumes ligand atoms are annotated already with s_pa_ligand_id and i_pa_ligand_het

schrodinger.protein.assignment.group_ligand_het_states(ct, iatoms: List[int]) → Dict[int, List[int]]¶: Return ligand atom indices grouped by het

schrodinger.protein.assignment.get_ligand_interactors(ct, iatoms: List[int])¶: Get ligand interactors while excluding shared acceptors/donors

schrodinger.protein.assignment.annotate_ligand_rotatable_hydrogens(ct, ligand_iatoms: List[int])¶

Annotate rotatable hydrogens and oxygens of the ligand.

These are either hydrogens that are shared with a rotatable_changeable or rotatable in a subset of ligand states. In case it is only rotatable in a subset of the ligand we also annotate the oxygen.

schrodinger.protein.assignment.extract_epik_states(ct, include_initial=False) → List[schrodinger.structure._structure.Structure]¶

Extract Epik embedded states

Epik states are embedded into a structure property during the PPW pipeline. States are extracted and returned.

schrodinger.protein.assignment.identify_all_hbonders(ct)¶: Identify all acceptor, donors and clashers in a structure

schrodinger.protein.assignment.pre_treat_changeables(st: schrodinger.structure._structure.Structure, changeables: List[schrodinger.protein.assignment.ProtAssign.changeable]) → None¶

Pre-treat changeables that are not yet treated

This is faster than pre-treating each changeable by itself as hydrogens are added only once.

schrodinger.protein.assignment.remove_changeable_interactors(changeables: List[schrodinger.protein.assignment.ProtAssign.changeable], interactors: schrodinger.protein.assignment.Interactors) → schrodinger.protein.assignment.Interactors¶: Remove changeable interactors from given interactors

schrodinger.protein.assignment.get_dihedral_atoms(ct: schrodinger.structure._structure.Structure, h: int) → List[int]¶: Get atoms to define a dihedral angle given a hydrogen atom index Return list is smaller than 4 elements if dihedral cannot be determined.

schrodinger.protein.assignment.is_covalent_ligand(st: schrodinger.structure._structure.Structure, atom: schrodinger.structure._structure.StructureAtom) → bool¶: Check if atom is part of a covalent ligand