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)

Copyright Schrodinger, LLC. All rights reserved.

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

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 ']
CARBOXYLIC_ACID_PKA_SHIFT = 5.0
MAX_CARBOXYLIC_ACID_INTERACTION_DISTANCE = 3.8
MAX_METAL_INTERACTION_DISTANCE = 3.5
MAX_STATIC_ACCEPTOR_INTERACTION_DISTANCE = 3.5
METAL_PKA_SHIFT = -3.0
MIN_CARBOXYLIC_ACID_INTERACTION_ANGLE = 140
MIN_STATIC_ACCEPTOR_INTERACTION_ANGLE = 150
STATIC_ACCEPTOR_PKA_SHIFT = 5.0
carboxyl_interactions()

Check if histidine is interacting with a carboxyl group.

metal_interactions()
predict(st)
static_acceptor_interactions()

Check if histidine is interacting with a static acceptor

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 ']
CARBOXYLIC_ACID_PKA_SHIFT = 5.0
MAX_CARBOXYLIC_ACID_INTERACTION_DISTANCE = 3.8
MAX_METAL_INTERACTION_DISTANCE = 3.5
MAX_STATIC_ACCEPTOR_INTERACTION_DISTANCE = 3.5
METAL_PKA_SHIFT = -3.0
MIN_CARBOXYLIC_ACID_INTERACTION_ANGLE = 140
MIN_STATIC_ACCEPTOR_INTERACTION_ANGLE = 150
STATIC_ACCEPTOR_PKA_SHIFT = 5.0
carboxyl_interactions()

Check if histidine is interacting with a carboxyl group.

metal_interactions()
predict(st)
static_acceptor_interactions()

Check if histidine is interacting with a static acceptor

exception schrodinger.protein.assignment.PropKaException(value)

Bases: Exception

__init__(value)
args
with_traceback()

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

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: List[int] = <factory>, donors: List[Tuple[int, int]] = <factory>, clashers: 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: List[int] = <factory>, donors: List[Tuple[int, int]] = <factory>, clashers: 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.

add_current_to_states(ct)
asl = 'none'
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

change_empirical_pka(pH)
change_pka(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

get_new_index(ct: schrodinger.structure._structure.Structure, atom_index: int, new_indices: Dict[int, int])
hbond_heavy_max_angle = 140.0
hbond_heavy_min_angle = 80.0
hbond_min_angle = 150.0
lock_protonation()
max_hbond_distance = 3.5
pre_treat(ct)
swap_atoms(ct, atom1, atom2)
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()
add_current_to_states(ct)
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

change_empirical_pka(pH)
change_pka(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

get_new_index(ct: schrodinger.structure._structure.Structure, atom_index: int, new_indices: Dict[int, int])
hbond_heavy_max_angle = 140.0
hbond_heavy_min_angle = 80.0
hbond_min_angle = 150.0
lock_protonation()
max_hbond_distance = 3.5
pre_treat(ct)
pre_treat_1(ct)
swap_atoms(ct, atom1, atom2)
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)
add_current_to_states(ct)
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

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

get_new_index(ct: schrodinger.structure._structure.Structure, atom_index: int, new_indices: Dict[int, int])
hbond_heavy_max_angle = 140.0
hbond_heavy_min_angle = 80.0
hbond_min_angle = 150.0
max_hbond_distance = 3.5
pre_treat(ct)
swap_atoms(ct, atom1, atom2)
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)
add_current_to_states(ct)
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

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

get_new_index(ct: schrodinger.structure._structure.Structure, atom_index: int, new_indices: Dict[int, int])
hbond_heavy_max_angle = 140.0
hbond_heavy_min_angle = 80.0
hbond_min_angle = 150.0
max_hbond_distance = 3.5
pre_treat(ct)
swap_atoms(ct, atom1, atom2)
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)
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

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

get_new_index(ct: schrodinger.structure._structure.Structure, atom_index: int, new_indices: Dict[int, int])
hbond_heavy_max_angle = 140.0
hbond_heavy_min_angle = 80.0
hbond_min_angle = 150.0
max_hbond_distance = 3.5
pre_treat(ct)
swap_atoms(ct, atom1, atom2)
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)
add_current_to_states(ct)
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

get_adjustable_atoms()
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

get_new_index(ct: schrodinger.structure._structure.Structure, atom_index: int, new_indices: Dict[int, int])
hbond_heavy_max_angle = 140.0
hbond_heavy_min_angle = 80.0
hbond_min_angle = 150.0
max_hbond_distance = 3.5
pre_treat(ct)
swap_atoms(ct, atom1, atom2)
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()
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

change_empirical_pka(pH)
change_pka(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

get_new_index(ct: schrodinger.structure._structure.Structure, atom_index: int, new_indices: Dict[int, int])
hbond_heavy_max_angle = 140.0
hbond_heavy_min_angle = 80.0
hbond_min_angle = 150.0
lock_protonation()
max_hbond_distance = 3.5
pre_treat(ct)
pre_treat_1(ct)
pre_treat_2(ct)
swap_atoms(ct, atom1, atom2)
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.