schrodinger.application.prepwizard module¶

Shared functionality between PrepWizard GUI and command-line PrepWizard.

class schrodinger.application.prepwizard.HetType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)¶

Bases: enum.Enum

METAL_OR_ION = 1¶

DETECTED_LIGAND = 2¶

NON_WATER_SOLVENT = 3¶

OTHER = 4¶

schrodinger.application.prepwizard.get_atoms_by_orig_anum(st)¶: Return a dict where keys are atom indices in the original structure (prior to preparation) and values are atom indices in the given st.

schrodinger.application.prepwizard.extract_receptor_without_hets(st: schrodinger.structure._structure.Structure) → schrodinger.structure._structure.Structure¶: Extract the receptor from the given st, while deleting all hets. Used for detecting H-bonds between the receptor and hets. Using same CT for all hets is faster, as SSSRs are cached.

schrodinger.application.prepwizard.retrieve_and_read_pdb(pdbid)¶: Retrieve the given PDB and return the Structure object. On error, raises RuntimeError.

schrodinger.application.prepwizard.find_metals_in_structure(st)¶

class schrodinger.application.prepwizard.JsonableHetStates(states_by_het=None)¶

Bases: schrodinger.models.json.JsonableClassMixin

JSON serializable class that represents the hets(ligands) table, as well all information about all states of all hets, as generated by Epik and the post-processing. Currently only information that is saved here is stored in self.states_by_het, which has het numbers as keys and lists of HetStates objects for each het as values.

__init__(states_by_het=None)¶

classmethod fromJsonImplementation(serialized_states)¶: Return an instance of JsonableHetStates from a serialized JSON dict. NOTE to future dev: If format of this JSON is changed in the future, please implement a new fromJsonImplementation() method, and add a json.adapter method for converting this older format into the new format.

toJsonImplementation()¶: Return a dict that can be serialized to JSON, which represents all het states for all hets.

schrodinger.application.prepwizard.serialize_het_states(states_by_het, complex_st)¶: Set JSON string for all given states as a CT-level property.

schrodinger.application.prepwizard.deserialize_het_states(complex_st)¶: Attempt to read the het states from the CT using the s_ppw_het_states property, if present.

class schrodinger.application.prepwizard.HetState(hetnum)¶

Bases: object

Class representing an ionization/tautomeric state of a het (e.g. ligand).

__init__(hetnum)¶

classmethod initFromEpikOutput(hetnum, state_st)¶: Return a HetState instance for the given Epik output structure.

extractStateChargesAndOrders(state_st)¶

applyState(st, no_hets_recep_st=None, all_recep_metals=None, is_original=False)¶

Apply this het state to the specified complex structure: modify the bond orders and formal charges to apply the currently selected het state. Used by PPW2 GUI.

Also calculates the score and info_str properties, even if they are already present, as user may have modified the structure since.

Raises RuntimeError if any of the het atoms are no longer in the structure, or are not numbered correctly.

findHetAtoms(complex_st)¶: Return a list of het heavy atoms in the given complex structure.

schrodinger.application.prepwizard.fix_common_structure_mistakes(st)¶: Fixes common problems in structures and returns a list of correction strings that are to be reported to the user.

schrodinger.application.prepwizard.atomsasl(atoms)¶: Generates an ASL expression for the specified atoms.

schrodinger.application.prepwizard.create_glycosylation_bonds(st, dist=1.8, verbose=True)¶

Create glycosylation bonds for N-linked or O-linked glycosilation events Identfies neutral O or N with implicit or explicit hydrogens and forms bonds to sugars ( ring with 5 aliphatic carbons and one oxygen ) at locations adjacent to the oxygen. :param st: Structure to modify. :type st: Schrodinger.structure

Parameters

dist (float) – Atoms must be at least this close to consider for for glycosilation
verbose (boolean) – Whether to print formed bonds to stdout

Rparam

Pairs of atom ( in the output structure ) where bonds were added

Return type

list of schrodinger atom objects

schrodinger.application.prepwizard.create_palmitoylation_bonds(st, dist=1.8, verbose=True)¶

Create palmitoylation bonds. Identfies neutral cysteine S with implicit or explicit hydrogens and palmitoyl groups or palmitoyl groups with the OH of the acid replace by a hydrogen :param st: Structure to modify. :type st: Schrodinger.structure

Parameters

dist (float) – Atoms must be at least this close to consider for for pamitoylation
verbose (boolean) – Whether to print formed bonds to stdout

Rparam

Pairs of atom ( in the output structure ) where bonds were added

Return type

list of schrodinger atom objects

schrodinger.application.prepwizard.create_disulfide_bonds(st, dist=3.2, verbose=False)¶: Create bonds between proximal Sulfurs, deleting any hydrogens on them. If verbose is True, prints log info to the termnal. Returns a list of (atom1, atom2) for ever added bond.

schrodinger.application.prepwizard.convert_selenomethionines(st)¶: Convert MSE residues to METs. Returns a list of residue strings that were converted.

schrodinger.application.prepwizard.count_phosphates_and_sulfurs(st)¶

schrodinger.application.prepwizard.extend_phosphate_states(st)¶

For specified structure, generates phosphate states, and returns list of output structures. Ev:78688

NOTE: Output structure has no hydrogens.

schrodinger.application.prepwizard.extend_sulfate_states(st)¶: For specified structure, generates sulfate states, and returns list of output structures. Ev:82634

schrodinger.application.prepwizard.does_res_have_missing_side_chains(residue)¶

Given a _Residue object, returns True if the residue is missing side-chain atoms. If at least one backbone atom is (also) missing, False is returned.

Basically only residues for which Prime missing-side-chains job can be run will return True.

schrodinger.application.prepwizard.do_any_residues_have_missing_side_chains(st)¶: Returns True if at least one of the residue in the given structure has missing side-chain atoms (backbone atoms are ignored).

schrodinger.application.prepwizard.fix_sulfur_charges(st)¶: Post process by fixing the charge on zero-order-bonded Sulfurs Gives -1 or -2 charge to Sulfurs as appropriate. Deletes a hydrogen from Sulfurs coordinating with metals (Ev:61622)

schrodinger.application.prepwizard.extract_het_from_complex(complex_st, het_atoms)¶

Extract the het defined by the given ASL from the complex structure, and include receptor atoms withing 2 bonds (for covalently bound ligands).

Parameters

complex_st (structure.Structure) – Receptor-ligand complex structure
het_atoms (list(int)) – List of atom indices for the het

Returns

Het structure, Het structure plus some receptor atoms (covalent ligands only), and het type.

Return type

(structure.Structure, structure.Structure, HetType)

schrodinger.application.prepwizard.extract_hets_from_complex(complex_st, het_atoms_lists)¶

Detect hets in the given complex structure, and extract them into separate substructures. For covalent ligands, receptor atoms within 2 bonds are also retained, so that Epik can account for them.

Parameters

complex_st (structure.Structure) – Receptor-ligand complex structure
het_atoms_lists (list(list(int))) – List of atoms for all hets

Returns

Yields tuples of: Het structure, Het structure plus some receptor atoms (covalent ligands only), and het type.

Return type

generator(structure.Structure, structure.Structure, HetType)

schrodinger.application.prepwizard.prepare_for_epik(complex_st, types_to_process)¶

Extract hets from the given complex structure, (except het types that user requested to skip), and separate retained hets into 2 lists: Those that Epik should be run on, those that Epik doesn’t produce any states for. Atoms in the original structure will be marked with i_ppw_anum property, for matching Epik output to atoms in the input structure.

Parameters

complex_st (structure.Structure) – Receptor-ligand complex structure
types_to_process ([HetType]) – List of het types should be processed

Returns

List of structures to run Epik on, and list of structures that should be processed, but without Epik.

Return type

[structure.Structure], [structure.Structure]

schrodinger.application.prepwizard.filter_undesired_states(orig_st, state_sts)¶

Returns a subset of state structures, which excludes metal-binding states for hets that are not within 5A of a metal.

Parameters

orig_st (structure.Structure) – Original complex structure (receptor, ligands, metals)
state_st (Iterable of structure.Structure) – Epik output states to filter.

Returns

List of filtered structures.

Return type

List of structure.Structure

schrodinger.application.prepwizard.get_asl_for_ppw_atoms(atoms)¶: Return an ASL that would match the given atom numbers from input structure (prior to preparation).

schrodinger.application.prepwizard.find_ppw_atom(st, anum)¶: Find the atom in the given structure whose i_ppw_anum property is set to the given value. ValueError exception is raised if such atom is not found. Used by PPW1 only. PPW2 uses an optimization instead.

schrodinger.application.prepwizard.apply_state(complex_st, state_st, atoms_by_anum)¶

Modify the het in complex_st complex (protein/ligand) structure such that its ionization state matches the output that we got from Epik (state_st).

Parameters

complex_st (structure.Structure) – Original complex structure (receptor + het)
state_st (structure.Structure) – Epik output for the het group. May include some atoms from the receptor if the ligand is covalently-bound.
atoms_by_anum – Dict where keys are atom numbers in original unprepared structure, and values are atom numbers in complex_st.

Returns

List of atom indices in complex_st that are part of the het.

Return type

(dict, list)

schrodinger.application.prepwizard.apply_state_and_calc_score(complex_st, state_st)¶

Apply the state <state_st> to <complex_st>, and return the score for the state in the context of the protein complex.

Parameters

complex_st (structure.Structure) – Original complex structure (receptor + het)
state_st (structure.Structure) – Epik output for the het group. May include some atoms from the receptor if the ligand is covalently-bound.

Returns

Tuple of state score, Epik penalty, and information string. Epik penalty will be None for metal states.

Return type

(float, float/None, str)

schrodinger.application.prepwizard.get_state_penalties(state_st)¶: Return the Epik state penalty for this Epik output structure, as well as metal penalties for each atom that has the r_epik_Metal_State_Penalty property set.

schrodinger.application.prepwizard.get_smallest_metal_penalty(metal_penalties, all_recep_metals)¶: Return the lowest metal penalty of all het atoms, considering only atoms that are within 3A of a receptor metal.

schrodinger.application.prepwizard.calc_hbond_energy(hydrogen, acceptor)¶: Calculate H-bond energy. Overly simple, to address PLDB-3337 and similar.

schrodinger.application.prepwizard.calc_state_score(complex_st, het_atoms, state_penalty, smallest_metal_penalty, hbonds)¶

Calculate the score for the current het state (must already been applied to the complex structure).

Complex_st: Structure containing the het and receptor atoms.
Het_atoms: List of atoms (complex indexed) that are part of the het.
State_penalty: Output from get_state_penalties()
Smallest_metal_penalty: Output from get_smallest_metal_penalty()
Hbonds: Output from hbond.get_hydrogen_bonds()

schrodinger.application.prepwizard.generate_phosphate_and_sulfur_states(sts)¶: For each ligand state, expand states for the phosphate and sulfate groups.

schrodinger.application.prepwizard.generate_metal_and_ion_states(sts)¶

schrodinger.application.prepwizard.get_bridging_waters(st, min_hbonds=3)¶: Return a list of all waters in the specified structure that make at least <min_hbonds> number of H-bonds (H-bonds to other waters excluded). The list contains both oxygen and hydrogen atoms (if present).

schrodinger.application.prepwizard.hydrogen_neighbors(st, atoms)¶

Returns the list of neighbor (bonded) atoms that are hydrogens.

Parameters

st (structure.Structure) – Structure where atoms are from.
atoms (list of ints) – List of atom indices for the heavy atoms.

Returns

List of hydrogen atom indices

Return type

list of ints.

schrodinger.application.prepwizard.get_num_clashes_with_metals(st, het_anums)¶

Returns the number of times there is a hydrogen that is clashing with a metal. For now, only hydrogens on aliphatic nitrogens that are zero- order bonded to metals are considered. Geometry is not considered, because amides are rotatable groups.

Parameters: st (structure.Structure) – Structure where atoms are from.

:param het_anumst of atom indices for the heavy atoms. :type het_anumst of ints

Returns: List of nitrogen atoms.
Return type: list(structure._StructureAtom)

schrodinger.application.prepwizard.get_pdb_id(st)¶: Returns the PDB ID of the given structure. If the property does not exist, returns the string “unknown”.

schrodinger.application.prepwizard.get_het_name(st, het_atoms, include_chain=False)¶

Return the het “name” to display for the user for the given het. Assumes all residues have the same chain name.

Example outputs:: “HEM 123a” “HEM A:123a” “HEM 154 Fe” “GLY-VAL-PRO 110-111-112” “GLY-VAL-PRO A:110-111-112”

Parameters

st (structure.Structure) – Structure containing the het
het_atoms (list of ints) – Atoms from this het.
include_chain (bool) – Whether the chain name should be included.

schrodinger.application.prepwizard.add_prepared_props(st)¶: Adds “prepared” and “prepared with version” properties to the given structure.

schrodinger.application.prepwizard.apply_het_states(orig_st, state_sts, logger)¶

For each het state, generate a complex structure with that state applied, and return a list of (state score, complex structure), one for each state.

Parameters

orig_st (structure.Structure) – Input protein complex structure.
state_sts (List[structure.Structure]) – List of ligand states to apply.
logger (logging.Loggger) – Logger to report output to.

Returns

List of state score and complex structure tuples

Return type

List[Tuple[float, structure.Structure]]

schrodinger.application.prepwizard.delete_far_waters(st, angstroms=5)¶

schrodinger.application.prepwizard.delete_non_bridging_waters(st, delwater_hbond_cutoff)¶: Delete waters that do not make at least this number of hydrogen bonds to non-waters.

schrodinger.application.prepwizard.idealize_hydrogen_temp_factor(st)¶

Set temperature factor for hydrogens without temperature factors to that of the bonded heavy atom (if available). This is important for X-ray refinement to prevent R-factor collapse.

Parameters: st (Schrodinger.structure) – Input Structure
Returns: None, but alters hydrogen temperature factors in place.

schrodinger.application.prepwizard.get_het_atom_numbers(st)¶

Get the list of het groups in a structure

Parameters: st (schrodinger.structure.Structure) – Input Structure
Returns: atom numbers in hetero atom fields. Each list is the atoms within a given hetero group
Return type: list of list of integers

class schrodinger.application.prepwizard.PrepWizardSettings(*args, _param_type=<object object>, **kwargs)¶

Bases: schrodinger.models.parameters.CompoundParam

Used for storing settings in prepwizard_driver.py, which is then passed to update_task_from_settings() to convert settings to PreprocessInput for use in PPW2 tasks. Also used as input for the prepare_structure() API. Also see tasks.PreprocessInput which has many similarities

jobname: str¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

force_field: str¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

preprocess: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

assign_bond_orders: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

use_ccd: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

skip_assigned_residues: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

add_hydrogens: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

readd_hydrogens: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

idealize_hydrogen_tf: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

add_terminal_oxygens: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

cap_termini: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

cap_termini_min_atoms: int¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

preprocess_delete_far_waters: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

preprocess_watdist: float¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

delete_far_waters: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

watdist: float¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

treat_metals: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

treat_disulfides: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

treat_glycosylation: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

treat_palmitoylation: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

selenomethionines: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

antibody_cdr_scheme: schrodinger.infra.util.AntibodyCDRScheme¶

renumber_ab_residues: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

tcr_cdr_scheme: schrodinger.infra.util.AntibodyCDRScheme¶

renumber_tcr_residues: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

fillsidechains: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

fillloops: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

custom_fasta_file: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

run_epik: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

use_epikx: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

max_states: int¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

run_protassign: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

samplewater: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

include_epik_states: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

xtal: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

pH: float¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

epik_pH: float¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

epik_pHt: float¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

use_propka: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

propka_pH: float¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

label_pkas: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

force_list: list¶

A Param to represent lists. Values of this param will have a mutated signal that will be emitted whenever any mutation method is called.

The constructor optionally takes a item_class keyword argument to specify what type of class the items in the list will be. This information will be used for jsonifying the list if specified.

minimize_adj_h: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

protassign_number_sequential_cycles: int¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

protassign_max_cluster_size: int¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

delwater_hbond_cutoff: int¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

delete_nonbridging_waters: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

run_impref: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

rmsd: float¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

fixheavy: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

reference_struct: schrodinger.structure._structure.Structure¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

use_PDB_pH: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

preserve_st_titles: bool¶

Base class for all Param classes. A Param is a descriptor for storing data, which means that a single Param instance will manage the data values for multiple instances of the class that owns it. Example:

class Coord(CompoundParam):
    x: int
    y: int

An instance of the Coord class can be created normally, and Params can be accessed as normal attributes:

coord = Coord()
coord.x = 4

When a Param value is set, the valueChanged signal is emitted. Params can be serialized and deserialized to and from JSON. Params can also be nested:

class Atom(CompoundParam):
    coord: Coord
    element: str

add_hydrogensChanged¶