You are reading the documentation for version 1.11 of OpenStructure. You may also want to read the documentation for: 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.7.1 1.8 1.9 1.10 2.0 2.1 2.2 devel

# Blocks¶

The most basic type of residue description is the BuildingBlock. It contains information on atom names and their corresponding types, charges and optionally also their masses. Interactions for all particles can also be defined even though they are optional, except the bonds giving information about the connectivity. You often need to manipulate building blocks or the residues they refer to in an automated manner. That’s where the BlockModifiers come in, with the GromacsBlockModifier as a specific implementation. As a special case there also exist HydrogenConstructors.

## The BuildingBlock Class¶

class BuildingBlock
Match(residue[, match_connectivity=True])

Checks, whether the given residue matches the atom names in the BuildingBlock. The connectivity gets checked optionally.

Parameters: residue (ResidueHandle) – match_connectivity (bool) – If set to true, the function checks the bonds in the residue with the defined bonds in the BuildingBlock bool
Connect(residue, editor)

Connects atoms of residue based on the bond definitions of the BuildingBlock.

Parameters: residue (ResidueHandle) – Residue to be connected editor (XCSEditor) – Editor associated to the residue’s entity RuntimeError when required atom can not be found in residue
AddAtom(name, type, charge[, mass = None])
Parameters: name (str) – Name of atom type (str) – Its corresponding forcefield type charge (float) – Its charge mass (float) – Its mass
RemoveAtom(name)

Removes atom from BuildingBlock with all its associated values and interactions

Parameters: name (str) – Name of atom to be removed
ReplaceAtom(name, new_name, new_type, new_charge[, new_mass = None])

Replace given atom by resetting name, type, charge and mass. All interactions containing that atom get adapted as well

Parameters: name (str) – Name of atom to be replaced new_name (str) – New name of atom new_type (str) – New type of atom new_charge (float) – New charge of atom new_mass (float) – New mass of atom
RemoveInteractionsToPrev()

Removes all interactions associated to an atom of a previous residues. This gets indicated in the BuildingBlock by an atom name prefixed by a -

RemoveInteractionsToNext()

Removes all interactions associated to an atom of a next residues. This gets indicated in the BuildingBlock by an atom name prefixed by a +

AddBond(bond[, replace_existing = False])
Parameters: bond (Interaction) – Bond to be added replace_existing (bool) – Whether potentially already existing bond for the same atoms should be replaced.
AddAngle(angle[, replace_existing = False])
Parameters: angle (Interaction) – Angle to be added replace_existing (bool) – Whether a potentially already existing angle for the same atoms should be replaced.
AddDihedral(dihedral[, replace_existing = False])
Parameters: dihedral (Interaction) – Dihedral to be added replace_existing (bool) – Whether potentially already existing dihedral for the same atoms should be replaced.
AddImproper(improper[, replace_existing = False])
Parameters: improper (Interaction) – Improper to be added replace_existing (bool) – Whether potentially already existing improper for the same atoms should be replaced.
AddExclusion(exclusion[, replace_existing = False])
Parameters: exclusion (Interaction) – Exclusion to be added replace_existing (bool) – Whether potentially already existing Exclusion for the same atoms should be replaced.
AddCMap(cmap[, replace_existing = False])
Parameters: cmap (Interaction) – CMap to be added replace_existing (bool) – Whether potentially already existing cmap for the same atoms should be replaced.
AddConstraint(constraint[, replace_existing = False])
Parameters: constraint (Interaction) – Constraint to be added replace_existing (bool) – Whether potentially already existing constraint for the same atoms should be replaced.
GetType(name)

Gets forcefield type from atom with given name

Parameters: name (str) – Name of atom you want the type from str RuntimeError when atom can not be found in BuildingBlock
GetCharge(name)

Gets charge from atom with given name

Parameters: name (str) – Name of atom you want the charge from float RuntimeError when atom can not be found in BuildingBlock
GetMass(name)

Gets mass from atom with given name

Parameters: name (str) – Name of atom you want the mass from float RuntimeError when atom can not be found in BuildingBlock
GetAtoms()
Returns: list of all atom names
GetTypes()
Returns: list of all atom types
GetCharges()
Returns: list of all charges
GetMasses()
Returns: list of all masses
GetBonds()
Returns: list of all bonds
GetAngles()
Returns: list of all angles
GetDihedrals()
Returns: list of all dihedrals
GetImpropers()
Returns: list of all impropers
GetCMaps()
Returns: list of all cmaps
GetExclusions()
Returns: list of all exlusions
GetConstraints()
Returns: list of all constraints

## Block Modifiers¶

class BlockModifier

Basis class. Block modifiers are used to change building blocks or residues. See GromacsBlockModifier for a specific example.

class GromacsBlockModifier
ApplyOnBuildingBlock(block)

Applies all defined rules on the given BuildingBlock

Parameters: block (BuildingBlock) – BuildingBlock to be modified
ApplyOnResidue(residue)

Applies all defined rules on the given ResidueHandle

Parameters: residue (ResidueHandle) – Residue to be modified
AddReplaceRule(name, new_name, new_type, new_charge)

Rule, that basically renames an atom and also resets its type and charge in a BuildingBlock. A simple renaming occurs in a ResidueHandle.

Parameters: name (str) – Name of the atom to be changed new_name (str) – Its new name new_type (str) – Its new type new_charge (float) – Its new charge
AddAddRule(number, method, atom_names, anchors, type, charge)

A rule to add new atoms the Gromacs way, see Gromacs Manual for the exact definition of the parameters. A BuildingBlock gets modified by adding the new atom definitions and also the corresponding bonds describing the connectivity. In case of ResidueHandle the new Atoms with connectivity get added with their positions as defined by the Gromacs adding rule.

Parameters: number (int) – Number of atoms to be added method (int) – Gromacs adding rule atom_names (list) – Strings containing the new atom names anchors (list) – Strings containing atom names used as anchor type (str) – The type the atoms will have charge (float) – The charge the atoms will have
AddDeleteAtom(name)

Defines an atom that has to be removed. In case of the BuildingBlock this removes this particular atom plus all interactions connected to it, in case of ResidueHandle, the atom simply gets deleted.

Parameters: name (str) – Atom to be deleted
AddBond(bond)

Adds a bond, this only has effect on BuildingBlock, not on ResidueHandle when the corresponding Apply function gets called

Parameters: bond (Interaction) – Bond to be added
AddAngle(angle)

Adds an angle, this only has effect on BuildingBlock, not on ResidueHandle when the corresponding Apply function gets called

Parameters: angle (Interaction) – Angle to be added
AddDihedral(dihedral)

Adds a dihedral, this only has effect on BuildingBlock, not on ResidueHandle when the corresponding Apply function gets called

Parameters: dihedral (Interaction) – Dihedral to be added
AddImproper(improper)

Adds an improper, this only has effect on BuildingBlock, not on ResidueHandle when the corresponding Apply function gets called

Parameters: improper (Interaction) – Improper to be added
AddCMap(cmap)

Adds a cmap, this only has effect on BuildingBlock, not on ResidueHandle when the corresponding Apply function gets called

Parameters: cmap (Interaction) – CMap to be added

## Hydrogen Constructors¶

class HydrogenConstructor

Basis class. Hydrogen constructors are used to add hydrogens to residues.

class GromacsHydrogenConstructor

The GromacsHydrogenConstructor is the Gromacs way of adding hydrogens to a structure.

ApplyOnBuildingBlock(block)

Guess what it does: !!ABSOLUTELY NOTHING!! just there for consistency

Parameters: block (BuildingBlock) – Block that won’t be changed at all! Isn’t that awesome?
ApplyOnResidue(residue)

Constructs hydrogens based on the defined hydrogen addition rules

Parameters: residue (ResidueHandle) – Residue to be modified
AddHydrogenRule(number, method, hydrogen_names, anchors)

Adds a hydrogen building rule as defined in Gromacs Manual

Parameters: number (int) – Number of hydrogens to be added method (int) – Gromacs adding rule hydrogen_names (list) – Strings containing the hydrogen names anchors (list) – Strings containing atom names used as anchor
class HeuristicHydrogenConstructor(block)

As soon as we leave the well defined world of Gromacs residue definitions, we have to find new ways for constructing hydrogens. The HeuristicHydrogenConstructor takes a BuildingBlock at initialization and builds heuristic rules to build hydrogens based on the connecticity defined in the given block.

Parameters: block – BuildingBlock from which the connectivity information for hydrogen construction is extracted
ApplyOnBuildingBlock(block)

Guess what it does: !!ABSOLUTELY NOTHING!! Just there for consistency

Parameters: block (BlockModifier) – Block that won’t be changed at all! Isn’t that awesome?
ApplyOnResidue(residue)

Constructs hydrogen based on heuristic rules

Parameters: residue (ResidueHandle) – Residue to be modified

## Search

Enter search terms or a module, class or function name.

Interactions

Forcefields