Public API

View Module Index

class sire.mm.AmberAngle

This simple class holds Amber parameters for an angle

assign((AmberAngle)arg1, (AmberAngle)other) → AmberAngle :

C++ signature :

SireMM::AmberAngle {lvalue} assign(SireMM::AmberAngle {lvalue},SireMM::AmberAngle)

clone((AmberAngle)arg1) → AmberAngle :

C++ signature :

SireMM::AmberAngle clone(SireMM::AmberAngle)

energy((AmberAngle)arg1, (float)theta) → float :

C++ signature :

double energy(SireMM::AmberAngle {lvalue},double)

hash((AmberAngle)arg1) → int :

C++ signature :

unsigned int hash(SireMM::AmberAngle {lvalue})

k((AmberAngle)arg1) → float :

C++ signature :

double k(SireMM::AmberAngle {lvalue})

theta0((AmberAngle)arg1) → float :

C++ signature :

double theta0(SireMM::AmberAngle {lvalue})

to_expression()

toExpression( (AmberAngle)arg1, (Symbol)THETA) -> Expression :

C++ signature :

SireCAS::Expression toExpression(SireMM::AmberAngle {lvalue},SireCAS::Symbol)

to_string()

toString( (AmberAngle)arg1) -> object :

C++ signature :

QString toString(SireMM::AmberAngle {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((AmberAngle)arg1) → str :

C++ signature :

char const* what(SireMM::AmberAngle {lvalue})

class sire.mm.AmberBond

This simple class holds Amber parameters for a bond

assign((AmberBond)arg1, (AmberBond)other) → AmberBond :

C++ signature :

SireMM::AmberBond {lvalue} assign(SireMM::AmberBond {lvalue},SireMM::AmberBond)

clone((AmberBond)arg1) → AmberBond :

C++ signature :

SireMM::AmberBond clone(SireMM::AmberBond)

energy((AmberBond)arg1, (float)r) → float :

Return the energy evaluated from this bond for the passed bond length

C++ signature :

double energy(SireMM::AmberBond {lvalue},double)

hash((AmberBond)arg1) → int :

C++ signature :

unsigned int hash(SireMM::AmberBond {lvalue})

k((AmberBond)arg1) → float :

C++ signature :

double k(SireMM::AmberBond {lvalue})

r0((AmberBond)arg1) → float :

C++ signature :

double r0(SireMM::AmberBond {lvalue})

to_expression()

toExpression( (AmberBond)arg1, (Symbol)R) -> Expression :

Return an expression to evaluate the energy of this bond, using the passed symbol to represent the bond length

C++ signature :

SireCAS::Expression toExpression(SireMM::AmberBond {lvalue},SireCAS::Symbol)

to_string()

toString( (AmberBond)arg1) -> object :

C++ signature :

QString toString(SireMM::AmberBond {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((AmberBond)arg1) → str :

C++ signature :

char const* what(SireMM::AmberBond {lvalue})

class sire.mm.AmberDihPart

This simple class holds Amber dihedral or improper parameter parts

assign((AmberDihPart)arg1, (AmberDihPart)other) → AmberDihPart :

C++ signature :

SireMM::AmberDihPart {lvalue} assign(SireMM::AmberDihPart {lvalue},SireMM::AmberDihPart)

clone((AmberDihPart)arg1) → AmberDihPart :

C++ signature :

SireMM::AmberDihPart clone(SireMM::AmberDihPart)

energy((AmberDihPart)arg1, (float)phi) → float :

C++ signature :

double energy(SireMM::AmberDihPart {lvalue},double)

hash((AmberDihPart)arg1) → int :

C++ signature :

unsigned int hash(SireMM::AmberDihPart {lvalue})

k((AmberDihPart)arg1) → float :

C++ signature :

double k(SireMM::AmberDihPart {lvalue})

periodicity((AmberDihPart)arg1) → float :

C++ signature :

double periodicity(SireMM::AmberDihPart {lvalue})

phase((AmberDihPart)arg1) → float :

C++ signature :

double phase(SireMM::AmberDihPart {lvalue})

to_string()

toString( (AmberDihPart)arg1) -> object :

C++ signature :

QString toString(SireMM::AmberDihPart {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((AmberDihPart)arg1) → str :

C++ signature :

char const* what(SireMM::AmberDihPart {lvalue})

class sire.mm.AmberDihedral

This simple class holds Amber dihedral or improper parameter

assign((AmberDihedral)arg1, (AmberDihedral)other) → AmberDihedral :

C++ signature :

SireMM::AmberDihedral {lvalue} assign(SireMM::AmberDihedral {lvalue},SireMM::AmberDihedral)

clone((AmberDihedral)arg1) → AmberDihedral :

C++ signature :

SireMM::AmberDihedral clone(SireMM::AmberDihedral)

energy((AmberDihedral)arg1, (float)phi) → float :

C++ signature :

double energy(SireMM::AmberDihedral {lvalue},double)

hash((AmberDihedral)arg1) → int :

C++ signature :

unsigned int hash(SireMM::AmberDihedral {lvalue})

terms((AmberDihedral)arg1) → object :

C++ signature :

QVector<SireMM::AmberDihPart> terms(SireMM::AmberDihedral {lvalue})

to_expression()

toExpression( (AmberDihedral)arg1, (Symbol)PHI) -> Expression :

C++ signature :

SireCAS::Expression toExpression(SireMM::AmberDihedral {lvalue},SireCAS::Symbol)

to_string()

toString( (AmberDihedral)arg1) -> object :

C++ signature :

QString toString(SireMM::AmberDihedral {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((AmberDihedral)arg1) → str :

C++ signature :

char const* what(SireMM::AmberDihedral {lvalue})

class sire.mm.Angle

This class provides a molecule view to an angle

assert_contains()

assertContains( (MoleculeView)arg1, (AtomIdx)atomidx) -> None :

Assert that this view contains the atom at index atomidx Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

void assertContains(SireMol::MoleculeView {lvalue},SireMol::AtomIdx)

assert_has_metadata()

assertHasMetadata( (MoleculeView)arg1, (PropertyName)metakey) -> None :

Assert that this contains some metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

void assertHasMetadata(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

assertHasMetadata( (MoleculeView)arg1, (PropertyName)key, (PropertyName)metakey) -> None :

Assert that this contains some metadata at metakey metakey for the property at key key Throw: SireBase::missing_property

C++ signature :

void assertHasMetadata(SireMol::MoleculeView {lvalue},SireBase::PropertyName,SireBase::PropertyName)

assert_has_property()

assertHasProperty( (MoleculeView)arg1, (PropertyName)key) -> None :

Assert that this contains a property at key key Throw: SireBase::missing_property

C++ signature :

void assertHasProperty(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

assert_same_molecule()

assertSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> None :

Assert that this is a view of the same molecule as other (albeit at a different version) Throw: SireError::incompatible_error

C++ signature :

void assertSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeView)

assertSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> None :

Assert that this view is looking at the molecule whose data is in other (albeit perhaps a different version of that molecule) Throw: SireError::incompatible_error

C++ signature :

void assertSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeData)

assign((Angle)arg1, (Angle)other) → Angle :

C++ signature :

SireMM::Angle {lvalue} assign(SireMM::Angle {lvalue},SireMM::Angle)

atom((MoleculeView)arg1, (int)i[, (PropertyMap)map={}]) → Atom :

Return the atom in this view that matches the ID atomid

Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},int [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> Atom :

Return the atom in this view that matches the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Atom :

Return the atom in this view that matches the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1) -> Atom :

Return this view as a Atom - this will only work if this view contains only a single atom Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue})

atom0((Angle)arg1) → Atom :

C++ signature :

SireMol::Atom atom0(SireMM::Angle {lvalue})

atom1((Angle)arg1) → Atom :

C++ signature :

SireMol::Atom atom1(SireMM::Angle {lvalue})

atom2((Angle)arg1) → Atom :

C++ signature :

SireMol::Atom atom2(SireMM::Angle {lvalue})

atoms((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Atom_ :

Return the atoms from this view that match the ID atomid

Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue})

chains((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Chain_ :

Return the chains that are involved with this view that match

the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1) -> Selector_Chain_ :

Return the chains that are involved with this view Throw: SireMol::missing_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue})

clone((Angle)arg1) → Angle :

C++ signature :

SireMM::Angle clone(SireMM::Angle)

const_data()

constData( (MoleculeView)arg1) -> object :

Return the MoleculeData that contains all of the information about the molecule which this view is showing

C++ signature :

SireMol::MoleculeData constData(SireMol::MoleculeView {lvalue})

count()

nAtoms( (MoleculeView)arg1) -> int :

Return the number of atoms in this view

C++ signature :

int nAtoms(SireMol::MoleculeView {lvalue})

cursor(map=None)

Return a Cursor that can be used to edit the properties of this view

cutgroup()

cutGroup( (MoleculeView)arg1, (int)i [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},int [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1) -> CutGroup :

Return the CutGroup that contains the atom(s) in this view Throw: SireMol::missing_cutgroup Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue})

cutgroups()

cutGroups( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1) -> Selector_CutGroup_ :

Return all of the CutGroups that are involved in this view Throw: SireMol::missing_cutgroup

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue})

delete_all_frames()

deleteAllFrames( (MoleculeView)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue})

deleteAllFrames( (MoleculeView)arg1, (PropertyMap)map) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

delete_frame()

deleteFrame( (MoleculeView)arg1, (int)frame) -> None :

C++ signature :

void deleteFrame(SireMol::MoleculeView {lvalue},int)

deleteFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void deleteFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

energy((Angle)arg1) → GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::Angle {lvalue})

energy( (Angle)arg1, (PropertyMap)map) -> GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::Angle {lvalue},SireBase::PropertyMap)

evaluate((Angle)arg1) → Evaluator :

C++ signature :

SireMol::Evaluator evaluate(SireMM::Angle {lvalue})

get_link()

getLink( (MoleculeView)arg1, (PropertyName)key) -> object :

Return the link for the given property name. This will throw an exception if there is no link for the given property name.

C++ signature :

QString getLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

get_links()

getLinks( (MoleculeView)arg1) -> object :

Return the property links for this molecule. This returns an empty dictionary if there are no links.

C++ signature :

QHash<QString, QString> getLinks(SireMol::MoleculeView {lvalue})

has_links()

hasLinks( (MoleculeView)arg1) -> bool :

Return whether or not this molecule has any property links

C++ signature :

bool hasLinks(SireMol::MoleculeView {lvalue})

has_metadata()

hasMetadata( (Angle)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasMetadata(SireMM::Angle {lvalue},SireBase::PropertyName)

hasMetadata( (Angle)arg1, (PropertyName)key, (PropertyName)metakey) -> bool :

C++ signature :

bool hasMetadata(SireMM::Angle {lvalue},SireBase::PropertyName,SireBase::PropertyName)

has_property()

hasProperty( (Angle)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasProperty(SireMM::Angle {lvalue},SireBase::PropertyName)

id()

ID( (Angle)arg1) -> AngleID :

C++ signature :

SireMol::AngleID ID(SireMM::Angle {lvalue})

invert((Angle)arg1) → SelectorAngle :

C++ signature :

SireMM::SelectorAngle invert(SireMM::Angle {lvalue})

is_empty()

isEmpty( (Angle)arg1) -> bool :

C++ signature :

bool isEmpty(SireMM::Angle {lvalue})

is_link()

isLink( (MoleculeView)arg1, (PropertyName)key) -> bool :

Return whether or not this molecule has a link for the given property name

C++ signature :

bool isLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

is_null()

isNull( (MoleculeView)arg1) -> bool :

Return whether or not this molecule view is null

C++ signature :

bool isNull(SireMol::MoleculeView {lvalue})

is_same_molecule()

isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :

Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)

C++ signature :

bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeView)

isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :

Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)

C++ signature :

bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeData)

is_selector()

isSelector( (MoleculeView)arg1) -> bool :

Return whether or not this is a Selector<T> object. This

helps code distinguish between views of single objects, e.g. Atom, Residue etc., and views of multiple objects, e.g. Selector<Atom>, Selector<Residue> etc.

C++ signature :

bool isSelector(SireMol::MoleculeView {lvalue})

load_frame()

loadFrame( (MoleculeView)arg1, (int)frame) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int)

loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator)

loadFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator,SireBase::PropertyMap)

measure((Angle)arg1) → object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> measure(SireMM::Angle {lvalue})

measure( (Angle)arg1, (PropertyMap)map) -> object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> measure(SireMM::Angle {lvalue},SireBase::PropertyMap)

metadata_keys()

metadataKeys( (Angle)arg1) -> object :

C++ signature :

QStringList metadataKeys(SireMM::Angle {lvalue})

metadataKeys( (Angle)arg1, (PropertyName)key) -> object :

C++ signature :

QStringList metadataKeys(SireMM::Angle {lvalue},SireBase::PropertyName)

metadata_type()

metadataType( (MoleculeView)arg1, (PropertyName)metakey) -> str :

Return the type of the metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

char const* metadataType(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

metadataType( (MoleculeView)arg1, (PropertyName)key, (PropertyName)metakey) -> str :

Return the type of the metadata at metakey metakey for the property at key key Throw: SireBase::missing_property

C++ signature :

char const* metadataType(SireMol::MoleculeView {lvalue},SireBase::PropertyName,SireBase::PropertyName)

molecules(idx=None, auto_reduce=False, error_on_missing: bool = False, map=None)

Return the molecule that contains this view as a list of molecules, containing just a single molecule.

If ‘id’ is specified then this checks that this molecule matches the ID before returning it. This will raise an exception if the ID doesn’t match.

Returns:

sire.mol.SelectorMol – that contains this view.

Return type:

A collection containing only a single molecule

move((Angle)arg1) → Mover_Angle_ :

C++ signature :

SireMol::Mover<SireMM::Angle> move(SireMM::Angle {lvalue})

num_atoms()

nAtoms( (MoleculeView)arg1) -> int :

Return the number of atoms in this view

C++ signature :

int nAtoms(SireMol::MoleculeView {lvalue})

num_chains()

nChains( (MoleculeView)arg1) -> int :

Return the number of chains in this view

C++ signature :

int nChains(SireMol::MoleculeView {lvalue})

num_cutgroups()

nCutGroups( (MoleculeView)arg1) -> int :

Return the number of CutGroups in this view

C++ signature :

int nCutGroups(SireMol::MoleculeView {lvalue})

num_frames()

nFrames( (MoleculeView)arg1) -> int :

C++ signature :

int nFrames(SireMol::MoleculeView {lvalue})

nFrames( (MoleculeView)arg1, (PropertyMap)map) -> int :

C++ signature :

int nFrames(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

num_residues()

nResidues( (MoleculeView)arg1) -> int :

Return the number of residues in this view

C++ signature :

int nResidues(SireMol::MoleculeView {lvalue})

num_segments()

nSegments( (MoleculeView)arg1) -> int :

Return the number of segments in this view

C++ signature :

int nSegments(SireMol::MoleculeView {lvalue})

num_views()

nViews( (MoleculeView)arg1) -> int :

Return the number of sub-views in this view. Most MoleculeViews are just a single view, but some (e.g. ViewsOfMol or Selector<T>) have multiple views

C++ signature :

int nViews(SireMol::MoleculeView {lvalue})

potential((Angle)arg1) → Expression :

C++ signature :

SireCAS::Expression potential(SireMM::Angle {lvalue})

potential( (Angle)arg1, (PropertyMap)map) -> Expression :

C++ signature :

SireCAS::Expression potential(SireMM::Angle {lvalue},SireBase::PropertyMap)

properties((Angle)arg1) → Properties :

C++ signature :

SireBase::Properties properties(SireMM::Angle {lvalue})

property_keys()

propertyKeys( (Angle)arg1) -> object :

C++ signature :

QStringList propertyKeys(SireMM::Angle {lvalue})

property_type()

propertyType( (MoleculeView)arg1, (PropertyName)key) -> str :

Return the type of the property at key key Throw: SireBase::missing_property

C++ signature :

char const* propertyType(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

residues((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Residue_ :

Return the residues from this view that match the ID resid

Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1) -> Selector_Residue_ :

Return all of the residues that are involved with this view Throw: SireMol::missing_residue

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue})

save_frame()

saveFrame( (MoleculeView)arg1 [, (int)frame]) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue} [,int])

saveFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

saveFrame( (MoleculeView)arg1, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

segments((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Segment_ :

Return the segments that are involved with this view that match

the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1) -> Selector_Segment_ :

Return the segments that are involved with this view Throw: SireMol::missing_segment

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue})

select_all()

selectAll( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> selectAll(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> selectAll(SireMol::MoleculeView {lvalue})

selectAll( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> selectAll(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> selectAll(SireMol::MoleculeView {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> selectAll(SireMol::MoleculeView {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> selectAll(SireMol::MoleculeView {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

select_all_atoms()

selectAllAtoms( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> selectAllAtoms(SireMol::MoleculeView {lvalue})

select_all_chains()

selectAllChains( (MoleculeView)arg1) -> Selector_Chain_ :

Return the chains that are involved with this view Throw: SireMol::missing_chain

C++ signature :

SireMol::Selector<SireMol::Chain> selectAllChains(SireMol::MoleculeView {lvalue})

select_all_cutgroups()

selectAllCutGroups( (MoleculeView)arg1) -> Selector_CutGroup_ :

Return all of the CutGroups that are involved in this view Throw: SireMol::missing_cutgroup

C++ signature :

SireMol::Selector<SireMol::CutGroup> selectAllCutGroups(SireMol::MoleculeView {lvalue})

select_all_residues()

selectAllResidues( (MoleculeView)arg1) -> Selector_Residue_ :

Return all of the residues that are involved with this view Throw: SireMol::missing_residue

C++ signature :

SireMol::Selector<SireMol::Residue> selectAllResidues(SireMol::MoleculeView {lvalue})

select_all_segments()

selectAllSegments( (MoleculeView)arg1) -> Selector_Segment_ :

Return the segments that are involved with this view Throw: SireMol::missing_segment

C++ signature :

SireMol::Selector<SireMol::Segment> selectAllSegments(SireMol::MoleculeView {lvalue})

selected_all()

selectedAll( (Angle)arg1) -> bool :

C++ signature :

bool selectedAll(SireMM::Angle {lvalue})

selection((Angle)arg1) → AtomSelection :

C++ signature :

SireMol::AtomSelection selection(SireMM::Angle {lvalue})

selector((Angle)arg1) → SelectorAngle :

C++ signature :

SireMM::SelectorAngle selector(SireMM::Angle {lvalue})

size()

measure( (Angle)arg1) -> object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> measure(SireMM::Angle {lvalue})

measure( (Angle)arg1, (PropertyMap)map) -> object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> measure(SireMM::Angle {lvalue},SireBase::PropertyMap)

to_list()

toList( (MoleculeView)arg1) -> object :

Expand this into a list of unit classes. This will return the view itself if

this is a unit class, e.g. Atom, Residue, Molecule etc. This will return a list of unit classes if this is a Selector<T> or equivalent type class.

C++ signature :

QList<SireBase::PropPtr<SireMol::MoleculeView>> toList(SireMol::MoleculeView {lvalue})

to_molecules()

toMolecules( (MoleculeView)arg1) -> Molecules :

Return a Molecules set that contains this view (or views)

C++ signature :

SireMol::Molecules toMolecules(SireMol::MoleculeView {lvalue})

to_selector()

toSelector( (Angle)arg1) -> object :

C++ signature :

SireBase::PropPtr<SireMol::MoleculeView> toSelector(SireMM::Angle {lvalue})

to_string()

toString( (Angle)arg1) -> object :

C++ signature :

QString toString(SireMM::Angle {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((Angle)arg1) → str :

C++ signature :

char const* what(SireMM::Angle {lvalue})

class sire.mm.AngleRestraint

This class represents a single angle restraint between any three atoms in a system Author: Christopher Woods

assign((AngleRestraint)arg1, (AngleRestraint)other) → AngleRestraint :

C++ signature :

SireMM::AngleRestraint {lvalue} assign(SireMM::AngleRestraint {lvalue},SireMM::AngleRestraint)

atoms((AngleRestraint)arg1) → object :

Return the atoms involved in the restraint

C++ signature :

QVector<long long> atoms(SireMM::AngleRestraint {lvalue})

clone((AngleRestraint)arg1) → AngleRestraint :

C++ signature :

SireMM::AngleRestraint clone(SireMM::AngleRestraint)

is_null()

isNull( (AngleRestraint)arg1) -> bool :

C++ signature :

bool isNull(SireMM::AngleRestraint {lvalue})

ktheta((AngleRestraint)arg1) → object :

Return the force constant for the restraint

C++ signature :

SireUnits::Dimension::PhysUnit<1, 2, -2, 0, 0, -1, -2> ktheta(SireMM::AngleRestraint {lvalue})

theta0((AngleRestraint)arg1) → object :

Return the equilibrium angle for the restraint

C++ signature :

SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> theta0(SireMM::AngleRestraint {lvalue})

to_string()

toString( (AngleRestraint)arg1) -> object :

C++ signature :

QString toString(SireMM::AngleRestraint {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((AngleRestraint)arg1) → str :

C++ signature :

char const* what(SireMM::AngleRestraint {lvalue})

class sire.mm.AngleRestraints

This class represents a collection of angle restraints

add((AngleRestraints)arg1, (AngleRestraint)restraint) → None :

Add a restraint onto the list

C++ signature :

void add(SireMM::AngleRestraints {lvalue},SireMM::AngleRestraint)

add( (AngleRestraints)arg1, (AngleRestraints)restraints) -> None :

Add a restraint onto the list

C++ signature :

void add(SireMM::AngleRestraints {lvalue},SireMM::AngleRestraints)

assign((AngleRestraints)arg1, (AngleRestraints)other) → AngleRestraints :

C++ signature :

SireMM::AngleRestraints {lvalue} assign(SireMM::AngleRestraints {lvalue},SireMM::AngleRestraints)

at((AngleRestraints)arg1, (int)i) → AngleRestraint :

Return the ith restraint

C++ signature :

SireMM::AngleRestraint at(SireMM::AngleRestraints {lvalue},int)

clone((AngleRestraints)arg1) → AngleRestraints :

C++ signature :

SireMM::AngleRestraints clone(SireMM::AngleRestraints)

count((AngleRestraints)arg1) → int :

Return the number of restraints

C++ signature :

int count(SireMM::AngleRestraints {lvalue})

is_empty()

isEmpty( (AngleRestraints)arg1) -> bool :

Return whether or not this is empty

C++ signature :

bool isEmpty(SireMM::AngleRestraints {lvalue})

is_null()

isNull( (AngleRestraints)arg1) -> bool :

Return whether or not this is empty

C++ signature :

bool isNull(SireMM::AngleRestraints {lvalue})

is_restraints()

isRestraints( (Restraints)arg1) -> bool :

Return whether or not this is a Restraints object (or derived from this object)

C++ signature :

bool isRestraints(SireMM::Restraints {lvalue})

num_restraints()

nRestraints( (AngleRestraints)arg1) -> int :

Return the number of restraints

C++ signature :

int nRestraints(SireMM::AngleRestraints {lvalue})

restraints((AngleRestraints)arg1) → object :

Return all of the restraints

C++ signature :

QList<SireMM::AngleRestraint> restraints(SireMM::AngleRestraints {lvalue})

set_name()

setName( (Restraints)arg1, (object)name) -> None :

Set the name for this group of restraints

C++ signature :

void setName(SireMM::Restraints {lvalue},QString)

size((AngleRestraints)arg1) → int :

Return the number of restraints

C++ signature :

int size(SireMM::AngleRestraints {lvalue})

to_string()

toString( (AngleRestraints)arg1) -> object :

C++ signature :

QString toString(SireMM::AngleRestraints {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((AngleRestraints)arg1) → str :

C++ signature :

char const* what(SireMM::AngleRestraints {lvalue})

class sire.mm.Bond

This class provides a molecule view to a bond

assert_contains()

assertContains( (MoleculeView)arg1, (AtomIdx)atomidx) -> None :

Assert that this view contains the atom at index atomidx Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

void assertContains(SireMol::MoleculeView {lvalue},SireMol::AtomIdx)

assert_has_metadata()

assertHasMetadata( (MoleculeView)arg1, (PropertyName)metakey) -> None :

Assert that this contains some metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

void assertHasMetadata(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

assertHasMetadata( (MoleculeView)arg1, (PropertyName)key, (PropertyName)metakey) -> None :

Assert that this contains some metadata at metakey metakey for the property at key key Throw: SireBase::missing_property

C++ signature :

void assertHasMetadata(SireMol::MoleculeView {lvalue},SireBase::PropertyName,SireBase::PropertyName)

assert_has_property()

assertHasProperty( (MoleculeView)arg1, (PropertyName)key) -> None :

Assert that this contains a property at key key Throw: SireBase::missing_property

C++ signature :

void assertHasProperty(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

assert_same_molecule()

assertSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> None :

Assert that this is a view of the same molecule as other (albeit at a different version) Throw: SireError::incompatible_error

C++ signature :

void assertSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeView)

assertSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> None :

Assert that this view is looking at the molecule whose data is in other (albeit perhaps a different version of that molecule) Throw: SireError::incompatible_error

C++ signature :

void assertSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeData)

assign((Bond)arg1, (Bond)bond) → Bond :

C++ signature :

SireMM::Bond {lvalue} assign(SireMM::Bond {lvalue},SireMM::Bond)

atom((MoleculeView)arg1, (int)i[, (PropertyMap)map={}]) → Atom :

Return the atom in this view that matches the ID atomid

Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},int [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> Atom :

Return the atom in this view that matches the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Atom :

Return the atom in this view that matches the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1) -> Atom :

Return this view as a Atom - this will only work if this view contains only a single atom Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue})

atom0((Bond)arg1) → Atom :

C++ signature :

SireMol::Atom atom0(SireMM::Bond {lvalue})

atom1((Bond)arg1) → Atom :

C++ signature :

SireMol::Atom atom1(SireMM::Bond {lvalue})

atoms((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Atom_ :

Return the atoms from this view that match the ID atomid

Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue})

chains((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Chain_ :

Return the chains that are involved with this view that match

the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1) -> Selector_Chain_ :

Return the chains that are involved with this view Throw: SireMol::missing_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue})

clone((Bond)arg1) → Bond :

C++ signature :

SireMM::Bond clone(SireMM::Bond)

const_data()

constData( (MoleculeView)arg1) -> object :

Return the MoleculeData that contains all of the information about the molecule which this view is showing

C++ signature :

SireMol::MoleculeData constData(SireMol::MoleculeView {lvalue})

count()

nAtoms( (MoleculeView)arg1) -> int :

Return the number of atoms in this view

C++ signature :

int nAtoms(SireMol::MoleculeView {lvalue})

cursor(map=None)

Return a Cursor that can be used to edit the properties of this view

cutgroup()

cutGroup( (MoleculeView)arg1, (int)i [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},int [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1) -> CutGroup :

Return the CutGroup that contains the atom(s) in this view Throw: SireMol::missing_cutgroup Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue})

cutgroups()

cutGroups( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1) -> Selector_CutGroup_ :

Return all of the CutGroups that are involved in this view Throw: SireMol::missing_cutgroup

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue})

delete_all_frames()

deleteAllFrames( (MoleculeView)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue})

deleteAllFrames( (MoleculeView)arg1, (PropertyMap)map) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

delete_frame()

deleteFrame( (MoleculeView)arg1, (int)frame) -> None :

C++ signature :

void deleteFrame(SireMol::MoleculeView {lvalue},int)

deleteFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void deleteFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

energy((Bond)arg1) → GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::Bond {lvalue})

energy( (Bond)arg1, (PropertyMap)map) -> GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::Bond {lvalue},SireBase::PropertyMap)

evaluate((Bond)arg1) → Evaluator :

C++ signature :

SireMol::Evaluator evaluate(SireMM::Bond {lvalue})

get_link()

getLink( (MoleculeView)arg1, (PropertyName)key) -> object :

Return the link for the given property name. This will throw an exception if there is no link for the given property name.

C++ signature :

QString getLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

get_links()

getLinks( (MoleculeView)arg1) -> object :

Return the property links for this molecule. This returns an empty dictionary if there are no links.

C++ signature :

QHash<QString, QString> getLinks(SireMol::MoleculeView {lvalue})

has_links()

hasLinks( (MoleculeView)arg1) -> bool :

Return whether or not this molecule has any property links

C++ signature :

bool hasLinks(SireMol::MoleculeView {lvalue})

has_metadata()

hasMetadata( (Bond)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasMetadata(SireMM::Bond {lvalue},SireBase::PropertyName)

hasMetadata( (Bond)arg1, (PropertyName)key, (PropertyName)metakey) -> bool :

C++ signature :

bool hasMetadata(SireMM::Bond {lvalue},SireBase::PropertyName,SireBase::PropertyName)

has_property()

hasProperty( (Bond)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasProperty(SireMM::Bond {lvalue},SireBase::PropertyName)

id()

ID( (Bond)arg1) -> BondID :

C++ signature :

SireMol::BondID ID(SireMM::Bond {lvalue})

invert((Bond)arg1) → SelectorBond :

C++ signature :

SireMM::SelectorBond invert(SireMM::Bond {lvalue})

is_empty()

isEmpty( (Bond)arg1) -> bool :

C++ signature :

bool isEmpty(SireMM::Bond {lvalue})

is_link()

isLink( (MoleculeView)arg1, (PropertyName)key) -> bool :

Return whether or not this molecule has a link for the given property name

C++ signature :

bool isLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

is_null()

isNull( (MoleculeView)arg1) -> bool :

Return whether or not this molecule view is null

C++ signature :

bool isNull(SireMol::MoleculeView {lvalue})

is_same_molecule()

isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :

Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)

C++ signature :

bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeView)

isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :

Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)

C++ signature :

bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeData)

is_selector()

isSelector( (MoleculeView)arg1) -> bool :

Return whether or not this is a Selector<T> object. This

helps code distinguish between views of single objects, e.g. Atom, Residue etc., and views of multiple objects, e.g. Selector<Atom>, Selector<Residue> etc.

C++ signature :

bool isSelector(SireMol::MoleculeView {lvalue})

length((Bond)arg1) → object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0> length(SireMM::Bond {lvalue})

length( (Bond)arg1, (PropertyMap)map) -> object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0> length(SireMM::Bond {lvalue},SireBase::PropertyMap)

load_frame()

loadFrame( (MoleculeView)arg1, (int)frame) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int)

loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator)

loadFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator,SireBase::PropertyMap)

measure((Bond)arg1) → object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0> measure(SireMM::Bond {lvalue})

measure( (Bond)arg1, (PropertyMap)map) -> object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0> measure(SireMM::Bond {lvalue},SireBase::PropertyMap)

metadata_keys()

metadataKeys( (Bond)arg1) -> object :

C++ signature :

QStringList metadataKeys(SireMM::Bond {lvalue})

metadataKeys( (Bond)arg1, (PropertyName)key) -> object :

C++ signature :

QStringList metadataKeys(SireMM::Bond {lvalue},SireBase::PropertyName)

metadata_type()

metadataType( (MoleculeView)arg1, (PropertyName)metakey) -> str :

Return the type of the metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

char const* metadataType(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

metadataType( (MoleculeView)arg1, (PropertyName)key, (PropertyName)metakey) -> str :

Return the type of the metadata at metakey metakey for the property at key key Throw: SireBase::missing_property

C++ signature :

char const* metadataType(SireMol::MoleculeView {lvalue},SireBase::PropertyName,SireBase::PropertyName)

molecules(idx=None, auto_reduce=False, error_on_missing: bool = False, map=None)

Return the molecule that contains this view as a list of molecules, containing just a single molecule.

If ‘id’ is specified then this checks that this molecule matches the ID before returning it. This will raise an exception if the ID doesn’t match.

Returns:

sire.mol.SelectorMol – that contains this view.

Return type:

A collection containing only a single molecule

move((Bond)arg1) → Mover_Bond_ :

C++ signature :

SireMol::Mover<SireMM::Bond> move(SireMM::Bond {lvalue})

num_atoms()

nAtoms( (MoleculeView)arg1) -> int :

Return the number of atoms in this view

C++ signature :

int nAtoms(SireMol::MoleculeView {lvalue})

num_chains()

nChains( (MoleculeView)arg1) -> int :

Return the number of chains in this view

C++ signature :

int nChains(SireMol::MoleculeView {lvalue})

num_cutgroups()

nCutGroups( (MoleculeView)arg1) -> int :

Return the number of CutGroups in this view

C++ signature :

int nCutGroups(SireMol::MoleculeView {lvalue})

num_frames()

nFrames( (MoleculeView)arg1) -> int :

C++ signature :

int nFrames(SireMol::MoleculeView {lvalue})

nFrames( (MoleculeView)arg1, (PropertyMap)map) -> int :

C++ signature :

int nFrames(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

num_residues()

nResidues( (MoleculeView)arg1) -> int :

Return the number of residues in this view

C++ signature :

int nResidues(SireMol::MoleculeView {lvalue})

num_segments()

nSegments( (MoleculeView)arg1) -> int :

Return the number of segments in this view

C++ signature :

int nSegments(SireMol::MoleculeView {lvalue})

num_views()

nViews( (MoleculeView)arg1) -> int :

Return the number of sub-views in this view. Most MoleculeViews are just a single view, but some (e.g. ViewsOfMol or Selector<T>) have multiple views

C++ signature :

int nViews(SireMol::MoleculeView {lvalue})

potential((Bond)arg1) → Expression :

C++ signature :

SireCAS::Expression potential(SireMM::Bond {lvalue})

potential( (Bond)arg1, (PropertyMap)map) -> Expression :

C++ signature :

SireCAS::Expression potential(SireMM::Bond {lvalue},SireBase::PropertyMap)

properties((Bond)arg1) → Properties :

C++ signature :

SireBase::Properties properties(SireMM::Bond {lvalue})

property_keys()

propertyKeys( (Bond)arg1) -> object :

C++ signature :

QStringList propertyKeys(SireMM::Bond {lvalue})

property_type()

propertyType( (MoleculeView)arg1, (PropertyName)key) -> str :

Return the type of the property at key key Throw: SireBase::missing_property

C++ signature :

char const* propertyType(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

residues((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Residue_ :

Return the residues from this view that match the ID resid

Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1) -> Selector_Residue_ :

Return all of the residues that are involved with this view Throw: SireMol::missing_residue

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue})

save_frame()

saveFrame( (MoleculeView)arg1 [, (int)frame]) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue} [,int])

saveFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

saveFrame( (MoleculeView)arg1, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

segments((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Segment_ :

Return the segments that are involved with this view that match

the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1) -> Selector_Segment_ :

Return the segments that are involved with this view Throw: SireMol::missing_segment

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue})

select_all()

selectAll( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> selectAll(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> selectAll(SireMol::MoleculeView {lvalue})

selectAll( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> selectAll(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> selectAll(SireMol::MoleculeView {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> selectAll(SireMol::MoleculeView {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> selectAll(SireMol::MoleculeView {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

select_all_atoms()

selectAllAtoms( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> selectAllAtoms(SireMol::MoleculeView {lvalue})

select_all_chains()

selectAllChains( (MoleculeView)arg1) -> Selector_Chain_ :

Return the chains that are involved with this view Throw: SireMol::missing_chain

C++ signature :

SireMol::Selector<SireMol::Chain> selectAllChains(SireMol::MoleculeView {lvalue})

select_all_cutgroups()

selectAllCutGroups( (MoleculeView)arg1) -> Selector_CutGroup_ :

Return all of the CutGroups that are involved in this view Throw: SireMol::missing_cutgroup

C++ signature :

SireMol::Selector<SireMol::CutGroup> selectAllCutGroups(SireMol::MoleculeView {lvalue})

select_all_residues()

selectAllResidues( (MoleculeView)arg1) -> Selector_Residue_ :

Return all of the residues that are involved with this view Throw: SireMol::missing_residue

C++ signature :

SireMol::Selector<SireMol::Residue> selectAllResidues(SireMol::MoleculeView {lvalue})

select_all_segments()

selectAllSegments( (MoleculeView)arg1) -> Selector_Segment_ :

Return the segments that are involved with this view Throw: SireMol::missing_segment

C++ signature :

SireMol::Selector<SireMol::Segment> selectAllSegments(SireMol::MoleculeView {lvalue})

selected_all()

selectedAll( (Bond)arg1) -> bool :

C++ signature :

bool selectedAll(SireMM::Bond {lvalue})

selection((Bond)arg1) → AtomSelection :

C++ signature :

SireMol::AtomSelection selection(SireMM::Bond {lvalue})

selector((Bond)arg1) → SelectorBond :

C++ signature :

SireMM::SelectorBond selector(SireMM::Bond {lvalue})

size()

measure( (Bond)arg1) -> object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0> measure(SireMM::Bond {lvalue})

measure( (Bond)arg1, (PropertyMap)map) -> object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0> measure(SireMM::Bond {lvalue},SireBase::PropertyMap)

to_list()

toList( (MoleculeView)arg1) -> object :

Expand this into a list of unit classes. This will return the view itself if

this is a unit class, e.g. Atom, Residue, Molecule etc. This will return a list of unit classes if this is a Selector<T> or equivalent type class.

C++ signature :

QList<SireBase::PropPtr<SireMol::MoleculeView>> toList(SireMol::MoleculeView {lvalue})

to_molecules()

toMolecules( (MoleculeView)arg1) -> Molecules :

Return a Molecules set that contains this view (or views)

C++ signature :

SireMol::Molecules toMolecules(SireMol::MoleculeView {lvalue})

to_selector()

toSelector( (Bond)arg1) -> object :

C++ signature :

SireBase::PropPtr<SireMol::MoleculeView> toSelector(SireMM::Bond {lvalue})

to_string()

toString( (Bond)arg1) -> object :

C++ signature :

QString toString(SireMM::Bond {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((Bond)arg1) → str :

C++ signature :

char const* what(SireMM::Bond {lvalue})

class sire.mm.BondRestraint

This class represents a single bond restraint between any two atoms in a system (or between the centroids of any two groups of atoms in a system)

assign((BondRestraint)arg1, (BondRestraint)other) → BondRestraint :

C++ signature :

SireMM::BondRestraint {lvalue} assign(SireMM::BondRestraint {lvalue},SireMM::BondRestraint)

atom0((BondRestraint)arg1) → int :

Return the index of the atom if this is a single-atom restraint

C++ signature :

long long atom0(SireMM::BondRestraint {lvalue})

atom1((BondRestraint)arg1) → int :

Return the index of the atom if this is a single-atom restraint

C++ signature :

long long atom1(SireMM::BondRestraint {lvalue})

atoms0((BondRestraint)arg1) → object :

Return the indexes of the atoms whose centroid is to be restrained

C++ signature :

QVector<long long> atoms0(SireMM::BondRestraint {lvalue})

atoms1((BondRestraint)arg1) → object :

Return the indexes of the atoms whose centroid is to be restrained

C++ signature :

QVector<long long> atoms1(SireMM::BondRestraint {lvalue})

clone((BondRestraint)arg1) → BondRestraint :

C++ signature :

SireMM::BondRestraint clone(SireMM::BondRestraint)

is_atom_restraint()

isAtomRestraint( (BondRestraint)arg1) -> bool :

Return whether this is a single-atom restraint

C++ signature :

bool isAtomRestraint(SireMM::BondRestraint {lvalue})

is_centroid_restraint()

isCentroidRestraint( (BondRestraint)arg1) -> bool :

Return whether this restraint acts on the centroid of a group

of atoms

C++ signature :

bool isCentroidRestraint(SireMM::BondRestraint {lvalue})

is_null()

isNull( (BondRestraint)arg1) -> bool :

C++ signature :

bool isNull(SireMM::BondRestraint {lvalue})

k((BondRestraint)arg1) → object :

Return the force constant for the restraint

C++ signature :

SireUnits::Dimension::PhysUnit<1, 0, -2, 0, 0, -1, 0> k(SireMM::BondRestraint {lvalue})

r0((BondRestraint)arg1) → object :

Return the width of the harmonic bond.

C++ signature :

SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0> r0(SireMM::BondRestraint {lvalue})

to_string()

toString( (BondRestraint)arg1) -> object :

C++ signature :

QString toString(SireMM::BondRestraint {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((BondRestraint)arg1) → str :

C++ signature :

char const* what(SireMM::BondRestraint {lvalue})

class sire.mm.BondRestraints

This class provides the information for a collection of bond restraints that can be added to a collection of molecues. Each restraint can act on a pair of particles or a pair of the centroids of two collections of particles. The restaints are spherically symmetric, and are simple harmonic potentials

add((BondRestraints)arg1, (BondRestraint)restraint) → None :

Add a restraint onto the list

C++ signature :

void add(SireMM::BondRestraints {lvalue},SireMM::BondRestraint)

add( (BondRestraints)arg1, (BondRestraints)restraints) -> None :

Add a restraint onto the list

C++ signature :

void add(SireMM::BondRestraints {lvalue},SireMM::BondRestraints)

assign((BondRestraints)arg1, (BondRestraints)other) → BondRestraints :

C++ signature :

SireMM::BondRestraints {lvalue} assign(SireMM::BondRestraints {lvalue},SireMM::BondRestraints)

at((BondRestraints)arg1, (int)i) → BondRestraint :

Return the ith restraint

C++ signature :

SireMM::BondRestraint at(SireMM::BondRestraints {lvalue},int)

atom_restraints()

atomRestraints( (BondRestraints)arg1) -> object :

Return all of the atom restraints

C++ signature :

QList<SireMM::BondRestraint> atomRestraints(SireMM::BondRestraints {lvalue})

centroid_restraints()

centroidRestraints( (BondRestraints)arg1) -> object :

Return all of the centroid restraints

C++ signature :

QList<SireMM::BondRestraint> centroidRestraints(SireMM::BondRestraints {lvalue})

clone((BondRestraints)arg1) → BondRestraints :

C++ signature :

SireMM::BondRestraints clone(SireMM::BondRestraints)

count((BondRestraints)arg1) → int :

Return the number of restraints

C++ signature :

int count(SireMM::BondRestraints {lvalue})

has_atom_restraints()

hasAtomRestraints( (BondRestraints)arg1) -> bool :

Return whether or not there are any atom restraints

C++ signature :

bool hasAtomRestraints(SireMM::BondRestraints {lvalue})

has_centroid_restraints()

hasCentroidRestraints( (BondRestraints)arg1) -> bool :

Return whether or not there are any centroid restraints

C++ signature :

bool hasCentroidRestraints(SireMM::BondRestraints {lvalue})

is_empty()

isEmpty( (BondRestraints)arg1) -> bool :

Return whether or not this is empty

C++ signature :

bool isEmpty(SireMM::BondRestraints {lvalue})

is_null()

isNull( (BondRestraints)arg1) -> bool :

Return whether or not this is empty

C++ signature :

bool isNull(SireMM::BondRestraints {lvalue})

is_restraints()

isRestraints( (Restraints)arg1) -> bool :

Return whether or not this is a Restraints object (or derived from this object)

C++ signature :

bool isRestraints(SireMM::Restraints {lvalue})

num_atom_restraints()

nAtomRestraints( (BondRestraints)arg1) -> int :

Return the number of atom restraints

C++ signature :

int nAtomRestraints(SireMM::BondRestraints {lvalue})

num_centroid_restraints()

nCentroidRestraints( (BondRestraints)arg1) -> int :

Return the number of centroid restraints

C++ signature :

int nCentroidRestraints(SireMM::BondRestraints {lvalue})

num_restraints()

nRestraints( (BondRestraints)arg1) -> int :

Return the number of restraints

C++ signature :

int nRestraints(SireMM::BondRestraints {lvalue})

restraints((BondRestraints)arg1) → object :

Return all of the restraints

C++ signature :

QList<SireMM::BondRestraint> restraints(SireMM::BondRestraints {lvalue})

set_name()

setName( (Restraints)arg1, (object)name) -> None :

Set the name for this group of restraints

C++ signature :

void setName(SireMM::Restraints {lvalue},QString)

size((BondRestraints)arg1) → int :

Return the number of restraints

C++ signature :

int size(SireMM::BondRestraints {lvalue})

to_string()

toString( (BondRestraints)arg1) -> object :

C++ signature :

QString toString(SireMM::BondRestraints {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((BondRestraints)arg1) → str :

C++ signature :

char const* what(SireMM::BondRestraints {lvalue})

class sire.mm.Dihedral

This class provides a molecule view to a dihedral

assert_contains()

assertContains( (MoleculeView)arg1, (AtomIdx)atomidx) -> None :

Assert that this view contains the atom at index atomidx Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

void assertContains(SireMol::MoleculeView {lvalue},SireMol::AtomIdx)

assert_has_metadata()

assertHasMetadata( (MoleculeView)arg1, (PropertyName)metakey) -> None :

Assert that this contains some metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

void assertHasMetadata(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

assertHasMetadata( (MoleculeView)arg1, (PropertyName)key, (PropertyName)metakey) -> None :

Assert that this contains some metadata at metakey metakey for the property at key key Throw: SireBase::missing_property

C++ signature :

void assertHasMetadata(SireMol::MoleculeView {lvalue},SireBase::PropertyName,SireBase::PropertyName)

assert_has_property()

assertHasProperty( (MoleculeView)arg1, (PropertyName)key) -> None :

Assert that this contains a property at key key Throw: SireBase::missing_property

C++ signature :

void assertHasProperty(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

assert_same_molecule()

assertSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> None :

Assert that this is a view of the same molecule as other (albeit at a different version) Throw: SireError::incompatible_error

C++ signature :

void assertSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeView)

assertSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> None :

Assert that this view is looking at the molecule whose data is in other (albeit perhaps a different version of that molecule) Throw: SireError::incompatible_error

C++ signature :

void assertSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeData)

assign((Dihedral)arg1, (Dihedral)other) → Dihedral :

C++ signature :

SireMM::Dihedral {lvalue} assign(SireMM::Dihedral {lvalue},SireMM::Dihedral)

atom((MoleculeView)arg1, (int)i[, (PropertyMap)map={}]) → Atom :

Return the atom in this view that matches the ID atomid

Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},int [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> Atom :

Return the atom in this view that matches the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Atom :

Return the atom in this view that matches the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1) -> Atom :

Return this view as a Atom - this will only work if this view contains only a single atom Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue})

atom0((Dihedral)arg1) → Atom :

C++ signature :

SireMol::Atom atom0(SireMM::Dihedral {lvalue})

atom1((Dihedral)arg1) → Atom :

C++ signature :

SireMol::Atom atom1(SireMM::Dihedral {lvalue})

atom2((Dihedral)arg1) → Atom :

C++ signature :

SireMol::Atom atom2(SireMM::Dihedral {lvalue})

atom3((Dihedral)arg1) → Atom :

C++ signature :

SireMol::Atom atom3(SireMM::Dihedral {lvalue})

atoms((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Atom_ :

Return the atoms from this view that match the ID atomid

Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue})

chains((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Chain_ :

Return the chains that are involved with this view that match

the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1) -> Selector_Chain_ :

Return the chains that are involved with this view Throw: SireMol::missing_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue})

clone((Dihedral)arg1) → Dihedral :

C++ signature :

SireMM::Dihedral clone(SireMM::Dihedral)

const_data()

constData( (MoleculeView)arg1) -> object :

Return the MoleculeData that contains all of the information about the molecule which this view is showing

C++ signature :

SireMol::MoleculeData constData(SireMol::MoleculeView {lvalue})

count()

nAtoms( (MoleculeView)arg1) -> int :

Return the number of atoms in this view

C++ signature :

int nAtoms(SireMol::MoleculeView {lvalue})

cursor(map=None)

Return a Cursor that can be used to edit the properties of this view

cutgroup()

cutGroup( (MoleculeView)arg1, (int)i [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},int [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1) -> CutGroup :

Return the CutGroup that contains the atom(s) in this view Throw: SireMol::missing_cutgroup Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue})

cutgroups()

cutGroups( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1) -> Selector_CutGroup_ :

Return all of the CutGroups that are involved in this view Throw: SireMol::missing_cutgroup

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue})

delete_all_frames()

deleteAllFrames( (MoleculeView)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue})

deleteAllFrames( (MoleculeView)arg1, (PropertyMap)map) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

delete_frame()

deleteFrame( (MoleculeView)arg1, (int)frame) -> None :

C++ signature :

void deleteFrame(SireMol::MoleculeView {lvalue},int)

deleteFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void deleteFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

energy((Dihedral)arg1) → GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::Dihedral {lvalue})

energy( (Dihedral)arg1, (PropertyMap)map) -> GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::Dihedral {lvalue},SireBase::PropertyMap)

evaluate((Dihedral)arg1) → Evaluator :

C++ signature :

SireMol::Evaluator evaluate(SireMM::Dihedral {lvalue})

get_link()

getLink( (MoleculeView)arg1, (PropertyName)key) -> object :

Return the link for the given property name. This will throw an exception if there is no link for the given property name.

C++ signature :

QString getLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

get_links()

getLinks( (MoleculeView)arg1) -> object :

Return the property links for this molecule. This returns an empty dictionary if there are no links.

C++ signature :

QHash<QString, QString> getLinks(SireMol::MoleculeView {lvalue})

has_links()

hasLinks( (MoleculeView)arg1) -> bool :

Return whether or not this molecule has any property links

C++ signature :

bool hasLinks(SireMol::MoleculeView {lvalue})

has_metadata()

hasMetadata( (Dihedral)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasMetadata(SireMM::Dihedral {lvalue},SireBase::PropertyName)

hasMetadata( (Dihedral)arg1, (PropertyName)key, (PropertyName)metakey) -> bool :

C++ signature :

bool hasMetadata(SireMM::Dihedral {lvalue},SireBase::PropertyName,SireBase::PropertyName)

has_property()

hasProperty( (Dihedral)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasProperty(SireMM::Dihedral {lvalue},SireBase::PropertyName)

id()

ID( (Dihedral)arg1) -> DihedralID :

C++ signature :

SireMol::DihedralID ID(SireMM::Dihedral {lvalue})

invert((Dihedral)arg1) → SelectorDihedral :

C++ signature :

SireMM::SelectorDihedral invert(SireMM::Dihedral {lvalue})

is_empty()

isEmpty( (Dihedral)arg1) -> bool :

C++ signature :

bool isEmpty(SireMM::Dihedral {lvalue})

is_link()

isLink( (MoleculeView)arg1, (PropertyName)key) -> bool :

Return whether or not this molecule has a link for the given property name

C++ signature :

bool isLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

is_null()

isNull( (MoleculeView)arg1) -> bool :

Return whether or not this molecule view is null

C++ signature :

bool isNull(SireMol::MoleculeView {lvalue})

is_same_molecule()

isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :

Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)

C++ signature :

bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeView)

isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :

Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)

C++ signature :

bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeData)

is_selector()

isSelector( (MoleculeView)arg1) -> bool :

Return whether or not this is a Selector<T> object. This

helps code distinguish between views of single objects, e.g. Atom, Residue etc., and views of multiple objects, e.g. Selector<Atom>, Selector<Residue> etc.

C++ signature :

bool isSelector(SireMol::MoleculeView {lvalue})

load_frame()

loadFrame( (MoleculeView)arg1, (int)frame) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int)

loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator)

loadFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator,SireBase::PropertyMap)

measure((Dihedral)arg1) → object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> measure(SireMM::Dihedral {lvalue})

measure( (Dihedral)arg1, (PropertyMap)map) -> object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> measure(SireMM::Dihedral {lvalue},SireBase::PropertyMap)

metadata_keys()

metadataKeys( (Dihedral)arg1) -> object :

C++ signature :

QStringList metadataKeys(SireMM::Dihedral {lvalue})

metadataKeys( (Dihedral)arg1, (PropertyName)key) -> object :

C++ signature :

QStringList metadataKeys(SireMM::Dihedral {lvalue},SireBase::PropertyName)

metadata_type()

metadataType( (MoleculeView)arg1, (PropertyName)metakey) -> str :

Return the type of the metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

char const* metadataType(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

metadataType( (MoleculeView)arg1, (PropertyName)key, (PropertyName)metakey) -> str :

Return the type of the metadata at metakey metakey for the property at key key Throw: SireBase::missing_property

C++ signature :

char const* metadataType(SireMol::MoleculeView {lvalue},SireBase::PropertyName,SireBase::PropertyName)

molecules(idx=None, auto_reduce=False, error_on_missing: bool = False, map=None)

Return the molecule that contains this view as a list of molecules, containing just a single molecule.

If ‘id’ is specified then this checks that this molecule matches the ID before returning it. This will raise an exception if the ID doesn’t match.

Returns:

sire.mol.SelectorMol – that contains this view.

Return type:

A collection containing only a single molecule

move((Dihedral)arg1) → Mover_Dihedral_ :

C++ signature :

SireMol::Mover<SireMM::Dihedral> move(SireMM::Dihedral {lvalue})

num_atoms()

nAtoms( (MoleculeView)arg1) -> int :

Return the number of atoms in this view

C++ signature :

int nAtoms(SireMol::MoleculeView {lvalue})

num_chains()

nChains( (MoleculeView)arg1) -> int :

Return the number of chains in this view

C++ signature :

int nChains(SireMol::MoleculeView {lvalue})

num_cutgroups()

nCutGroups( (MoleculeView)arg1) -> int :

Return the number of CutGroups in this view

C++ signature :

int nCutGroups(SireMol::MoleculeView {lvalue})

num_frames()

nFrames( (MoleculeView)arg1) -> int :

C++ signature :

int nFrames(SireMol::MoleculeView {lvalue})

nFrames( (MoleculeView)arg1, (PropertyMap)map) -> int :

C++ signature :

int nFrames(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

num_residues()

nResidues( (MoleculeView)arg1) -> int :

Return the number of residues in this view

C++ signature :

int nResidues(SireMol::MoleculeView {lvalue})

num_segments()

nSegments( (MoleculeView)arg1) -> int :

Return the number of segments in this view

C++ signature :

int nSegments(SireMol::MoleculeView {lvalue})

num_views()

nViews( (MoleculeView)arg1) -> int :

Return the number of sub-views in this view. Most MoleculeViews are just a single view, but some (e.g. ViewsOfMol or Selector<T>) have multiple views

C++ signature :

int nViews(SireMol::MoleculeView {lvalue})

potential((Dihedral)arg1) → Expression :

C++ signature :

SireCAS::Expression potential(SireMM::Dihedral {lvalue})

potential( (Dihedral)arg1, (PropertyMap)map) -> Expression :

C++ signature :

SireCAS::Expression potential(SireMM::Dihedral {lvalue},SireBase::PropertyMap)

properties((Dihedral)arg1) → Properties :

C++ signature :

SireBase::Properties properties(SireMM::Dihedral {lvalue})

property_keys()

propertyKeys( (Dihedral)arg1) -> object :

C++ signature :

QStringList propertyKeys(SireMM::Dihedral {lvalue})

property_type()

propertyType( (MoleculeView)arg1, (PropertyName)key) -> str :

Return the type of the property at key key Throw: SireBase::missing_property

C++ signature :

char const* propertyType(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

residues((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Residue_ :

Return the residues from this view that match the ID resid

Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1) -> Selector_Residue_ :

Return all of the residues that are involved with this view Throw: SireMol::missing_residue

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue})

save_frame()

saveFrame( (MoleculeView)arg1 [, (int)frame]) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue} [,int])

saveFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

saveFrame( (MoleculeView)arg1, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

segments((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Segment_ :

Return the segments that are involved with this view that match

the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1) -> Selector_Segment_ :

Return the segments that are involved with this view Throw: SireMol::missing_segment

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue})

select_all()

selectAll( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> selectAll(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> selectAll(SireMol::MoleculeView {lvalue})

selectAll( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> selectAll(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> selectAll(SireMol::MoleculeView {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> selectAll(SireMol::MoleculeView {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> selectAll(SireMol::MoleculeView {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

select_all_atoms()

selectAllAtoms( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> selectAllAtoms(SireMol::MoleculeView {lvalue})

select_all_chains()

selectAllChains( (MoleculeView)arg1) -> Selector_Chain_ :

Return the chains that are involved with this view Throw: SireMol::missing_chain

C++ signature :

SireMol::Selector<SireMol::Chain> selectAllChains(SireMol::MoleculeView {lvalue})

select_all_cutgroups()

selectAllCutGroups( (MoleculeView)arg1) -> Selector_CutGroup_ :

Return all of the CutGroups that are involved in this view Throw: SireMol::missing_cutgroup

C++ signature :

SireMol::Selector<SireMol::CutGroup> selectAllCutGroups(SireMol::MoleculeView {lvalue})

select_all_residues()

selectAllResidues( (MoleculeView)arg1) -> Selector_Residue_ :

Return all of the residues that are involved with this view Throw: SireMol::missing_residue

C++ signature :

SireMol::Selector<SireMol::Residue> selectAllResidues(SireMol::MoleculeView {lvalue})

select_all_segments()

selectAllSegments( (MoleculeView)arg1) -> Selector_Segment_ :

Return the segments that are involved with this view Throw: SireMol::missing_segment

C++ signature :

SireMol::Selector<SireMol::Segment> selectAllSegments(SireMol::MoleculeView {lvalue})

selected_all()

selectedAll( (Dihedral)arg1) -> bool :

C++ signature :

bool selectedAll(SireMM::Dihedral {lvalue})

selection((Dihedral)arg1) → AtomSelection :

C++ signature :

SireMol::AtomSelection selection(SireMM::Dihedral {lvalue})

selector((Dihedral)arg1) → SelectorDihedral :

C++ signature :

SireMM::SelectorDihedral selector(SireMM::Dihedral {lvalue})

size()

measure( (Dihedral)arg1) -> object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> measure(SireMM::Dihedral {lvalue})

measure( (Dihedral)arg1, (PropertyMap)map) -> object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> measure(SireMM::Dihedral {lvalue},SireBase::PropertyMap)

to_list()

toList( (MoleculeView)arg1) -> object :

Expand this into a list of unit classes. This will return the view itself if

this is a unit class, e.g. Atom, Residue, Molecule etc. This will return a list of unit classes if this is a Selector<T> or equivalent type class.

C++ signature :

QList<SireBase::PropPtr<SireMol::MoleculeView>> toList(SireMol::MoleculeView {lvalue})

to_molecules()

toMolecules( (MoleculeView)arg1) -> Molecules :

Return a Molecules set that contains this view (or views)

C++ signature :

SireMol::Molecules toMolecules(SireMol::MoleculeView {lvalue})

to_selector()

toSelector( (Dihedral)arg1) -> object :

C++ signature :

SireBase::PropPtr<SireMol::MoleculeView> toSelector(SireMM::Dihedral {lvalue})

to_string()

toString( (Dihedral)arg1) -> object :

C++ signature :

QString toString(SireMM::Dihedral {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((Dihedral)arg1) → str :

C++ signature :

char const* what(SireMM::Dihedral {lvalue})

class sire.mm.DihedralRestraint

This class represents a single angle restraint between any three atoms in a system Author: Christopher Woods

assign((DihedralRestraint)arg1, (DihedralRestraint)other) → DihedralRestraint :

C++ signature :

SireMM::DihedralRestraint {lvalue} assign(SireMM::DihedralRestraint {lvalue},SireMM::DihedralRestraint)

atoms((DihedralRestraint)arg1) → object :

Return the atoms involved in the restraint

C++ signature :

QVector<long long> atoms(SireMM::DihedralRestraint {lvalue})

clone((DihedralRestraint)arg1) → DihedralRestraint :

C++ signature :

SireMM::DihedralRestraint clone(SireMM::DihedralRestraint)

is_null()

isNull( (DihedralRestraint)arg1) -> bool :

C++ signature :

bool isNull(SireMM::DihedralRestraint {lvalue})

kphi((DihedralRestraint)arg1) → object :

Return the force constant for the restraint

C++ signature :

SireUnits::Dimension::PhysUnit<1, 2, -2, 0, 0, -1, -2> kphi(SireMM::DihedralRestraint {lvalue})

phi0((DihedralRestraint)arg1) → object :

Return the equilibrium angle for the restraint

C++ signature :

SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> phi0(SireMM::DihedralRestraint {lvalue})

to_string()

toString( (DihedralRestraint)arg1) -> object :

C++ signature :

QString toString(SireMM::DihedralRestraint {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((DihedralRestraint)arg1) → str :

C++ signature :

char const* what(SireMM::DihedralRestraint {lvalue})

class sire.mm.DihedralRestraints

This class represents a collection of angle restraints

add((DihedralRestraints)arg1, (DihedralRestraint)restraint) → None :

Add a restraints onto the list

C++ signature :

void add(SireMM::DihedralRestraints {lvalue},SireMM::DihedralRestraint)

add( (DihedralRestraints)arg1, (DihedralRestraints)restraints) -> None :

Add a restraint onto the list

C++ signature :

void add(SireMM::DihedralRestraints {lvalue},SireMM::DihedralRestraints)

assign((DihedralRestraints)arg1, (DihedralRestraints)other) → DihedralRestraints :

C++ signature :

SireMM::DihedralRestraints {lvalue} assign(SireMM::DihedralRestraints {lvalue},SireMM::DihedralRestraints)

at((DihedralRestraints)arg1, (int)i) → DihedralRestraint :

Return the ith restraint

C++ signature :

SireMM::DihedralRestraint at(SireMM::DihedralRestraints {lvalue},int)

clone((DihedralRestraints)arg1) → DihedralRestraints :

C++ signature :

SireMM::DihedralRestraints clone(SireMM::DihedralRestraints)

count((DihedralRestraints)arg1) → int :

Return the number of restraints

C++ signature :

int count(SireMM::DihedralRestraints {lvalue})

is_empty()

isEmpty( (DihedralRestraints)arg1) -> bool :

Return whether or not this is empty

C++ signature :

bool isEmpty(SireMM::DihedralRestraints {lvalue})

is_null()

isNull( (DihedralRestraints)arg1) -> bool :

Return whether or not this is empty

C++ signature :

bool isNull(SireMM::DihedralRestraints {lvalue})

is_restraints()

isRestraints( (Restraints)arg1) -> bool :

Return whether or not this is a Restraints object (or derived from this object)

C++ signature :

bool isRestraints(SireMM::Restraints {lvalue})

num_restraints()

nRestraints( (DihedralRestraints)arg1) -> int :

Return the number of restraints

C++ signature :

int nRestraints(SireMM::DihedralRestraints {lvalue})

restraints((DihedralRestraints)arg1) → object :

Return all of the restraints

C++ signature :

QList<SireMM::DihedralRestraint> restraints(SireMM::DihedralRestraints {lvalue})

set_name()

setName( (Restraints)arg1, (object)name) -> None :

Set the name for this group of restraints

C++ signature :

void setName(SireMM::Restraints {lvalue},QString)

size((DihedralRestraints)arg1) → int :

Return the number of restraints

C++ signature :

int size(SireMM::DihedralRestraints {lvalue})

to_string()

toString( (DihedralRestraints)arg1) -> object :

C++ signature :

QString toString(SireMM::DihedralRestraints {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((DihedralRestraints)arg1) → str :

C++ signature :

char const* what(SireMM::DihedralRestraints {lvalue})

class sire.mm.Improper

This class provides a molecule view to an improper

assert_contains()

assertContains( (MoleculeView)arg1, (AtomIdx)atomidx) -> None :

Assert that this view contains the atom at index atomidx Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

void assertContains(SireMol::MoleculeView {lvalue},SireMol::AtomIdx)

assert_has_metadata()

assertHasMetadata( (MoleculeView)arg1, (PropertyName)metakey) -> None :

Assert that this contains some metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

void assertHasMetadata(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

assertHasMetadata( (MoleculeView)arg1, (PropertyName)key, (PropertyName)metakey) -> None :

Assert that this contains some metadata at metakey metakey for the property at key key Throw: SireBase::missing_property

C++ signature :

void assertHasMetadata(SireMol::MoleculeView {lvalue},SireBase::PropertyName,SireBase::PropertyName)

assert_has_property()

assertHasProperty( (MoleculeView)arg1, (PropertyName)key) -> None :

Assert that this contains a property at key key Throw: SireBase::missing_property

C++ signature :

void assertHasProperty(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

assert_same_molecule()

assertSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> None :

Assert that this is a view of the same molecule as other (albeit at a different version) Throw: SireError::incompatible_error

C++ signature :

void assertSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeView)

assertSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> None :

Assert that this view is looking at the molecule whose data is in other (albeit perhaps a different version of that molecule) Throw: SireError::incompatible_error

C++ signature :

void assertSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeData)

assign((Improper)arg1, (Improper)other) → Improper :

C++ signature :

SireMM::Improper {lvalue} assign(SireMM::Improper {lvalue},SireMM::Improper)

atom((MoleculeView)arg1, (int)i[, (PropertyMap)map={}]) → Atom :

Return the atom in this view that matches the ID atomid

Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},int [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> Atom :

Return the atom in this view that matches the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Atom :

Return the atom in this view that matches the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1) -> Atom :

Return this view as a Atom - this will only work if this view contains only a single atom Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue})

atom0((Improper)arg1) → Atom :

C++ signature :

SireMol::Atom atom0(SireMM::Improper {lvalue})

atom1((Improper)arg1) → Atom :

C++ signature :

SireMol::Atom atom1(SireMM::Improper {lvalue})

atom2((Improper)arg1) → Atom :

C++ signature :

SireMol::Atom atom2(SireMM::Improper {lvalue})

atom3((Improper)arg1) → Atom :

C++ signature :

SireMol::Atom atom3(SireMM::Improper {lvalue})

atoms((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Atom_ :

Return the atoms from this view that match the ID atomid

Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue})

chains((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Chain_ :

Return the chains that are involved with this view that match

the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1) -> Selector_Chain_ :

Return the chains that are involved with this view Throw: SireMol::missing_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue})

clone((Improper)arg1) → Improper :

C++ signature :

SireMM::Improper clone(SireMM::Improper)

const_data()

constData( (MoleculeView)arg1) -> object :

Return the MoleculeData that contains all of the information about the molecule which this view is showing

C++ signature :

SireMol::MoleculeData constData(SireMol::MoleculeView {lvalue})

count()

nAtoms( (MoleculeView)arg1) -> int :

Return the number of atoms in this view

C++ signature :

int nAtoms(SireMol::MoleculeView {lvalue})

cursor(map=None)

Return a Cursor that can be used to edit the properties of this view

cutgroup()

cutGroup( (MoleculeView)arg1, (int)i [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},int [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1) -> CutGroup :

Return the CutGroup that contains the atom(s) in this view Throw: SireMol::missing_cutgroup Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue})

cutgroups()

cutGroups( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1) -> Selector_CutGroup_ :

Return all of the CutGroups that are involved in this view Throw: SireMol::missing_cutgroup

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue})

delete_all_frames()

deleteAllFrames( (MoleculeView)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue})

deleteAllFrames( (MoleculeView)arg1, (PropertyMap)map) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

delete_frame()

deleteFrame( (MoleculeView)arg1, (int)frame) -> None :

C++ signature :

void deleteFrame(SireMol::MoleculeView {lvalue},int)

deleteFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void deleteFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

energy((Improper)arg1) → GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::Improper {lvalue})

energy( (Improper)arg1, (PropertyMap)map) -> GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::Improper {lvalue},SireBase::PropertyMap)

evaluate((Improper)arg1) → Evaluator :

C++ signature :

SireMol::Evaluator evaluate(SireMM::Improper {lvalue})

get_link()

getLink( (MoleculeView)arg1, (PropertyName)key) -> object :

Return the link for the given property name. This will throw an exception if there is no link for the given property name.

C++ signature :

QString getLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

get_links()

getLinks( (MoleculeView)arg1) -> object :

Return the property links for this molecule. This returns an empty dictionary if there are no links.

C++ signature :

QHash<QString, QString> getLinks(SireMol::MoleculeView {lvalue})

has_links()

hasLinks( (MoleculeView)arg1) -> bool :

Return whether or not this molecule has any property links

C++ signature :

bool hasLinks(SireMol::MoleculeView {lvalue})

has_metadata()

hasMetadata( (Improper)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasMetadata(SireMM::Improper {lvalue},SireBase::PropertyName)

hasMetadata( (Improper)arg1, (PropertyName)key, (PropertyName)metakey) -> bool :

C++ signature :

bool hasMetadata(SireMM::Improper {lvalue},SireBase::PropertyName,SireBase::PropertyName)

has_property()

hasProperty( (Improper)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasProperty(SireMM::Improper {lvalue},SireBase::PropertyName)

id()

ID( (Improper)arg1) -> ImproperID :

C++ signature :

SireMol::ImproperID ID(SireMM::Improper {lvalue})

invert((Improper)arg1) → SelectorImproper :

C++ signature :

SireMM::SelectorImproper invert(SireMM::Improper {lvalue})

is_empty()

isEmpty( (Improper)arg1) -> bool :

C++ signature :

bool isEmpty(SireMM::Improper {lvalue})

is_link()

isLink( (MoleculeView)arg1, (PropertyName)key) -> bool :

Return whether or not this molecule has a link for the given property name

C++ signature :

bool isLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

is_null()

isNull( (MoleculeView)arg1) -> bool :

Return whether or not this molecule view is null

C++ signature :

bool isNull(SireMol::MoleculeView {lvalue})

is_same_molecule()

isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :

Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)

C++ signature :

bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeView)

isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :

Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)

C++ signature :

bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeData)

is_selector()

isSelector( (MoleculeView)arg1) -> bool :

Return whether or not this is a Selector<T> object. This

helps code distinguish between views of single objects, e.g. Atom, Residue etc., and views of multiple objects, e.g. Selector<Atom>, Selector<Residue> etc.

C++ signature :

bool isSelector(SireMol::MoleculeView {lvalue})

load_frame()

loadFrame( (MoleculeView)arg1, (int)frame) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int)

loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator)

loadFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator,SireBase::PropertyMap)

measure((Improper)arg1) → object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> measure(SireMM::Improper {lvalue})

measure( (Improper)arg1, (PropertyMap)map) -> object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> measure(SireMM::Improper {lvalue},SireBase::PropertyMap)

metadata_keys()

metadataKeys( (Improper)arg1) -> object :

C++ signature :

QStringList metadataKeys(SireMM::Improper {lvalue})

metadataKeys( (Improper)arg1, (PropertyName)key) -> object :

C++ signature :

QStringList metadataKeys(SireMM::Improper {lvalue},SireBase::PropertyName)

metadata_type()

metadataType( (MoleculeView)arg1, (PropertyName)metakey) -> str :

Return the type of the metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

char const* metadataType(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

metadataType( (MoleculeView)arg1, (PropertyName)key, (PropertyName)metakey) -> str :

Return the type of the metadata at metakey metakey for the property at key key Throw: SireBase::missing_property

C++ signature :

char const* metadataType(SireMol::MoleculeView {lvalue},SireBase::PropertyName,SireBase::PropertyName)

molecules(idx=None, auto_reduce=False, error_on_missing: bool = False, map=None)

Return the molecule that contains this view as a list of molecules, containing just a single molecule.

If ‘id’ is specified then this checks that this molecule matches the ID before returning it. This will raise an exception if the ID doesn’t match.

Returns:

sire.mol.SelectorMol – that contains this view.

Return type:

A collection containing only a single molecule

move((Improper)arg1) → Mover_Improper_ :

C++ signature :

SireMol::Mover<SireMM::Improper> move(SireMM::Improper {lvalue})

num_atoms()

nAtoms( (MoleculeView)arg1) -> int :

Return the number of atoms in this view

C++ signature :

int nAtoms(SireMol::MoleculeView {lvalue})

num_chains()

nChains( (MoleculeView)arg1) -> int :

Return the number of chains in this view

C++ signature :

int nChains(SireMol::MoleculeView {lvalue})

num_cutgroups()

nCutGroups( (MoleculeView)arg1) -> int :

Return the number of CutGroups in this view

C++ signature :

int nCutGroups(SireMol::MoleculeView {lvalue})

num_frames()

nFrames( (MoleculeView)arg1) -> int :

C++ signature :

int nFrames(SireMol::MoleculeView {lvalue})

nFrames( (MoleculeView)arg1, (PropertyMap)map) -> int :

C++ signature :

int nFrames(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

num_residues()

nResidues( (MoleculeView)arg1) -> int :

Return the number of residues in this view

C++ signature :

int nResidues(SireMol::MoleculeView {lvalue})

num_segments()

nSegments( (MoleculeView)arg1) -> int :

Return the number of segments in this view

C++ signature :

int nSegments(SireMol::MoleculeView {lvalue})

num_views()

nViews( (MoleculeView)arg1) -> int :

Return the number of sub-views in this view. Most MoleculeViews are just a single view, but some (e.g. ViewsOfMol or Selector<T>) have multiple views

C++ signature :

int nViews(SireMol::MoleculeView {lvalue})

phi((Improper)arg1) → object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> phi(SireMM::Improper {lvalue})

phi( (Improper)arg1, (PropertyMap)map) -> object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> phi(SireMM::Improper {lvalue},SireBase::PropertyMap)

potential((Improper)arg1) → Expression :

C++ signature :

SireCAS::Expression potential(SireMM::Improper {lvalue})

potential( (Improper)arg1, (PropertyMap)map) -> Expression :

C++ signature :

SireCAS::Expression potential(SireMM::Improper {lvalue},SireBase::PropertyMap)

properties((Improper)arg1) → Properties :

C++ signature :

SireBase::Properties properties(SireMM::Improper {lvalue})

property_keys()

propertyKeys( (Improper)arg1) -> object :

C++ signature :

QStringList propertyKeys(SireMM::Improper {lvalue})

property_type()

propertyType( (MoleculeView)arg1, (PropertyName)key) -> str :

Return the type of the property at key key Throw: SireBase::missing_property

C++ signature :

char const* propertyType(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

residues((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Residue_ :

Return the residues from this view that match the ID resid

Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1) -> Selector_Residue_ :

Return all of the residues that are involved with this view Throw: SireMol::missing_residue

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue})

save_frame()

saveFrame( (MoleculeView)arg1 [, (int)frame]) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue} [,int])

saveFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

saveFrame( (MoleculeView)arg1, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

segments((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Segment_ :

Return the segments that are involved with this view that match

the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1) -> Selector_Segment_ :

Return the segments that are involved with this view Throw: SireMol::missing_segment

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue})

select_all()

selectAll( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> selectAll(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> selectAll(SireMol::MoleculeView {lvalue})

selectAll( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> selectAll(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> selectAll(SireMol::MoleculeView {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> selectAll(SireMol::MoleculeView {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> selectAll(SireMol::MoleculeView {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

select_all_atoms()

selectAllAtoms( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> selectAllAtoms(SireMol::MoleculeView {lvalue})

select_all_chains()

selectAllChains( (MoleculeView)arg1) -> Selector_Chain_ :

Return the chains that are involved with this view Throw: SireMol::missing_chain

C++ signature :

SireMol::Selector<SireMol::Chain> selectAllChains(SireMol::MoleculeView {lvalue})

select_all_cutgroups()

selectAllCutGroups( (MoleculeView)arg1) -> Selector_CutGroup_ :

Return all of the CutGroups that are involved in this view Throw: SireMol::missing_cutgroup

C++ signature :

SireMol::Selector<SireMol::CutGroup> selectAllCutGroups(SireMol::MoleculeView {lvalue})

select_all_residues()

selectAllResidues( (MoleculeView)arg1) -> Selector_Residue_ :

Return all of the residues that are involved with this view Throw: SireMol::missing_residue

C++ signature :

SireMol::Selector<SireMol::Residue> selectAllResidues(SireMol::MoleculeView {lvalue})

select_all_segments()

selectAllSegments( (MoleculeView)arg1) -> Selector_Segment_ :

Return the segments that are involved with this view Throw: SireMol::missing_segment

C++ signature :

SireMol::Selector<SireMol::Segment> selectAllSegments(SireMol::MoleculeView {lvalue})

selected_all()

selectedAll( (Improper)arg1) -> bool :

C++ signature :

bool selectedAll(SireMM::Improper {lvalue})

selection((Improper)arg1) → AtomSelection :

C++ signature :

SireMol::AtomSelection selection(SireMM::Improper {lvalue})

selector((Improper)arg1) → SelectorImproper :

C++ signature :

SireMM::SelectorImproper selector(SireMM::Improper {lvalue})

size()

measure( (Improper)arg1) -> object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> measure(SireMM::Improper {lvalue})

measure( (Improper)arg1, (PropertyMap)map) -> object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> measure(SireMM::Improper {lvalue},SireBase::PropertyMap)

theta((Improper)arg1) → object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> theta(SireMM::Improper {lvalue})

theta( (Improper)arg1, (PropertyMap)map) -> object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> theta(SireMM::Improper {lvalue},SireBase::PropertyMap)

to_list()

toList( (MoleculeView)arg1) -> object :

Expand this into a list of unit classes. This will return the view itself if

this is a unit class, e.g. Atom, Residue, Molecule etc. This will return a list of unit classes if this is a Selector<T> or equivalent type class.

C++ signature :

QList<SireBase::PropPtr<SireMol::MoleculeView>> toList(SireMol::MoleculeView {lvalue})

to_molecules()

toMolecules( (MoleculeView)arg1) -> Molecules :

Return a Molecules set that contains this view (or views)

C++ signature :

SireMol::Molecules toMolecules(SireMol::MoleculeView {lvalue})

to_selector()

toSelector( (Improper)arg1) -> object :

C++ signature :

SireBase::PropPtr<SireMol::MoleculeView> toSelector(SireMM::Improper {lvalue})

to_string()

toString( (Improper)arg1) -> object :

C++ signature :

QString toString(SireMM::Improper {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((Improper)arg1) → str :

C++ signature :

char const* what(SireMM::Improper {lvalue})

class sire.mm.LJ1264Parameter

This class holds a LJ 12-6-4 parameter. These are used between some atom-pairs to define a 12-6-4 potential with functional form

E_LJ = A r^12 - B r^6 - C r^4

a()

A( (LJ1264Parameter)arg1) -> float :

C++ signature :

double A(SireMM::LJ1264Parameter {lvalue})

assert_is_lj_parameter()

assertIsLJParameter( (LJ1264Parameter)arg1) -> None :

Assert that this is a standard 12-6 LJ parameter (C is 0)

C++ signature :

void assertIsLJParameter(SireMM::LJ1264Parameter {lvalue})

assign((LJ1264Parameter)arg1, (LJ1264Parameter)other) → LJ1264Parameter :

C++ signature :

SireMM::LJ1264Parameter {lvalue} assign(SireMM::LJ1264Parameter {lvalue},SireMM::LJ1264Parameter)

b()

B( (LJ1264Parameter)arg1) -> float :

C++ signature :

double B(SireMM::LJ1264Parameter {lvalue})

b_unit()

BUnit() -> GeneralUnit :

Return the correct physical units for the B parameter

C++ signature :

SireUnits::Dimension::GeneralUnit BUnit()

c()

C( (LJ1264Parameter)arg1) -> float :

C++ signature :

double C(SireMM::LJ1264Parameter {lvalue})

c_unit()

CUnit() -> GeneralUnit :

Return the correct physical units for the C parameter

C++ signature :

SireUnits::Dimension::GeneralUnit CUnit()

clone((LJ1264Parameter)arg1) → LJ1264Parameter :

C++ signature :

SireMM::LJ1264Parameter clone(SireMM::LJ1264Parameter)

static dummy() → LJ1264Parameter :

Return a dummy LJ1264Parameter

C++ signature :

SireMM::LJ1264Parameter dummy()

has_c()

hasC( (LJ1264Parameter)arg1) -> bool :

Return whether or not this has a C parameter. If so,

then it is a 12-6-4 parameter. If not, then it is a standard 12-6 parameter.

C++ signature :

bool hasC(SireMM::LJ1264Parameter {lvalue})

is_dummy()

isDummy( (LJ1264Parameter)arg1) -> bool :

C++ signature :

bool isDummy(SireMM::LJ1264Parameter {lvalue})

is_lj_parameter()

isLJParameter( (LJ1264Parameter)arg1) -> bool :

Return whether or not this is a standard 12-6 LJ parameter

C++ signature :

bool isLJParameter(SireMM::LJ1264Parameter {lvalue})

to_lj_pair()

toLJPair( (LJ1264Parameter)arg1) -> object :

Return this converted to a standard 12-6 LJ parameter

C++ signature :

SireMM::LJPair toLJPair(SireMM::LJ1264Parameter {lvalue})

to_lj_parameter()

toLJParameter( (LJ1264Parameter)arg1) -> LJParameter :

Return this converted to a standard 12-6 LJ parameter

C++ signature :

SireMM::LJParameter toLJParameter(SireMM::LJ1264Parameter {lvalue})

to_string()

toString( (LJ1264Parameter)arg1) -> object :

Return a string representation of the LJ parameter

C++ signature :

QString toString(SireMM::LJ1264Parameter {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

unit()

AUnit() -> GeneralUnit :

Return the correct physical units for the A parameter

C++ signature :

SireUnits::Dimension::GeneralUnit AUnit()

what((LJ1264Parameter)arg1) → str :

C++ signature :

char const* what(SireMM::LJ1264Parameter {lvalue})

zero_lj()

zeroLJ( (LJ1264Parameter)arg1) -> bool :

C++ signature :

bool zeroLJ(SireMM::LJ1264Parameter {lvalue})

class sire.mm.LJParameter

An LJParameter holds Lennard Jones parameters (sigma and epsilon)

Author: Christopher Woods

a()

A( (LJParameter)arg1) -> float :

Return the LJ A parameter

C++ signature :

double A(SireMM::LJParameter {lvalue})

b()

B( (LJParameter)arg1) -> float :

Return the LJ B parameter

C++ signature :

double B(SireMM::LJParameter {lvalue})

clone((LJParameter)arg1) → LJParameter :

C++ signature :

SireMM::LJParameter clone(SireMM::LJParameter)

combine((LJParameter)arg1, (LJParameter)other, (CombiningRules)rules) → LJParameter :

Return the LJParameter that is this parameter combined with other according to the passed combining rules

C++ signature :

SireMM::LJParameter combine(SireMM::LJParameter {lvalue},SireMM::LJParameter,SireMM::LJParameter::CombiningRules)

combine_arithmetic()

combineArithmetic( (LJParameter)arg1, (LJParameter)other) -> LJParameter :

Return the LJParameter that is this parameter combined with other using arithmetic combining rules

C++ signature :

SireMM::LJParameter combineArithmetic(SireMM::LJParameter {lvalue},SireMM::LJParameter)

combine_geometric()

combineGeometric( (LJParameter)arg1, (LJParameter)other) -> LJParameter :

Return the LJParameter that is this parameter combined with other using geometric combining rules

C++ signature :

SireMM::LJParameter combineGeometric(SireMM::LJParameter {lvalue},SireMM::LJParameter)

combining_rules

alias of CombiningRules

static dummy() → LJParameter :

Return a dummy CLJParameter

C++ signature :

SireMM::LJParameter dummy()

epsilon((LJParameter)arg1) → object :

C++ signature :

SireUnits::Dimension::PhysUnit<1, 2, -2, 0, 0, -1, 0> epsilon(SireMM::LJParameter {lvalue})

from_and_b()

fromAAndB( (float)a, (float)b) -> LJParameter :

Return a LJ parameter that corresponds to the passed LJ parameters A and B, E(r) = A r-12 - B r-6

C++ signature :

SireMM::LJParameter fromAAndB(double,double)

from_r_min_and_epsilon()

fromRMinAndEpsilon( (object)rmin, (object)epsilon) -> LJParameter :

Return a LJ parameter that corresponds to the curve that has a minimum at rmin, and a well-depth of epsilon. E(r) = 4 epilson [ (sigmar)^12 - (sigmar)^6 ], where rmin = 2^(16) sigma

C++ signature :

SireMM::LJParameter fromRMinAndEpsilon(SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0>,SireUnits::Dimension::PhysUnit<1, 2, -2, 0, 0, -1, 0>)

from_sigma_and_epsilon()

fromSigmaAndEpsilon( (object)sigma, (object)epsilon) -> LJParameter :

Return a LJ parameter that corresponds to the passed values of sigma and epsilon, E(r) = 4 epsilon [ (sigmar)^12 - (sigmar)^6 ]

C++ signature :

SireMM::LJParameter fromSigmaAndEpsilon(SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0>,SireUnits::Dimension::PhysUnit<1, 2, -2, 0, 0, -1, 0>)

is_dummy()

isDummy( (LJParameter)arg1) -> bool :

C++ signature :

bool isDummy(SireMM::LJParameter {lvalue})

rmin((LJParameter)arg1) → object :

Return the LJ rmin parameter - this is the location of the minimum. rmin = 2^(16) sigma

C++ signature :

SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0> rmin(SireMM::LJParameter {lvalue})

sigma((LJParameter)arg1) → object :

C++ signature :

SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0> sigma(SireMM::LJParameter {lvalue})

sqrt_epsilon()

sqrtEpsilon( (LJParameter)arg1) -> float :

C++ signature :

double sqrtEpsilon(SireMM::LJParameter {lvalue})

sqrt_sigma()

sqrtSigma( (LJParameter)arg1) -> float :

C++ signature :

double sqrtSigma(SireMM::LJParameter {lvalue})

to_string()

toString( (LJParameter)arg1) -> object :

Return a string representation of the CLJ parameter

C++ signature :

QString toString(SireMM::LJParameter {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((LJParameter)arg1) → str :

C++ signature :

char const* what(SireMM::LJParameter {lvalue})

zero_lj()

zeroLJ( (LJParameter)arg1) -> bool :

C++ signature :

bool zeroLJ(SireMM::LJParameter {lvalue})

class sire.mm.SelectorAngle

This provides a Selector<T>-style interface for multiple angles

add((SelectorAngle)arg1, (Angle)Angle) → SelectorAngle :

C++ signature :

SireMM::SelectorAngle add(SireMM::SelectorAngle {lvalue},SireMM::Angle)

add( (SelectorAngle)arg1, (SelectorAngle)other) -> SelectorAngle :

C++ signature :

SireMM::SelectorAngle add(SireMM::SelectorAngle {lvalue},SireMM::SelectorAngle)

assert_contains()

assertContains( (MoleculeView)arg1, (AtomIdx)atomidx) -> None :

Assert that this view contains the atom at index atomidx Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

void assertContains(SireMol::MoleculeView {lvalue},SireMol::AtomIdx)

assert_has_metadata()

assertHasMetadata( (MoleculeView)arg1, (PropertyName)metakey) -> None :

Assert that this contains some metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

void assertHasMetadata(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

assertHasMetadata( (MoleculeView)arg1, (PropertyName)key, (PropertyName)metakey) -> None :

Assert that this contains some metadata at metakey metakey for the property at key key Throw: SireBase::missing_property

C++ signature :

void assertHasMetadata(SireMol::MoleculeView {lvalue},SireBase::PropertyName,SireBase::PropertyName)

assert_has_property()

assertHasProperty( (MoleculeView)arg1, (PropertyName)key) -> None :

Assert that this contains a property at key key Throw: SireBase::missing_property

C++ signature :

void assertHasProperty(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

assert_same_molecule()

assertSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> None :

Assert that this is a view of the same molecule as other (albeit at a different version) Throw: SireError::incompatible_error

C++ signature :

void assertSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeView)

assertSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> None :

Assert that this view is looking at the molecule whose data is in other (albeit perhaps a different version of that molecule) Throw: SireError::incompatible_error

C++ signature :

void assertSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeData)

assign((SelectorAngle)arg1, (SelectorAngle)angle) → SelectorAngle :

C++ signature :

SireMM::SelectorAngle {lvalue} assign(SireMM::SelectorAngle {lvalue},SireMM::SelectorAngle)

atom((MoleculeView)arg1, (int)i[, (PropertyMap)map={}]) → Atom :

Return the atom in this view that matches the ID atomid

Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},int [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> Atom :

Return the atom in this view that matches the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Atom :

Return the atom in this view that matches the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1) -> Atom :

Return this view as a Atom - this will only work if this view contains only a single atom Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue})

atoms((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Atom_ :

Return the atoms from this view that match the ID atomid

Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue})

chains((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Chain_ :

Return the chains that are involved with this view that match

the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1) -> Selector_Chain_ :

Return the chains that are involved with this view Throw: SireMol::missing_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue})

clone((SelectorAngle)arg1) → SelectorAngle :

C++ signature :

SireMM::SelectorAngle clone(SireMM::SelectorAngle)

const_data()

constData( (MoleculeView)arg1) -> object :

Return the MoleculeData that contains all of the information about the molecule which this view is showing

C++ signature :

SireMol::MoleculeData constData(SireMol::MoleculeView {lvalue})

count()

__len__( (SelectorAngle)arg1) -> int :

C++ signature :

unsigned long __len__(SireMM::SelectorAngle {lvalue})

cursor(map=None)

Return the Cursors object that contains cursors for all of the views in this collection. Note that the parent cursor of this list will be the molecule

cutgroup()

cutGroup( (MoleculeView)arg1, (int)i [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},int [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1) -> CutGroup :

Return the CutGroup that contains the atom(s) in this view Throw: SireMol::missing_cutgroup Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue})

cutgroups()

cutGroups( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1) -> Selector_CutGroup_ :

Return all of the CutGroups that are involved in this view Throw: SireMol::missing_cutgroup

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue})

delete_all_frames()

deleteAllFrames( (MoleculeView)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue})

deleteAllFrames( (MoleculeView)arg1, (PropertyMap)map) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

delete_frame()

deleteFrame( (MoleculeView)arg1, (int)frame) -> None :

C++ signature :

void deleteFrame(SireMol::MoleculeView {lvalue},int)

deleteFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void deleteFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

energies((SelectorAngle)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::GeneralUnit> energies(SireMM::SelectorAngle {lvalue})

energies( (SelectorAngle)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::GeneralUnit> energies(SireMM::SelectorAngle {lvalue},SireBase::PropertyMap)

energy((SelectorAngle)arg1) → GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::SelectorAngle {lvalue})

energy( (SelectorAngle)arg1, (PropertyMap)map) -> GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::SelectorAngle {lvalue},SireBase::PropertyMap)

evaluate((SelectorAngle)arg1) → Evaluator :

C++ signature :

SireMol::Evaluator evaluate(SireMM::SelectorAngle {lvalue})

get_link()

getLink( (MoleculeView)arg1, (PropertyName)key) -> object :

Return the link for the given property name. This will throw an exception if there is no link for the given property name.

C++ signature :

QString getLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

get_links()

getLinks( (MoleculeView)arg1) -> object :

Return the property links for this molecule. This returns an empty dictionary if there are no links.

C++ signature :

QHash<QString, QString> getLinks(SireMol::MoleculeView {lvalue})

has_links()

hasLinks( (MoleculeView)arg1) -> bool :

Return whether or not this molecule has any property links

C++ signature :

bool hasLinks(SireMol::MoleculeView {lvalue})

has_metadata()

hasMetadata( (SelectorAngle)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasMetadata(SireMM::SelectorAngle {lvalue},SireBase::PropertyName)

hasMetadata( (SelectorAngle)arg1, (PropertyName)key, (PropertyName)metakey) -> bool :

C++ signature :

bool hasMetadata(SireMM::SelectorAngle {lvalue},SireBase::PropertyName,SireBase::PropertyName)

has_property()

hasProperty( (SelectorAngle)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasProperty(SireMM::SelectorAngle {lvalue},SireBase::PropertyName)

ids()

IDs( (SelectorAngle)arg1) -> object :

C++ signature :

QList<SireMol::AngleID> IDs(SireMM::SelectorAngle {lvalue})

intersection((SelectorAngle)arg1, (SelectorAngle)other) → SelectorAngle :

C++ signature :

SireMM::SelectorAngle intersection(SireMM::SelectorAngle {lvalue},SireMM::SelectorAngle)

invert((SelectorAngle)arg1[, (PropertyMap)map]) → SelectorAngle :

C++ signature :

SireMM::SelectorAngle invert(SireMM::SelectorAngle {lvalue} [,SireBase::PropertyMap])

is_empty()

isEmpty( (SelectorAngle)arg1) -> bool :

C++ signature :

bool isEmpty(SireMM::SelectorAngle {lvalue})

is_link()

isLink( (MoleculeView)arg1, (PropertyName)key) -> bool :

Return whether or not this molecule has a link for the given property name

C++ signature :

bool isLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

is_null()

isNull( (MoleculeView)arg1) -> bool :

Return whether or not this molecule view is null

C++ signature :

bool isNull(SireMol::MoleculeView {lvalue})

is_same_molecule()

isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :

Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)

C++ signature :

bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeView)

isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :

Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)

C++ signature :

bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeData)

is_selector()

isSelector( (SelectorAngle)arg1) -> bool :

C++ signature :

bool isSelector(SireMM::SelectorAngle {lvalue})

load_frame()

loadFrame( (MoleculeView)arg1, (int)frame) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int)

loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator)

loadFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator,SireBase::PropertyMap)

measures((SelectorAngle)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> measures(SireMM::SelectorAngle {lvalue})

measures( (SelectorAngle)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> measures(SireMM::SelectorAngle {lvalue},SireBase::PropertyMap)

metadata_keys()

metadataKeys( (SelectorAngle)arg1) -> object :

C++ signature :

QStringList metadataKeys(SireMM::SelectorAngle {lvalue})

metadataKeys( (SelectorAngle)arg1, (PropertyName)key) -> object :

C++ signature :

QStringList metadataKeys(SireMM::SelectorAngle {lvalue},SireBase::PropertyName)

metadata_type()

metadataType( (MoleculeView)arg1, (PropertyName)metakey) -> str :

Return the type of the metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

char const* metadataType(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

metadataType( (MoleculeView)arg1, (PropertyName)key, (PropertyName)metakey) -> str :

Return the type of the metadata at metakey metakey for the property at key key Throw: SireBase::missing_property

C++ signature :

char const* metadataType(SireMol::MoleculeView {lvalue},SireBase::PropertyName,SireBase::PropertyName)

molecules(idx=None, auto_reduce=False, error_on_missing: bool = False, map=None)

Return the molecule that contains this view as a list of molecules, containing just a single molecule.

If ‘id’ is specified then this checks that this molecule matches the ID before returning it. This will raise an exception if the ID doesn’t match.

Returns:

sire.mol.SelectorMol – that contains this view.

Return type:

A collection containing only a single molecule

move((SelectorAngle)arg1) → Mover_SelectorAngle_ :

C++ signature :

SireMol::Mover<SireMM::SelectorAngle> move(SireMM::SelectorAngle {lvalue})

num_atoms()

nAtoms( (MoleculeView)arg1) -> int :

Return the number of atoms in this view

C++ signature :

int nAtoms(SireMol::MoleculeView {lvalue})

num_chains()

nChains( (MoleculeView)arg1) -> int :

Return the number of chains in this view

C++ signature :

int nChains(SireMol::MoleculeView {lvalue})

num_cutgroups()

nCutGroups( (MoleculeView)arg1) -> int :

Return the number of CutGroups in this view

C++ signature :

int nCutGroups(SireMol::MoleculeView {lvalue})

num_frames()

nFrames( (MoleculeView)arg1) -> int :

C++ signature :

int nFrames(SireMol::MoleculeView {lvalue})

nFrames( (MoleculeView)arg1, (PropertyMap)map) -> int :

C++ signature :

int nFrames(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

num_residues()

nResidues( (MoleculeView)arg1) -> int :

Return the number of residues in this view

C++ signature :

int nResidues(SireMol::MoleculeView {lvalue})

num_segments()

nSegments( (MoleculeView)arg1) -> int :

Return the number of segments in this view

C++ signature :

int nSegments(SireMol::MoleculeView {lvalue})

num_views()

nViews( (SelectorAngle)arg1) -> int :

C++ signature :

int nViews(SireMM::SelectorAngle {lvalue})

potentials((SelectorAngle)arg1) → object :

C++ signature :

QList<SireCAS::Expression> potentials(SireMM::SelectorAngle {lvalue})

potentials( (SelectorAngle)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireCAS::Expression> potentials(SireMM::SelectorAngle {lvalue},SireBase::PropertyMap)

properties((SelectorAngle)arg1) → object :

C++ signature :

QList<SireBase::Properties> properties(SireMM::SelectorAngle {lvalue})

property_keys()

propertyKeys( (SelectorAngle)arg1) -> object :

C++ signature :

QStringList propertyKeys(SireMM::SelectorAngle {lvalue})

property_type()

propertyType( (MoleculeView)arg1, (PropertyName)key) -> str :

Return the type of the property at key key Throw: SireBase::missing_property

C++ signature :

char const* propertyType(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

residues((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Residue_ :

Return the residues from this view that match the ID resid

Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1) -> Selector_Residue_ :

Return all of the residues that are involved with this view Throw: SireMol::missing_residue

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue})

save_frame()

saveFrame( (MoleculeView)arg1 [, (int)frame]) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue} [,int])

saveFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

saveFrame( (MoleculeView)arg1, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

segments((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Segment_ :

Return the segments that are involved with this view that match

the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1) -> Selector_Segment_ :

Return the segments that are involved with this view Throw: SireMol::missing_segment

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue})

select_all()

selectAll( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> selectAll(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> selectAll(SireMol::MoleculeView {lvalue})

selectAll( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> selectAll(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> selectAll(SireMol::MoleculeView {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> selectAll(SireMol::MoleculeView {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> selectAll(SireMol::MoleculeView {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

select_all_atoms()

selectAllAtoms( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> selectAllAtoms(SireMol::MoleculeView {lvalue})

select_all_chains()

selectAllChains( (MoleculeView)arg1) -> Selector_Chain_ :

Return the chains that are involved with this view Throw: SireMol::missing_chain

C++ signature :

SireMol::Selector<SireMol::Chain> selectAllChains(SireMol::MoleculeView {lvalue})

select_all_cutgroups()

selectAllCutGroups( (MoleculeView)arg1) -> Selector_CutGroup_ :

Return all of the CutGroups that are involved in this view Throw: SireMol::missing_cutgroup

C++ signature :

SireMol::Selector<SireMol::CutGroup> selectAllCutGroups(SireMol::MoleculeView {lvalue})

select_all_residues()

selectAllResidues( (MoleculeView)arg1) -> Selector_Residue_ :

Return all of the residues that are involved with this view Throw: SireMol::missing_residue

C++ signature :

SireMol::Selector<SireMol::Residue> selectAllResidues(SireMol::MoleculeView {lvalue})

select_all_segments()

selectAllSegments( (MoleculeView)arg1) -> Selector_Segment_ :

Return the segments that are involved with this view Throw: SireMol::missing_segment

C++ signature :

SireMol::Selector<SireMol::Segment> selectAllSegments(SireMol::MoleculeView {lvalue})

selected_all()

selectedAll( (SelectorAngle)arg1) -> bool :

C++ signature :

bool selectedAll(SireMM::SelectorAngle {lvalue})

selection((SelectorAngle)arg1) → AtomSelection :

C++ signature :

SireMol::AtomSelection selection(SireMM::SelectorAngle {lvalue})

size()

__len__( (SelectorAngle)arg1) -> int :

C++ signature :

unsigned long __len__(SireMM::SelectorAngle {lvalue})

sizes((SelectorAngle)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> sizes(SireMM::SelectorAngle {lvalue})

sizes( (SelectorAngle)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> sizes(SireMM::SelectorAngle {lvalue},SireBase::PropertyMap)

to_list()

toList( (SelectorAngle)arg1) -> object :

C++ signature :

QList<SireBase::PropPtr<SireMol::MoleculeView>> toList(SireMM::SelectorAngle {lvalue})

to_molecules()

toMolecules( (MoleculeView)arg1) -> Molecules :

Return a Molecules set that contains this view (or views)

C++ signature :

SireMol::Molecules toMolecules(SireMol::MoleculeView {lvalue})

to_selector()

toSelector( (SelectorAngle)arg1) -> object :

C++ signature :

SireBase::PropPtr<SireMol::MoleculeView> toSelector(SireMM::SelectorAngle {lvalue})

to_string()

toString( (SelectorAngle)arg1) -> object :

C++ signature :

QString toString(SireMM::SelectorAngle {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

view(default: bool = True, no_default: bool = False, orthographic: bool = True, protein: str = '', water: str = '', ions: str = '', rest: str = '', all: str = '', ball_and_stick: str = '', base: str = '', cartoon: str = '', hyperball: str = '', licorice: str = '', line: str = '', point: str = '', ribbon: str = '', rocket: str = '', rope: str = '', spacefill: str = '', surface: str = '', trace: str = '', tube: str = '', center: str = None, align: str = None, frame: int = None, smooth=False, wrap=True, mapping=None, bgcolor=None, stage_parameters: str = None, map=None)

Return an NGLView viewer for this view. The returned viewer can be passed directly to, e.g. a Jupyter notebook to directly view the molecule(s), or it can be captured in a variable so that it’s NGLViewer member functions can be called to edit the viewer before display.

Full instructions on how to use this view are in the cheatsheet (https://sire.openbiosim.org/cheatsheet/view)

center:

Pass in a selection string to select the atoms to center in the view. By default no atoms are centered

align:

Pass in a selection string to select atoms against which every frame will be aligned. These atoms will be moved to the center of the periodic box (if a periodic box is used). If “True” is passed, then this will attempt to align ALL of the coordinates in the view.

You can also choose to pass in a molecular container, and it will align against the atoms in that container, assuming they are contained in this view. If not, then you need to supply a mapping that maps from the atoms in the align container, to the atoms in this view.

frame:

The frame of the trajectory against which the alignment should be based. For example, frame=3 would align based on the coordinates of the aligned atoms in frame 3 of the trajectory. If this is None (the default) then the first frame will be used.

mapping: AtomMapping

An AtomMapping object that maps from atoms in the alignment container to atoms in this view. You only need to supply this if all of the alignment atoms are not contained in this view.

smooth:

Pass in the number of frames to smooth (average) the view over. If ‘True’ is passed, then the recommended number of frames will be averaged over

wrap: bool

Whether or not to wrap the coordinates into the periodic box.

orthographic:

Set to False to use a perspective view, or accept the default (True) for an orthographic view

default:

The default representation / color for the view. If this is set to False or None or “none” then default views are disabled.

no_default:

Set to False to disable all default views

protein, water, ions:

Set the default views for protein, water and ion molecules. Set to False, None or “none” to disable these default views.

rest:

Synonym for “default”, but does not disable all default views if set to None, False or “none”

all:

Set the representation for all atoms. Set to None, False or “none” to disable all views.

ball_and_stick, base, cartoon etc.

Set the selection strings for atoms that should be represented with these views.

bgcolor: str

The background color of the view. Set to ‘None’ to use the default background color (black)

stage_parameters: dict

An optional dictionary that will be passed directly to the NGLView object to set the stage parameters.

map: dict or sire.base.PropertyMap

An optional property map that can be used to control which properties are used to get the molecular data to be viewed.

what((SelectorAngle)arg1) → str :

C++ signature :

char const* what(SireMM::SelectorAngle {lvalue})

class sire.mm.SelectorBond

This provides a Selector<T>-style interface for multiple bonds

add((SelectorBond)arg1, (Bond)bond) → SelectorBond :

C++ signature :

SireMM::SelectorBond add(SireMM::SelectorBond {lvalue},SireMM::Bond)

add( (SelectorBond)arg1, (SelectorBond)other) -> SelectorBond :

C++ signature :

SireMM::SelectorBond add(SireMM::SelectorBond {lvalue},SireMM::SelectorBond)

assert_contains()

assertContains( (MoleculeView)arg1, (AtomIdx)atomidx) -> None :

Assert that this view contains the atom at index atomidx Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

void assertContains(SireMol::MoleculeView {lvalue},SireMol::AtomIdx)

assert_has_metadata()

assertHasMetadata( (MoleculeView)arg1, (PropertyName)metakey) -> None :

Assert that this contains some metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

void assertHasMetadata(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

assertHasMetadata( (MoleculeView)arg1, (PropertyName)key, (PropertyName)metakey) -> None :

Assert that this contains some metadata at metakey metakey for the property at key key Throw: SireBase::missing_property

C++ signature :

void assertHasMetadata(SireMol::MoleculeView {lvalue},SireBase::PropertyName,SireBase::PropertyName)

assert_has_property()

assertHasProperty( (MoleculeView)arg1, (PropertyName)key) -> None :

Assert that this contains a property at key key Throw: SireBase::missing_property

C++ signature :

void assertHasProperty(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

assert_same_molecule()

assertSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> None :

Assert that this is a view of the same molecule as other (albeit at a different version) Throw: SireError::incompatible_error

C++ signature :

void assertSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeView)

assertSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> None :

Assert that this view is looking at the molecule whose data is in other (albeit perhaps a different version of that molecule) Throw: SireError::incompatible_error

C++ signature :

void assertSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeData)

assign((SelectorBond)arg1, (SelectorBond)bond) → SelectorBond :

C++ signature :

SireMM::SelectorBond {lvalue} assign(SireMM::SelectorBond {lvalue},SireMM::SelectorBond)

atom((MoleculeView)arg1, (int)i[, (PropertyMap)map={}]) → Atom :

Return the atom in this view that matches the ID atomid

Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},int [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> Atom :

Return the atom in this view that matches the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Atom :

Return the atom in this view that matches the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1) -> Atom :

Return this view as a Atom - this will only work if this view contains only a single atom Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue})

atoms((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Atom_ :

Return the atoms from this view that match the ID atomid

Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue})

chains((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Chain_ :

Return the chains that are involved with this view that match

the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1) -> Selector_Chain_ :

Return the chains that are involved with this view Throw: SireMol::missing_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue})

clone((SelectorBond)arg1) → SelectorBond :

C++ signature :

SireMM::SelectorBond clone(SireMM::SelectorBond)

const_data()

constData( (MoleculeView)arg1) -> object :

Return the MoleculeData that contains all of the information about the molecule which this view is showing

C++ signature :

SireMol::MoleculeData constData(SireMol::MoleculeView {lvalue})

count()

__len__( (SelectorBond)arg1) -> int :

C++ signature :

unsigned long __len__(SireMM::SelectorBond {lvalue})

cursor(map=None)

Return the Cursors object that contains cursors for all of the views in this collection. Note that the parent cursor of this list will be the molecule

cutgroup()

cutGroup( (MoleculeView)arg1, (int)i [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},int [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1) -> CutGroup :

Return the CutGroup that contains the atom(s) in this view Throw: SireMol::missing_cutgroup Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue})

cutgroups()

cutGroups( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1) -> Selector_CutGroup_ :

Return all of the CutGroups that are involved in this view Throw: SireMol::missing_cutgroup

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue})

delete_all_frames()

deleteAllFrames( (MoleculeView)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue})

deleteAllFrames( (MoleculeView)arg1, (PropertyMap)map) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

delete_frame()

deleteFrame( (MoleculeView)arg1, (int)frame) -> None :

C++ signature :

void deleteFrame(SireMol::MoleculeView {lvalue},int)

deleteFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void deleteFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

energies((SelectorBond)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::GeneralUnit> energies(SireMM::SelectorBond {lvalue})

energies( (SelectorBond)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::GeneralUnit> energies(SireMM::SelectorBond {lvalue},SireBase::PropertyMap)

energy((SelectorBond)arg1) → GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::SelectorBond {lvalue})

energy( (SelectorBond)arg1, (PropertyMap)map) -> GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::SelectorBond {lvalue},SireBase::PropertyMap)

evaluate((SelectorBond)arg1) → Evaluator :

C++ signature :

SireMol::Evaluator evaluate(SireMM::SelectorBond {lvalue})

get_link()

getLink( (MoleculeView)arg1, (PropertyName)key) -> object :

Return the link for the given property name. This will throw an exception if there is no link for the given property name.

C++ signature :

QString getLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

get_links()

getLinks( (MoleculeView)arg1) -> object :

Return the property links for this molecule. This returns an empty dictionary if there are no links.

C++ signature :

QHash<QString, QString> getLinks(SireMol::MoleculeView {lvalue})

has_links()

hasLinks( (MoleculeView)arg1) -> bool :

Return whether or not this molecule has any property links

C++ signature :

bool hasLinks(SireMol::MoleculeView {lvalue})

has_metadata()

hasMetadata( (SelectorBond)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasMetadata(SireMM::SelectorBond {lvalue},SireBase::PropertyName)

hasMetadata( (SelectorBond)arg1, (PropertyName)key, (PropertyName)metakey) -> bool :

C++ signature :

bool hasMetadata(SireMM::SelectorBond {lvalue},SireBase::PropertyName,SireBase::PropertyName)

has_property()

hasProperty( (SelectorBond)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasProperty(SireMM::SelectorBond {lvalue},SireBase::PropertyName)

ids()

IDs( (SelectorBond)arg1) -> object :

C++ signature :

QList<SireMol::BondID> IDs(SireMM::SelectorBond {lvalue})

intersection((SelectorBond)arg1, (SelectorBond)other) → SelectorBond :

C++ signature :

SireMM::SelectorBond intersection(SireMM::SelectorBond {lvalue},SireMM::SelectorBond)

invert((SelectorBond)arg1[, (PropertyMap)map]) → SelectorBond :

C++ signature :

SireMM::SelectorBond invert(SireMM::SelectorBond {lvalue} [,SireBase::PropertyMap])

is_empty()

isEmpty( (SelectorBond)arg1) -> bool :

C++ signature :

bool isEmpty(SireMM::SelectorBond {lvalue})

is_link()

isLink( (MoleculeView)arg1, (PropertyName)key) -> bool :

Return whether or not this molecule has a link for the given property name

C++ signature :

bool isLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

is_null()

isNull( (MoleculeView)arg1) -> bool :

Return whether or not this molecule view is null

C++ signature :

bool isNull(SireMol::MoleculeView {lvalue})

is_same_molecule()

isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :

Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)

C++ signature :

bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeView)

isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :

Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)

C++ signature :

bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeData)

is_selector()

isSelector( (SelectorBond)arg1) -> bool :

C++ signature :

bool isSelector(SireMM::SelectorBond {lvalue})

lengths((SelectorBond)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0>> lengths(SireMM::SelectorBond {lvalue})

lengths( (SelectorBond)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0>> lengths(SireMM::SelectorBond {lvalue},SireBase::PropertyMap)

load_frame()

loadFrame( (MoleculeView)arg1, (int)frame) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int)

loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator)

loadFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator,SireBase::PropertyMap)

measures((SelectorBond)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0>> measures(SireMM::SelectorBond {lvalue})

measures( (SelectorBond)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0>> measures(SireMM::SelectorBond {lvalue},SireBase::PropertyMap)

metadata_keys()

metadataKeys( (SelectorBond)arg1) -> object :

C++ signature :

QStringList metadataKeys(SireMM::SelectorBond {lvalue})

metadataKeys( (SelectorBond)arg1, (PropertyName)key) -> object :

C++ signature :

QStringList metadataKeys(SireMM::SelectorBond {lvalue},SireBase::PropertyName)

metadata_type()

metadataType( (MoleculeView)arg1, (PropertyName)metakey) -> str :

Return the type of the metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

char const* metadataType(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

metadataType( (MoleculeView)arg1, (PropertyName)key, (PropertyName)metakey) -> str :

Return the type of the metadata at metakey metakey for the property at key key Throw: SireBase::missing_property

C++ signature :

char const* metadataType(SireMol::MoleculeView {lvalue},SireBase::PropertyName,SireBase::PropertyName)

molecules(idx=None, auto_reduce=False, error_on_missing: bool = False, map=None)

Return the molecule that contains this view as a list of molecules, containing just a single molecule.

If ‘id’ is specified then this checks that this molecule matches the ID before returning it. This will raise an exception if the ID doesn’t match.

Returns:

sire.mol.SelectorMol – that contains this view.

Return type:

A collection containing only a single molecule

move((SelectorBond)arg1) → Mover_SelectorBond_ :

C++ signature :

SireMol::Mover<SireMM::SelectorBond> move(SireMM::SelectorBond {lvalue})

num_atoms()

nAtoms( (MoleculeView)arg1) -> int :

Return the number of atoms in this view

C++ signature :

int nAtoms(SireMol::MoleculeView {lvalue})

num_chains()

nChains( (MoleculeView)arg1) -> int :

Return the number of chains in this view

C++ signature :

int nChains(SireMol::MoleculeView {lvalue})

num_cutgroups()

nCutGroups( (MoleculeView)arg1) -> int :

Return the number of CutGroups in this view

C++ signature :

int nCutGroups(SireMol::MoleculeView {lvalue})

num_frames()

nFrames( (MoleculeView)arg1) -> int :

C++ signature :

int nFrames(SireMol::MoleculeView {lvalue})

nFrames( (MoleculeView)arg1, (PropertyMap)map) -> int :

C++ signature :

int nFrames(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

num_residues()

nResidues( (MoleculeView)arg1) -> int :

Return the number of residues in this view

C++ signature :

int nResidues(SireMol::MoleculeView {lvalue})

num_segments()

nSegments( (MoleculeView)arg1) -> int :

Return the number of segments in this view

C++ signature :

int nSegments(SireMol::MoleculeView {lvalue})

num_views()

nViews( (SelectorBond)arg1) -> int :

C++ signature :

int nViews(SireMM::SelectorBond {lvalue})

potentials((SelectorBond)arg1) → object :

C++ signature :

QList<SireCAS::Expression> potentials(SireMM::SelectorBond {lvalue})

potentials( (SelectorBond)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireCAS::Expression> potentials(SireMM::SelectorBond {lvalue},SireBase::PropertyMap)

properties((SelectorBond)arg1) → object :

C++ signature :

QList<SireBase::Properties> properties(SireMM::SelectorBond {lvalue})

property_keys()

propertyKeys( (SelectorBond)arg1) -> object :

C++ signature :

QStringList propertyKeys(SireMM::SelectorBond {lvalue})

property_type()

propertyType( (MoleculeView)arg1, (PropertyName)key) -> str :

Return the type of the property at key key Throw: SireBase::missing_property

C++ signature :

char const* propertyType(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

residues((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Residue_ :

Return the residues from this view that match the ID resid

Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1) -> Selector_Residue_ :

Return all of the residues that are involved with this view Throw: SireMol::missing_residue

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue})

save_frame()

saveFrame( (MoleculeView)arg1 [, (int)frame]) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue} [,int])

saveFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

saveFrame( (MoleculeView)arg1, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

segments((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Segment_ :

Return the segments that are involved with this view that match

the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1) -> Selector_Segment_ :

Return the segments that are involved with this view Throw: SireMol::missing_segment

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue})

select_all()

selectAll( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> selectAll(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> selectAll(SireMol::MoleculeView {lvalue})

selectAll( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> selectAll(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> selectAll(SireMol::MoleculeView {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> selectAll(SireMol::MoleculeView {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> selectAll(SireMol::MoleculeView {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

select_all_atoms()

selectAllAtoms( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> selectAllAtoms(SireMol::MoleculeView {lvalue})

select_all_chains()

selectAllChains( (MoleculeView)arg1) -> Selector_Chain_ :

Return the chains that are involved with this view Throw: SireMol::missing_chain

C++ signature :

SireMol::Selector<SireMol::Chain> selectAllChains(SireMol::MoleculeView {lvalue})

select_all_cutgroups()

selectAllCutGroups( (MoleculeView)arg1) -> Selector_CutGroup_ :

Return all of the CutGroups that are involved in this view Throw: SireMol::missing_cutgroup

C++ signature :

SireMol::Selector<SireMol::CutGroup> selectAllCutGroups(SireMol::MoleculeView {lvalue})

select_all_residues()

selectAllResidues( (MoleculeView)arg1) -> Selector_Residue_ :

Return all of the residues that are involved with this view Throw: SireMol::missing_residue

C++ signature :

SireMol::Selector<SireMol::Residue> selectAllResidues(SireMol::MoleculeView {lvalue})

select_all_segments()

selectAllSegments( (MoleculeView)arg1) -> Selector_Segment_ :

Return the segments that are involved with this view Throw: SireMol::missing_segment

C++ signature :

SireMol::Selector<SireMol::Segment> selectAllSegments(SireMol::MoleculeView {lvalue})

selected_all()

selectedAll( (SelectorBond)arg1) -> bool :

C++ signature :

bool selectedAll(SireMM::SelectorBond {lvalue})

selection((SelectorBond)arg1) → AtomSelection :

C++ signature :

SireMol::AtomSelection selection(SireMM::SelectorBond {lvalue})

size()

__len__( (SelectorBond)arg1) -> int :

C++ signature :

unsigned long __len__(SireMM::SelectorBond {lvalue})

to_list()

toList( (SelectorBond)arg1) -> object :

C++ signature :

QList<SireBase::PropPtr<SireMol::MoleculeView>> toList(SireMM::SelectorBond {lvalue})

to_molecules()

toMolecules( (MoleculeView)arg1) -> Molecules :

Return a Molecules set that contains this view (or views)

C++ signature :

SireMol::Molecules toMolecules(SireMol::MoleculeView {lvalue})

to_selector()

toSelector( (SelectorBond)arg1) -> object :

C++ signature :

SireBase::PropPtr<SireMol::MoleculeView> toSelector(SireMM::SelectorBond {lvalue})

to_string()

toString( (SelectorBond)arg1) -> object :

C++ signature :

QString toString(SireMM::SelectorBond {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

view(default: bool = True, no_default: bool = False, orthographic: bool = True, protein: str = '', water: str = '', ions: str = '', rest: str = '', all: str = '', ball_and_stick: str = '', base: str = '', cartoon: str = '', hyperball: str = '', licorice: str = '', line: str = '', point: str = '', ribbon: str = '', rocket: str = '', rope: str = '', spacefill: str = '', surface: str = '', trace: str = '', tube: str = '', center: str = None, align: str = None, frame: int = None, smooth=False, wrap=True, mapping=None, bgcolor=None, stage_parameters: str = None, map=None)

Return an NGLView viewer for this view. The returned viewer can be passed directly to, e.g. a Jupyter notebook to directly view the molecule(s), or it can be captured in a variable so that it’s NGLViewer member functions can be called to edit the viewer before display.

Full instructions on how to use this view are in the cheatsheet (https://sire.openbiosim.org/cheatsheet/view)

center:

Pass in a selection string to select the atoms to center in the view. By default no atoms are centered

align:

Pass in a selection string to select atoms against which every frame will be aligned. These atoms will be moved to the center of the periodic box (if a periodic box is used). If “True” is passed, then this will attempt to align ALL of the coordinates in the view.

You can also choose to pass in a molecular container, and it will align against the atoms in that container, assuming they are contained in this view. If not, then you need to supply a mapping that maps from the atoms in the align container, to the atoms in this view.

frame:

The frame of the trajectory against which the alignment should be based. For example, frame=3 would align based on the coordinates of the aligned atoms in frame 3 of the trajectory. If this is None (the default) then the first frame will be used.

mapping: AtomMapping

An AtomMapping object that maps from atoms in the alignment container to atoms in this view. You only need to supply this if all of the alignment atoms are not contained in this view.

smooth:

Pass in the number of frames to smooth (average) the view over. If ‘True’ is passed, then the recommended number of frames will be averaged over

wrap: bool

Whether or not to wrap the coordinates into the periodic box.

orthographic:

Set to False to use a perspective view, or accept the default (True) for an orthographic view

default:

The default representation / color for the view. If this is set to False or None or “none” then default views are disabled.

no_default:

Set to False to disable all default views

protein, water, ions:

Set the default views for protein, water and ion molecules. Set to False, None or “none” to disable these default views.

rest:

Synonym for “default”, but does not disable all default views if set to None, False or “none”

all:

Set the representation for all atoms. Set to None, False or “none” to disable all views.

ball_and_stick, base, cartoon etc.

Set the selection strings for atoms that should be represented with these views.

bgcolor: str

The background color of the view. Set to ‘None’ to use the default background color (black)

stage_parameters: dict

An optional dictionary that will be passed directly to the NGLView object to set the stage parameters.

map: dict or sire.base.PropertyMap

An optional property map that can be used to control which properties are used to get the molecular data to be viewed.

what((SelectorBond)arg1) → str :

C++ signature :

char const* what(SireMM::SelectorBond {lvalue})

class sire.mm.SelectorDihedral

This provides a Selector<T>-style interface for multiple dihedrals

add((SelectorDihedral)arg1, (Dihedral)dihedral) → SelectorDihedral :

C++ signature :

SireMM::SelectorDihedral add(SireMM::SelectorDihedral {lvalue},SireMM::Dihedral)

add( (SelectorDihedral)arg1, (SelectorDihedral)other) -> SelectorDihedral :

C++ signature :

SireMM::SelectorDihedral add(SireMM::SelectorDihedral {lvalue},SireMM::SelectorDihedral)

assert_contains()

assertContains( (MoleculeView)arg1, (AtomIdx)atomidx) -> None :

Assert that this view contains the atom at index atomidx Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

void assertContains(SireMol::MoleculeView {lvalue},SireMol::AtomIdx)

assert_has_metadata()

assertHasMetadata( (MoleculeView)arg1, (PropertyName)metakey) -> None :

Assert that this contains some metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

void assertHasMetadata(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

assertHasMetadata( (MoleculeView)arg1, (PropertyName)key, (PropertyName)metakey) -> None :

Assert that this contains some metadata at metakey metakey for the property at key key Throw: SireBase::missing_property

C++ signature :

void assertHasMetadata(SireMol::MoleculeView {lvalue},SireBase::PropertyName,SireBase::PropertyName)

assert_has_property()

assertHasProperty( (MoleculeView)arg1, (PropertyName)key) -> None :

Assert that this contains a property at key key Throw: SireBase::missing_property

C++ signature :

void assertHasProperty(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

assert_same_molecule()

assertSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> None :

Assert that this is a view of the same molecule as other (albeit at a different version) Throw: SireError::incompatible_error

C++ signature :

void assertSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeView)

assertSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> None :

Assert that this view is looking at the molecule whose data is in other (albeit perhaps a different version of that molecule) Throw: SireError::incompatible_error

C++ signature :

void assertSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeData)

assign((SelectorDihedral)arg1, (SelectorDihedral)dihedral) → SelectorDihedral :

C++ signature :

SireMM::SelectorDihedral {lvalue} assign(SireMM::SelectorDihedral {lvalue},SireMM::SelectorDihedral)

atom((MoleculeView)arg1, (int)i[, (PropertyMap)map={}]) → Atom :

Return the atom in this view that matches the ID atomid

Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},int [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> Atom :

Return the atom in this view that matches the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Atom :

Return the atom in this view that matches the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1) -> Atom :

Return this view as a Atom - this will only work if this view contains only a single atom Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue})

atoms((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Atom_ :

Return the atoms from this view that match the ID atomid

Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue})

chains((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Chain_ :

Return the chains that are involved with this view that match

the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1) -> Selector_Chain_ :

Return the chains that are involved with this view Throw: SireMol::missing_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue})

clone((SelectorDihedral)arg1) → SelectorDihedral :

C++ signature :

SireMM::SelectorDihedral clone(SireMM::SelectorDihedral)

const_data()

constData( (MoleculeView)arg1) -> object :

Return the MoleculeData that contains all of the information about the molecule which this view is showing

C++ signature :

SireMol::MoleculeData constData(SireMol::MoleculeView {lvalue})

count()

__len__( (SelectorDihedral)arg1) -> int :

C++ signature :

unsigned long __len__(SireMM::SelectorDihedral {lvalue})

cursor(map=None)

Return the Cursors object that contains cursors for all of the views in this collection. Note that the parent cursor of this list will be the molecule

cutgroup()

cutGroup( (MoleculeView)arg1, (int)i [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},int [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1) -> CutGroup :

Return the CutGroup that contains the atom(s) in this view Throw: SireMol::missing_cutgroup Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue})

cutgroups()

cutGroups( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1) -> Selector_CutGroup_ :

Return all of the CutGroups that are involved in this view Throw: SireMol::missing_cutgroup

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue})

delete_all_frames()

deleteAllFrames( (MoleculeView)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue})

deleteAllFrames( (MoleculeView)arg1, (PropertyMap)map) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

delete_frame()

deleteFrame( (MoleculeView)arg1, (int)frame) -> None :

C++ signature :

void deleteFrame(SireMol::MoleculeView {lvalue},int)

deleteFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void deleteFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

energies((SelectorDihedral)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::GeneralUnit> energies(SireMM::SelectorDihedral {lvalue})

energies( (SelectorDihedral)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::GeneralUnit> energies(SireMM::SelectorDihedral {lvalue},SireBase::PropertyMap)

energy((SelectorDihedral)arg1) → GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::SelectorDihedral {lvalue})

energy( (SelectorDihedral)arg1, (PropertyMap)map) -> GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::SelectorDihedral {lvalue},SireBase::PropertyMap)

evaluate((SelectorDihedral)arg1) → Evaluator :

C++ signature :

SireMol::Evaluator evaluate(SireMM::SelectorDihedral {lvalue})

get_link()

getLink( (MoleculeView)arg1, (PropertyName)key) -> object :

Return the link for the given property name. This will throw an exception if there is no link for the given property name.

C++ signature :

QString getLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

get_links()

getLinks( (MoleculeView)arg1) -> object :

Return the property links for this molecule. This returns an empty dictionary if there are no links.

C++ signature :

QHash<QString, QString> getLinks(SireMol::MoleculeView {lvalue})

has_links()

hasLinks( (MoleculeView)arg1) -> bool :

Return whether or not this molecule has any property links

C++ signature :

bool hasLinks(SireMol::MoleculeView {lvalue})

has_metadata()

hasMetadata( (SelectorDihedral)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasMetadata(SireMM::SelectorDihedral {lvalue},SireBase::PropertyName)

hasMetadata( (SelectorDihedral)arg1, (PropertyName)key, (PropertyName)metakey) -> bool :

C++ signature :

bool hasMetadata(SireMM::SelectorDihedral {lvalue},SireBase::PropertyName,SireBase::PropertyName)

has_property()

hasProperty( (SelectorDihedral)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasProperty(SireMM::SelectorDihedral {lvalue},SireBase::PropertyName)

ids()

IDs( (SelectorDihedral)arg1) -> object :

C++ signature :

QList<SireMol::DihedralID> IDs(SireMM::SelectorDihedral {lvalue})

intersection((SelectorDihedral)arg1, (SelectorDihedral)other) → SelectorDihedral :

C++ signature :

SireMM::SelectorDihedral intersection(SireMM::SelectorDihedral {lvalue},SireMM::SelectorDihedral)

invert((SelectorDihedral)arg1[, (PropertyMap)map]) → SelectorDihedral :

C++ signature :

SireMM::SelectorDihedral invert(SireMM::SelectorDihedral {lvalue} [,SireBase::PropertyMap])

is_empty()

isEmpty( (SelectorDihedral)arg1) -> bool :

C++ signature :

bool isEmpty(SireMM::SelectorDihedral {lvalue})

is_link()

isLink( (MoleculeView)arg1, (PropertyName)key) -> bool :

Return whether or not this molecule has a link for the given property name

C++ signature :

bool isLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

is_null()

isNull( (MoleculeView)arg1) -> bool :

Return whether or not this molecule view is null

C++ signature :

bool isNull(SireMol::MoleculeView {lvalue})

is_same_molecule()

isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :

Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)

C++ signature :

bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeView)

isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :

Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)

C++ signature :

bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeData)

is_selector()

isSelector( (SelectorDihedral)arg1) -> bool :

C++ signature :

bool isSelector(SireMM::SelectorDihedral {lvalue})

load_frame()

loadFrame( (MoleculeView)arg1, (int)frame) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int)

loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator)

loadFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator,SireBase::PropertyMap)

measures((SelectorDihedral)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> measures(SireMM::SelectorDihedral {lvalue})

measures( (SelectorDihedral)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> measures(SireMM::SelectorDihedral {lvalue},SireBase::PropertyMap)

metadata_keys()

metadataKeys( (SelectorDihedral)arg1) -> object :

C++ signature :

QStringList metadataKeys(SireMM::SelectorDihedral {lvalue})

metadataKeys( (SelectorDihedral)arg1, (PropertyName)key) -> object :

C++ signature :

QStringList metadataKeys(SireMM::SelectorDihedral {lvalue},SireBase::PropertyName)

metadata_type()

metadataType( (MoleculeView)arg1, (PropertyName)metakey) -> str :

Return the type of the metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

char const* metadataType(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

metadataType( (MoleculeView)arg1, (PropertyName)key, (PropertyName)metakey) -> str :

Return the type of the metadata at metakey metakey for the property at key key Throw: SireBase::missing_property

C++ signature :

char const* metadataType(SireMol::MoleculeView {lvalue},SireBase::PropertyName,SireBase::PropertyName)

molecules(idx=None, auto_reduce=False, error_on_missing: bool = False, map=None)

Return the molecule that contains this view as a list of molecules, containing just a single molecule.

If ‘id’ is specified then this checks that this molecule matches the ID before returning it. This will raise an exception if the ID doesn’t match.

Returns:

sire.mol.SelectorMol – that contains this view.

Return type:

A collection containing only a single molecule

move((SelectorDihedral)arg1) → Mover_SelectorDihedral_ :

C++ signature :

SireMol::Mover<SireMM::SelectorDihedral> move(SireMM::SelectorDihedral {lvalue})

num_atoms()

nAtoms( (MoleculeView)arg1) -> int :

Return the number of atoms in this view

C++ signature :

int nAtoms(SireMol::MoleculeView {lvalue})

num_chains()

nChains( (MoleculeView)arg1) -> int :

Return the number of chains in this view

C++ signature :

int nChains(SireMol::MoleculeView {lvalue})

num_cutgroups()

nCutGroups( (MoleculeView)arg1) -> int :

Return the number of CutGroups in this view

C++ signature :

int nCutGroups(SireMol::MoleculeView {lvalue})

num_frames()

nFrames( (MoleculeView)arg1) -> int :

C++ signature :

int nFrames(SireMol::MoleculeView {lvalue})

nFrames( (MoleculeView)arg1, (PropertyMap)map) -> int :

C++ signature :

int nFrames(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

num_residues()

nResidues( (MoleculeView)arg1) -> int :

Return the number of residues in this view

C++ signature :

int nResidues(SireMol::MoleculeView {lvalue})

num_segments()

nSegments( (MoleculeView)arg1) -> int :

Return the number of segments in this view

C++ signature :

int nSegments(SireMol::MoleculeView {lvalue})

num_views()

nViews( (SelectorDihedral)arg1) -> int :

C++ signature :

int nViews(SireMM::SelectorDihedral {lvalue})

potentials((SelectorDihedral)arg1) → object :

C++ signature :

QList<SireCAS::Expression> potentials(SireMM::SelectorDihedral {lvalue})

potentials( (SelectorDihedral)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireCAS::Expression> potentials(SireMM::SelectorDihedral {lvalue},SireBase::PropertyMap)

properties((SelectorDihedral)arg1) → object :

C++ signature :

QList<SireBase::Properties> properties(SireMM::SelectorDihedral {lvalue})

property_keys()

propertyKeys( (SelectorDihedral)arg1) -> object :

C++ signature :

QStringList propertyKeys(SireMM::SelectorDihedral {lvalue})

property_type()

propertyType( (MoleculeView)arg1, (PropertyName)key) -> str :

Return the type of the property at key key Throw: SireBase::missing_property

C++ signature :

char const* propertyType(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

residues((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Residue_ :

Return the residues from this view that match the ID resid

Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1) -> Selector_Residue_ :

Return all of the residues that are involved with this view Throw: SireMol::missing_residue

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue})

save_frame()

saveFrame( (MoleculeView)arg1 [, (int)frame]) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue} [,int])

saveFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

saveFrame( (MoleculeView)arg1, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

segments((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Segment_ :

Return the segments that are involved with this view that match

the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1) -> Selector_Segment_ :

Return the segments that are involved with this view Throw: SireMol::missing_segment

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue})

select_all()

selectAll( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> selectAll(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> selectAll(SireMol::MoleculeView {lvalue})

selectAll( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> selectAll(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> selectAll(SireMol::MoleculeView {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> selectAll(SireMol::MoleculeView {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> selectAll(SireMol::MoleculeView {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

select_all_atoms()

selectAllAtoms( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> selectAllAtoms(SireMol::MoleculeView {lvalue})

select_all_chains()

selectAllChains( (MoleculeView)arg1) -> Selector_Chain_ :

Return the chains that are involved with this view Throw: SireMol::missing_chain

C++ signature :

SireMol::Selector<SireMol::Chain> selectAllChains(SireMol::MoleculeView {lvalue})

select_all_cutgroups()

selectAllCutGroups( (MoleculeView)arg1) -> Selector_CutGroup_ :

Return all of the CutGroups that are involved in this view Throw: SireMol::missing_cutgroup

C++ signature :

SireMol::Selector<SireMol::CutGroup> selectAllCutGroups(SireMol::MoleculeView {lvalue})

select_all_residues()

selectAllResidues( (MoleculeView)arg1) -> Selector_Residue_ :

Return all of the residues that are involved with this view Throw: SireMol::missing_residue

C++ signature :

SireMol::Selector<SireMol::Residue> selectAllResidues(SireMol::MoleculeView {lvalue})

select_all_segments()

selectAllSegments( (MoleculeView)arg1) -> Selector_Segment_ :

Return the segments that are involved with this view Throw: SireMol::missing_segment

C++ signature :

SireMol::Selector<SireMol::Segment> selectAllSegments(SireMol::MoleculeView {lvalue})

selected_all()

selectedAll( (SelectorDihedral)arg1) -> bool :

C++ signature :

bool selectedAll(SireMM::SelectorDihedral {lvalue})

selection((SelectorDihedral)arg1) → AtomSelection :

C++ signature :

SireMol::AtomSelection selection(SireMM::SelectorDihedral {lvalue})

size()

__len__( (SelectorDihedral)arg1) -> int :

C++ signature :

unsigned long __len__(SireMM::SelectorDihedral {lvalue})

sizes((SelectorDihedral)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> sizes(SireMM::SelectorDihedral {lvalue})

sizes( (SelectorDihedral)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> sizes(SireMM::SelectorDihedral {lvalue},SireBase::PropertyMap)

to_list()

toList( (SelectorDihedral)arg1) -> object :

C++ signature :

QList<SireBase::PropPtr<SireMol::MoleculeView>> toList(SireMM::SelectorDihedral {lvalue})

to_molecules()

toMolecules( (MoleculeView)arg1) -> Molecules :

Return a Molecules set that contains this view (or views)

C++ signature :

SireMol::Molecules toMolecules(SireMol::MoleculeView {lvalue})

to_selector()

toSelector( (SelectorDihedral)arg1) -> object :

C++ signature :

SireBase::PropPtr<SireMol::MoleculeView> toSelector(SireMM::SelectorDihedral {lvalue})

to_string()

toString( (SelectorDihedral)arg1) -> object :

C++ signature :

QString toString(SireMM::SelectorDihedral {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

view(default: bool = True, no_default: bool = False, orthographic: bool = True, protein: str = '', water: str = '', ions: str = '', rest: str = '', all: str = '', ball_and_stick: str = '', base: str = '', cartoon: str = '', hyperball: str = '', licorice: str = '', line: str = '', point: str = '', ribbon: str = '', rocket: str = '', rope: str = '', spacefill: str = '', surface: str = '', trace: str = '', tube: str = '', center: str = None, align: str = None, frame: int = None, smooth=False, wrap=True, mapping=None, bgcolor=None, stage_parameters: str = None, map=None)

Return an NGLView viewer for this view. The returned viewer can be passed directly to, e.g. a Jupyter notebook to directly view the molecule(s), or it can be captured in a variable so that it’s NGLViewer member functions can be called to edit the viewer before display.

Full instructions on how to use this view are in the cheatsheet (https://sire.openbiosim.org/cheatsheet/view)

center:

Pass in a selection string to select the atoms to center in the view. By default no atoms are centered

align:

Pass in a selection string to select atoms against which every frame will be aligned. These atoms will be moved to the center of the periodic box (if a periodic box is used). If “True” is passed, then this will attempt to align ALL of the coordinates in the view.

You can also choose to pass in a molecular container, and it will align against the atoms in that container, assuming they are contained in this view. If not, then you need to supply a mapping that maps from the atoms in the align container, to the atoms in this view.

frame:

The frame of the trajectory against which the alignment should be based. For example, frame=3 would align based on the coordinates of the aligned atoms in frame 3 of the trajectory. If this is None (the default) then the first frame will be used.

mapping: AtomMapping

An AtomMapping object that maps from atoms in the alignment container to atoms in this view. You only need to supply this if all of the alignment atoms are not contained in this view.

smooth:

Pass in the number of frames to smooth (average) the view over. If ‘True’ is passed, then the recommended number of frames will be averaged over

wrap: bool

Whether or not to wrap the coordinates into the periodic box.

orthographic:

Set to False to use a perspective view, or accept the default (True) for an orthographic view

default:

The default representation / color for the view. If this is set to False or None or “none” then default views are disabled.

no_default:

Set to False to disable all default views

protein, water, ions:

Set the default views for protein, water and ion molecules. Set to False, None or “none” to disable these default views.

rest:

Synonym for “default”, but does not disable all default views if set to None, False or “none”

all:

Set the representation for all atoms. Set to None, False or “none” to disable all views.

ball_and_stick, base, cartoon etc.

Set the selection strings for atoms that should be represented with these views.

bgcolor: str

The background color of the view. Set to ‘None’ to use the default background color (black)

stage_parameters: dict

An optional dictionary that will be passed directly to the NGLView object to set the stage parameters.

map: dict or sire.base.PropertyMap

An optional property map that can be used to control which properties are used to get the molecular data to be viewed.

what((SelectorDihedral)arg1) → str :

C++ signature :

char const* what(SireMM::SelectorDihedral {lvalue})

class sire.mm.SelectorImproper

This provides a Selector<T>-style interface for multiple impropers

add((SelectorImproper)arg1, (Improper)Improper) → SelectorImproper :

C++ signature :

SireMM::SelectorImproper add(SireMM::SelectorImproper {lvalue},SireMM::Improper)

add( (SelectorImproper)arg1, (SelectorImproper)other) -> SelectorImproper :

C++ signature :

SireMM::SelectorImproper add(SireMM::SelectorImproper {lvalue},SireMM::SelectorImproper)

assert_contains()

assertContains( (MoleculeView)arg1, (AtomIdx)atomidx) -> None :

Assert that this view contains the atom at index atomidx Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

void assertContains(SireMol::MoleculeView {lvalue},SireMol::AtomIdx)

assert_has_metadata()

assertHasMetadata( (MoleculeView)arg1, (PropertyName)metakey) -> None :

Assert that this contains some metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

void assertHasMetadata(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

assertHasMetadata( (MoleculeView)arg1, (PropertyName)key, (PropertyName)metakey) -> None :

Assert that this contains some metadata at metakey metakey for the property at key key Throw: SireBase::missing_property

C++ signature :

void assertHasMetadata(SireMol::MoleculeView {lvalue},SireBase::PropertyName,SireBase::PropertyName)

assert_has_property()

assertHasProperty( (MoleculeView)arg1, (PropertyName)key) -> None :

Assert that this contains a property at key key Throw: SireBase::missing_property

C++ signature :

void assertHasProperty(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

assert_same_molecule()

assertSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> None :

Assert that this is a view of the same molecule as other (albeit at a different version) Throw: SireError::incompatible_error

C++ signature :

void assertSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeView)

assertSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> None :

Assert that this view is looking at the molecule whose data is in other (albeit perhaps a different version of that molecule) Throw: SireError::incompatible_error

C++ signature :

void assertSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeData)

assign((SelectorImproper)arg1, (SelectorImproper)Improper) → SelectorImproper :

C++ signature :

SireMM::SelectorImproper {lvalue} assign(SireMM::SelectorImproper {lvalue},SireMM::SelectorImproper)

atom((MoleculeView)arg1, (int)i[, (PropertyMap)map={}]) → Atom :

Return the atom in this view that matches the ID atomid

Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},int [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> Atom :

Return the atom in this view that matches the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Atom :

Return the atom in this view that matches the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

atom( (MoleculeView)arg1) -> Atom :

Return this view as a Atom - this will only work if this view contains only a single atom Throw: SireMol::duplicate_atom

C++ signature :

SireMol::Atom atom(SireMol::MoleculeView {lvalue})

atoms((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Atom_ :

Return the atoms from this view that match the ID atomid

Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

atoms( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> atoms(SireMol::MoleculeView {lvalue})

chains((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Chain_ :

Return the chains that are involved with this view that match

the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

chains( (MoleculeView)arg1) -> Selector_Chain_ :

Return the chains that are involved with this view Throw: SireMol::missing_chain

C++ signature :

SireMol::Selector<SireMol::Chain> chains(SireMol::MoleculeView {lvalue})

clone((SelectorImproper)arg1) → SelectorImproper :

C++ signature :

SireMM::SelectorImproper clone(SireMM::SelectorImproper)

const_data()

constData( (MoleculeView)arg1) -> object :

Return the MoleculeData that contains all of the information about the molecule which this view is showing

C++ signature :

SireMol::MoleculeData constData(SireMol::MoleculeView {lvalue})

count()

__len__( (SelectorImproper)arg1) -> int :

C++ signature :

unsigned long __len__(SireMM::SelectorImproper {lvalue})

cursor(map=None)

Return the Cursors object that contains cursors for all of the views in this collection. Note that the parent cursor of this list will be the molecule

cutgroup()

cutGroup( (MoleculeView)arg1, (int)i [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},int [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> CutGroup :

Return the CutGroup whose atoms are in this view that matches the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutGroup( (MoleculeView)arg1) -> CutGroup :

Return the CutGroup that contains the atom(s) in this view Throw: SireMol::missing_cutgroup Throw: SireMol::duplicate_cutgroup

C++ signature :

SireMol::CutGroup cutGroup(SireMol::MoleculeView {lvalue})

cutgroups()

cutGroups( (MoleculeView)arg1, (object)name [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutGroups( (MoleculeView)arg1) -> Selector_CutGroup_ :

Return all of the CutGroups that are involved in this view Throw: SireMol::missing_cutgroup

C++ signature :

SireMol::Selector<SireMol::CutGroup> cutGroups(SireMol::MoleculeView {lvalue})

delete_all_frames()

deleteAllFrames( (MoleculeView)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue})

deleteAllFrames( (MoleculeView)arg1, (PropertyMap)map) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

delete_frame()

deleteFrame( (MoleculeView)arg1, (int)frame) -> None :

C++ signature :

void deleteFrame(SireMol::MoleculeView {lvalue},int)

deleteFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void deleteFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

energies((SelectorImproper)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::GeneralUnit> energies(SireMM::SelectorImproper {lvalue})

energies( (SelectorImproper)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::GeneralUnit> energies(SireMM::SelectorImproper {lvalue},SireBase::PropertyMap)

energy((SelectorImproper)arg1) → GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::SelectorImproper {lvalue})

energy( (SelectorImproper)arg1, (PropertyMap)map) -> GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::SelectorImproper {lvalue},SireBase::PropertyMap)

evaluate((SelectorImproper)arg1) → Evaluator :

C++ signature :

SireMol::Evaluator evaluate(SireMM::SelectorImproper {lvalue})

get_link()

getLink( (MoleculeView)arg1, (PropertyName)key) -> object :

Return the link for the given property name. This will throw an exception if there is no link for the given property name.

C++ signature :

QString getLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

get_links()

getLinks( (MoleculeView)arg1) -> object :

Return the property links for this molecule. This returns an empty dictionary if there are no links.

C++ signature :

QHash<QString, QString> getLinks(SireMol::MoleculeView {lvalue})

has_links()

hasLinks( (MoleculeView)arg1) -> bool :

Return whether or not this molecule has any property links

C++ signature :

bool hasLinks(SireMol::MoleculeView {lvalue})

has_metadata()

hasMetadata( (SelectorImproper)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasMetadata(SireMM::SelectorImproper {lvalue},SireBase::PropertyName)

hasMetadata( (SelectorImproper)arg1, (PropertyName)key, (PropertyName)metakey) -> bool :

C++ signature :

bool hasMetadata(SireMM::SelectorImproper {lvalue},SireBase::PropertyName,SireBase::PropertyName)

has_property()

hasProperty( (SelectorImproper)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasProperty(SireMM::SelectorImproper {lvalue},SireBase::PropertyName)

ids()

IDs( (SelectorImproper)arg1) -> object :

C++ signature :

QList<SireMol::ImproperID> IDs(SireMM::SelectorImproper {lvalue})

intersection((SelectorImproper)arg1, (SelectorImproper)other) → SelectorImproper :

C++ signature :

SireMM::SelectorImproper intersection(SireMM::SelectorImproper {lvalue},SireMM::SelectorImproper)

invert((SelectorImproper)arg1[, (PropertyMap)map]) → SelectorImproper :

C++ signature :

SireMM::SelectorImproper invert(SireMM::SelectorImproper {lvalue} [,SireBase::PropertyMap])

is_empty()

isEmpty( (SelectorImproper)arg1) -> bool :

C++ signature :

bool isEmpty(SireMM::SelectorImproper {lvalue})

is_link()

isLink( (MoleculeView)arg1, (PropertyName)key) -> bool :

Return whether or not this molecule has a link for the given property name

C++ signature :

bool isLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

is_null()

isNull( (MoleculeView)arg1) -> bool :

Return whether or not this molecule view is null

C++ signature :

bool isNull(SireMol::MoleculeView {lvalue})

is_same_molecule()

isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :

Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)

C++ signature :

bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeView)

isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :

Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)

C++ signature :

bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeData)

is_selector()

isSelector( (SelectorImproper)arg1) -> bool :

C++ signature :

bool isSelector(SireMM::SelectorImproper {lvalue})

load_frame()

loadFrame( (MoleculeView)arg1, (int)frame) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int)

loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator)

loadFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator,SireBase::PropertyMap)

measures((SelectorImproper)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> measures(SireMM::SelectorImproper {lvalue})

measures( (SelectorImproper)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> measures(SireMM::SelectorImproper {lvalue},SireBase::PropertyMap)

metadata_keys()

metadataKeys( (SelectorImproper)arg1) -> object :

C++ signature :

QStringList metadataKeys(SireMM::SelectorImproper {lvalue})

metadataKeys( (SelectorImproper)arg1, (PropertyName)key) -> object :

C++ signature :

QStringList metadataKeys(SireMM::SelectorImproper {lvalue},SireBase::PropertyName)

metadata_type()

metadataType( (MoleculeView)arg1, (PropertyName)metakey) -> str :

Return the type of the metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

char const* metadataType(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

metadataType( (MoleculeView)arg1, (PropertyName)key, (PropertyName)metakey) -> str :

Return the type of the metadata at metakey metakey for the property at key key Throw: SireBase::missing_property

C++ signature :

char const* metadataType(SireMol::MoleculeView {lvalue},SireBase::PropertyName,SireBase::PropertyName)

molecules(idx=None, auto_reduce=False, error_on_missing: bool = False, map=None)

Return the molecule that contains this view as a list of molecules, containing just a single molecule.

If ‘id’ is specified then this checks that this molecule matches the ID before returning it. This will raise an exception if the ID doesn’t match.

Returns:

sire.mol.SelectorMol – that contains this view.

Return type:

A collection containing only a single molecule

move((SelectorImproper)arg1) → Mover_SelectorImproper_ :

C++ signature :

SireMol::Mover<SireMM::SelectorImproper> move(SireMM::SelectorImproper {lvalue})

num_atoms()

nAtoms( (MoleculeView)arg1) -> int :

Return the number of atoms in this view

C++ signature :

int nAtoms(SireMol::MoleculeView {lvalue})

num_chains()

nChains( (MoleculeView)arg1) -> int :

Return the number of chains in this view

C++ signature :

int nChains(SireMol::MoleculeView {lvalue})

num_cutgroups()

nCutGroups( (MoleculeView)arg1) -> int :

Return the number of CutGroups in this view

C++ signature :

int nCutGroups(SireMol::MoleculeView {lvalue})

num_frames()

nFrames( (MoleculeView)arg1) -> int :

C++ signature :

int nFrames(SireMol::MoleculeView {lvalue})

nFrames( (MoleculeView)arg1, (PropertyMap)map) -> int :

C++ signature :

int nFrames(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

num_residues()

nResidues( (MoleculeView)arg1) -> int :

Return the number of residues in this view

C++ signature :

int nResidues(SireMol::MoleculeView {lvalue})

num_segments()

nSegments( (MoleculeView)arg1) -> int :

Return the number of segments in this view

C++ signature :

int nSegments(SireMol::MoleculeView {lvalue})

num_views()

nViews( (SelectorImproper)arg1) -> int :

C++ signature :

int nViews(SireMM::SelectorImproper {lvalue})

potentials((SelectorImproper)arg1) → object :

C++ signature :

QList<SireCAS::Expression> potentials(SireMM::SelectorImproper {lvalue})

potentials( (SelectorImproper)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireCAS::Expression> potentials(SireMM::SelectorImproper {lvalue},SireBase::PropertyMap)

properties((SelectorImproper)arg1) → object :

C++ signature :

QList<SireBase::Properties> properties(SireMM::SelectorImproper {lvalue})

property_keys()

propertyKeys( (SelectorImproper)arg1) -> object :

C++ signature :

QStringList propertyKeys(SireMM::SelectorImproper {lvalue})

property_type()

propertyType( (MoleculeView)arg1, (PropertyName)key) -> str :

Return the type of the property at key key Throw: SireBase::missing_property

C++ signature :

char const* propertyType(SireMol::MoleculeView {lvalue},SireBase::PropertyName)

residues((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Residue_ :

Return the residues from this view that match the ID resid

Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

residues( (MoleculeView)arg1) -> Selector_Residue_ :

Return all of the residues that are involved with this view Throw: SireMol::missing_residue

C++ signature :

SireMol::Selector<SireMol::Residue> residues(SireMol::MoleculeView {lvalue})

save_frame()

saveFrame( (MoleculeView)arg1 [, (int)frame]) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue} [,int])

saveFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)

saveFrame( (MoleculeView)arg1, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMol::MoleculeView {lvalue},SireBase::PropertyMap)

segments((MoleculeView)arg1, (object)name[, (PropertyMap)map={}]) → Selector_Segment_ :

Return the segments that are involved with this view that match

the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QString [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)values [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QList<long long> [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)names [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},QStringList [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (object)slice [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

segments( (MoleculeView)arg1) -> Selector_Segment_ :

Return the segments that are involved with this view Throw: SireMol::missing_segment

C++ signature :

SireMol::Selector<SireMol::Segment> segments(SireMol::MoleculeView {lvalue})

select_all()

selectAll( (MoleculeView)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Selector_Atom_ :

Return the atoms from this view that match the ID atomid Throw: SireMol::missing_atom Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Atom> selectAll(SireMol::MoleculeView {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> selectAll(SireMol::MoleculeView {lvalue})

selectAll( (MoleculeView)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> Selector_CutGroup_ :

Return the CutGroups whose atoms are in this view that match the ID in cgid Throw: SireMol::missing_cutgroup Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::CutGroup> selectAll(SireMol::MoleculeView {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Selector_Residue_ :

Return the residues from this view that match the ID resid Throw: SireMol::missing_residue Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Residue> selectAll(SireMol::MoleculeView {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Selector_Chain_ :

Return the chains that are involved with this view that match the ID chainid Throw: SireMol::missing_chain Throw: SireError::invalid_index Throw: SireMol::duplicate_chain

C++ signature :

SireMol::Selector<SireMol::Chain> selectAll(SireMol::MoleculeView {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

selectAll( (MoleculeView)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Selector_Segment_ :

Return the segments that are involved with this view that match the ID segid Throw: SireMol::missing_segment Throw: SireError::invalid_index

C++ signature :

SireMol::Selector<SireMol::Segment> selectAll(SireMol::MoleculeView {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

select_all_atoms()

selectAllAtoms( (MoleculeView)arg1) -> Selector_Atom_ :

Return all of the atoms in this view Throw: SireMol::missing_atom

C++ signature :

SireMol::Selector<SireMol::Atom> selectAllAtoms(SireMol::MoleculeView {lvalue})

select_all_chains()

selectAllChains( (MoleculeView)arg1) -> Selector_Chain_ :

Return the chains that are involved with this view Throw: SireMol::missing_chain

C++ signature :

SireMol::Selector<SireMol::Chain> selectAllChains(SireMol::MoleculeView {lvalue})

select_all_cutgroups()

selectAllCutGroups( (MoleculeView)arg1) -> Selector_CutGroup_ :

Return all of the CutGroups that are involved in this view Throw: SireMol::missing_cutgroup

C++ signature :

SireMol::Selector<SireMol::CutGroup> selectAllCutGroups(SireMol::MoleculeView {lvalue})

select_all_residues()

selectAllResidues( (MoleculeView)arg1) -> Selector_Residue_ :

Return all of the residues that are involved with this view Throw: SireMol::missing_residue

C++ signature :

SireMol::Selector<SireMol::Residue> selectAllResidues(SireMol::MoleculeView {lvalue})

select_all_segments()

selectAllSegments( (MoleculeView)arg1) -> Selector_Segment_ :

Return the segments that are involved with this view Throw: SireMol::missing_segment

C++ signature :

SireMol::Selector<SireMol::Segment> selectAllSegments(SireMol::MoleculeView {lvalue})

selected_all()

selectedAll( (SelectorImproper)arg1) -> bool :

C++ signature :

bool selectedAll(SireMM::SelectorImproper {lvalue})

selection((SelectorImproper)arg1) → AtomSelection :

C++ signature :

SireMol::AtomSelection selection(SireMM::SelectorImproper {lvalue})

size()

__len__( (SelectorImproper)arg1) -> int :

C++ signature :

unsigned long __len__(SireMM::SelectorImproper {lvalue})

sizes((SelectorImproper)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> sizes(SireMM::SelectorImproper {lvalue})

sizes( (SelectorImproper)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> sizes(SireMM::SelectorImproper {lvalue},SireBase::PropertyMap)

to_list()

toList( (SelectorImproper)arg1) -> object :

C++ signature :

QList<SireBase::PropPtr<SireMol::MoleculeView>> toList(SireMM::SelectorImproper {lvalue})

to_molecules()

toMolecules( (MoleculeView)arg1) -> Molecules :

Return a Molecules set that contains this view (or views)

C++ signature :

SireMol::Molecules toMolecules(SireMol::MoleculeView {lvalue})

to_selector()

toSelector( (SelectorImproper)arg1) -> object :

C++ signature :

SireBase::PropPtr<SireMol::MoleculeView> toSelector(SireMM::SelectorImproper {lvalue})

to_string()

toString( (SelectorImproper)arg1) -> object :

C++ signature :

QString toString(SireMM::SelectorImproper {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

view(default: bool = True, no_default: bool = False, orthographic: bool = True, protein: str = '', water: str = '', ions: str = '', rest: str = '', all: str = '', ball_and_stick: str = '', base: str = '', cartoon: str = '', hyperball: str = '', licorice: str = '', line: str = '', point: str = '', ribbon: str = '', rocket: str = '', rope: str = '', spacefill: str = '', surface: str = '', trace: str = '', tube: str = '', center: str = None, align: str = None, frame: int = None, smooth=False, wrap=True, mapping=None, bgcolor=None, stage_parameters: str = None, map=None)

Return an NGLView viewer for this view. The returned viewer can be passed directly to, e.g. a Jupyter notebook to directly view the molecule(s), or it can be captured in a variable so that it’s NGLViewer member functions can be called to edit the viewer before display.

Full instructions on how to use this view are in the cheatsheet (https://sire.openbiosim.org/cheatsheet/view)

center:

Pass in a selection string to select the atoms to center in the view. By default no atoms are centered

align:

Pass in a selection string to select atoms against which every frame will be aligned. These atoms will be moved to the center of the periodic box (if a periodic box is used). If “True” is passed, then this will attempt to align ALL of the coordinates in the view.

You can also choose to pass in a molecular container, and it will align against the atoms in that container, assuming they are contained in this view. If not, then you need to supply a mapping that maps from the atoms in the align container, to the atoms in this view.

frame:

The frame of the trajectory against which the alignment should be based. For example, frame=3 would align based on the coordinates of the aligned atoms in frame 3 of the trajectory. If this is None (the default) then the first frame will be used.

mapping: AtomMapping

An AtomMapping object that maps from atoms in the alignment container to atoms in this view. You only need to supply this if all of the alignment atoms are not contained in this view.

smooth:

Pass in the number of frames to smooth (average) the view over. If ‘True’ is passed, then the recommended number of frames will be averaged over

wrap: bool

Whether or not to wrap the coordinates into the periodic box.

orthographic:

Set to False to use a perspective view, or accept the default (True) for an orthographic view

default:

The default representation / color for the view. If this is set to False or None or “none” then default views are disabled.

no_default:

Set to False to disable all default views

protein, water, ions:

Set the default views for protein, water and ion molecules. Set to False, None or “none” to disable these default views.

rest:

Synonym for “default”, but does not disable all default views if set to None, False or “none”

all:

Set the representation for all atoms. Set to None, False or “none” to disable all views.

ball_and_stick, base, cartoon etc.

Set the selection strings for atoms that should be represented with these views.

bgcolor: str

The background color of the view. Set to ‘None’ to use the default background color (black)

stage_parameters: dict

An optional dictionary that will be passed directly to the NGLView object to set the stage parameters.

map: dict or sire.base.PropertyMap

An optional property map that can be used to control which properties are used to get the molecular data to be viewed.

what((SelectorImproper)arg1) → str :

C++ signature :

char const* what(SireMM::SelectorImproper {lvalue})

class sire.mm.SelectorMAngle

Multi-molecule selector for angles

add((SelectorMAngle)arg1, (SelectorMAngle)other) → SelectorMAngle :

C++ signature :

SireMM::SelectorMAngle add(SireMM::SelectorMAngle {lvalue},SireMM::SelectorMAngle)

apply(func, *args, **kwargs)

Call the passed function on all views in the container, appending the result to a list of results, which is returned.

The function can be either;

1. a string containing the name of the function to call, or

2. an actual function (either a normal function or a lambda expression)

You can optionally pass in positional and keyword arguments here that will be passed to the function.

Parameters:

• objs (self) – The container itself (this is self)

• func (str or function) – The function to be called, or the name of the function to be called.

Returns:

A list of the results, with one result per view in the container.

Return type:

list

apply_reduce(func, reduction_func=None, *args, **kwargs)

Call the passed function on all views in the container, reducing the result into a single value via the ‘reduce’ function.

This is equivalent to calling

``` reduce(reduction_func, objs.apply(func, *args, **kwargs))

The function can be either;

1. a string containing the name of the function to call, or

2. an actual function (either a normal function or a lambda expression)

The reduction function should be a function that can be passed to reduce. If this isn’t passed, then it is assumed to be operator.add.

You can optionally pass in positional and keyword arguments here that will be passed to the applied function.

Parameters:

• objs (self) – The container itself (this is self)

• func (str or function) – The function to be called, or the name of the function to be called.

• reduction_func – The function used to reduce the result. This is operator.add by default.

Returns:

The reduced result

Return type:

result

assign((SelectorMAngle)arg1, (SelectorMAngle)other) → SelectorMAngle :

C++ signature :

SireMM::SelectorMAngle {lvalue} assign(SireMM::SelectorMAngle {lvalue},SireMM::SelectorMAngle)

chain((SelectorMAngle)arg1, (int)i[, (PropertyMap)map={}]) → Chain :

C++ signature :

SireMol::Chain chain(SireMM::SelectorMAngle {lvalue},int [,SireBase::PropertyMap={}])

chain( (SelectorMAngle)arg1, (object)name [, (PropertyMap)map={}]) -> Chain :

C++ signature :

SireMol::Chain chain(SireMM::SelectorMAngle {lvalue},QString [,SireBase::PropertyMap={}])

chain( (SelectorMAngle)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Chain :

C++ signature :

SireMol::Chain chain(SireMM::SelectorMAngle {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

clone((SelectorMAngle)arg1) → SelectorMAngle :

C++ signature :

SireMM::SelectorMAngle clone(SireMM::SelectorMAngle)

count()

__len__( (SelectorMAngle)arg1) -> int :

C++ signature :

unsigned long __len__(SireMM::SelectorMAngle {lvalue})

cutgroup()

cutGroup( (SelectorMAngle)arg1, (int)i [, (PropertyMap)map={}]) -> CutGroup :

C++ signature :

SireMol::CutGroup cutGroup(SireMM::SelectorMAngle {lvalue},int [,SireBase::PropertyMap={}])

cutGroup( (SelectorMAngle)arg1, (object)name [, (PropertyMap)map={}]) -> CutGroup :

C++ signature :

SireMol::CutGroup cutGroup(SireMM::SelectorMAngle {lvalue},QString [,SireBase::PropertyMap={}])

cutGroup( (SelectorMAngle)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> CutGroup :

C++ signature :

SireMol::CutGroup cutGroup(SireMM::SelectorMAngle {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutgroups()

cutGroups( (SelectorMAngle)arg1) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMAngle {lvalue})

cutGroups( (SelectorMAngle)arg1, (int)i [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMAngle {lvalue},int [,SireBase::PropertyMap={}])

cutGroups( (SelectorMAngle)arg1, (object)slice [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMAngle {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

cutGroups( (SelectorMAngle)arg1, (object)idxs [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMAngle {lvalue},QList<long long> [,SireBase::PropertyMap={}])

cutGroups( (SelectorMAngle)arg1, (object)name [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMAngle {lvalue},QString [,SireBase::PropertyMap={}])

cutGroups( (SelectorMAngle)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMAngle {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

delete_all_frames()

deleteAllFrames( (SelectorMAngle)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMM::SelectorMAngle {lvalue})

deleteAllFrames( (SelectorMAngle)arg1, (PropertyMap)map) -> None :

C++ signature :

void deleteAllFrames(SireMM::SelectorMAngle {lvalue},SireBase::PropertyMap)

delete_frame()

deleteFrame( (SelectorMAngle)arg1, (int)frame) -> None :

C++ signature :

void deleteFrame(SireMM::SelectorMAngle {lvalue},int)

deleteFrame( (SelectorMAngle)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void deleteFrame(SireMM::SelectorMAngle {lvalue},int,SireBase::PropertyMap)

dynamics(cutoff=None, cutoff_type=None, timestep=None, save_frequency=None, energy_frequency=None, frame_frequency=None, save_velocities=None, constraint=None, perturbable_constraint=None, include_constrained_energies: bool = True, integrator=None, schedule=None, lambda_value=None, swap_end_states=None, ignore_perturbations=None, temperature=None, pressure=None, rest2_scale=None, rest2_selection=None, vacuum=None, shift_delta=None, shift_coulomb=None, coulomb_power=None, restraints=None, fixed=None, platform=None, device=None, precision=None, com_reset_frequency=None, barostat_frequency=None, dynamic_constraints: bool = True, qm_engine=None, lambda_interpolate=None, map=None)

Return a Dynamics object that can be used to perform dynamics of the molecule(s) in this view

cutoff: Length

The size of the non-bonded cutoff

cutoff_type: str

The type of cutoff to use, e.g. “PME”, “RF” etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options

timestep: time

The size of the dynamics timestep

save_frequency: time

The amount of simulation time between saving energies and frames. This can be overridden using energy_frequency or frame_frequency, or by these options in individual dynamics runs. Set this to zero if you don’t want any saves.

energy_frequency: time

The amount of time between saving energies. This overrides the value in save_frequency. Set this to zero if you don’t want to save energies during the trajectory. This can be overridden by setting energy_frequency during an individual run.

frame_frequency: time

The amount of time between saving frames. This overrides the value in save_frequency. Set this to zero if you don’t want to save frames during the trajectory. This can be overridden by setting frame_frequency during an individual run.

save_velocities: bool

Whether or not to save velocities when saving trajectory frames during the simulation. This defaults to False, as velocity trajectories aren’t often needed, and they double the amount of space that is required for a trajectory.

constraint: str

The type of constraint to use for bonds and/or angles, e.g. h-bonds, bonds etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This will be automatically guessed from the timestep if it isn’t set.

perturbable_constraint: str

The type of constraint to use for perturbable bonds and/or angles, e.g. h-bonds, bonds etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This equal the value of constraint if it isn’t set.

include_constrained_energies: bool

Whether or not to include the energies of the constrained bonds and angles. If this is False, then the internal bond or angle energy of the constrained degrees of freedom are not included in the total energy, and their forces are not evaluated.

integrator: str

The type of integrator to use, e.g. langevin, verlet etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This will be automatically set to langevin_middle (NVT/NPT) or verlet (NVE) depending on the ensemble if this is not set (or is set to auto)

schedule: sire.cas.LambdaSchedule

The schedule used to control how perturbable forcefield parameters should be morphed as a function of lambda. If this is not set then a sire.cas.LambdaSchedule.standard_morph() is used.

lambda_value: float

The value of lambda at which to run dynamics. This only impacts perturbable molecules, whose forcefield parameters will be scaled according to the lambda schedule for the specified value of lambda.

swap_end_states: bool

Whether or not to swap the end states. If this is True, then the perturbation will run from the perturbed back to the reference molecule (the perturbed molecule will be at lambda=0, while the reference molecule will be at lambda=1). This will use the coordinates of the perturbed molecule as the starting point.

ignore_perturbations: bool

Whether or not to ignore perturbations. If this is True, then the perturbation will be ignored, and the simulation will be run using the properties of the reference molecule (or the perturbed molecule if swap_end_states is True). This is useful if you just want to run standard molecular dynamics of the reference or perturbed states.

temperature: temperature

The temperature at which to run the simulation. A microcanonical (NVE) simulation will be run if you don’t specify the temperature.

pressure: pressure

The pressure at which to run the simulation. A microcanonical (NVE) or canonical (NVT) simulation will be run if the pressure is not set.

rest2_scale: float

The scaling factor to apply when running a REST2 simulation (Replica Exchange with Solute Tempering). This defaults to 1.0. This specifies the ratio of the temperature of the REST2 region to the temperature of the rest of the system.

rest2_selection: str

A selection string for atoms to include in the REST2 region in addition to any perturbable molecules. For example, “molidx 0 and residx 0,1,2” would select atoms from the first three residues of the first molecule. If None, then all atoms within perturbable molecules will be included in the REST2 region. When atoms within a perturbable molecule are also included in the selection, then only those atoms will be considered as part of the REST2 region. This allows REST2 to be applied to protein mutations.

A selection string for atoms to include in the REST2 region in addition to the perturbable molecule. For example, “molidx 0 and residx 0,1,2” would select atoms from the first three residues of the first molecule. Selected atoms should be within the same molecule. If None, then only the perturbable molecule will be used for the REST2 region.

vacuum: bool (optional)

Whether or not to run the simulation in vacuum. If this is set to True, then the simulation space automatically be replaced by a sire.vol.Cartesian space, and the simulation run in vacuum.

shift_delta: length

The shift_delta parameter that controls the Lennard-Jones softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 2.0 A.

shift_coulomb: length

The shift_coulomb parameter that controls the electrostatic softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 1.0 A.

coulomb_power: int

The coulomb power parmeter that controls the electrostatic softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 0.

restraints: sire.mm.Restraints or list[sire.mm.Restraints]

A single set of restraints, or a list of sets of restraints that will be applied to the atoms during the simulation.

fixed: molecule(s) view, search string, int, list[int] etc

Anything that can be used to identify the atom or atoms that should be fixed in place during the simulation. These atoms will not be moved by dynamics.

platform: str

The name of the OpenMM platform on which to run the dynamics, e.g. “CUDA”, “OpenCL”, “Metal” etc.

device: str or int

The ID of the GPU (or accelerator) used to accelerate the simulation. This would be CUDA_DEVICE_ID or similar if CUDA was used. This can be any valid OpenMM device string

precision: str

The desired precision for the simulation (e.g. single, mixed or double)

com_reset_frequency:

Either the number of steps between center-of-mass resets, or the time between resets. If this is unset, then the center-of-mass is not reset during the simulation.

barostat_frequency:

Either the number of steps between MC moves to apply the barostat, of the time between moves. If this is unset, then the default of every 25 steps is used.

dynamic_constraints: bool

Whether or not to update the length of constraints of perturbable bonds with lambda. This defaults to True, meaning that changing lambda will change any constraint on a perturbable bond to equal to the value of r0 at that lambda value. If this is false, then the constraint is set based on the current length.

qm_engine:

A sire.qm.QMMMEngine object to used to compute QM/MM forces and energies on a subset of the atoms in the system.

lambda_interpolate: float

The lambda value at which to interpolate the QM/MM forces and energies, which can be used to perform end-state correction simulations. A value of 1.0 is full QM, whereas a value of 0.0 is full MM. If two values are specified, then lambda will be linearly interpolated between the two values over the course of the simulation, which lambda updated at the energy_frequency.

map: dict

A dictionary of additional options. Note that any options set in this dictionary that are also specified via one of the arguments above will be overridden by the argument value

energies((SelectorMAngle)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::GeneralUnit> energies(SireMM::SelectorMAngle {lvalue})

energies( (SelectorMAngle)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::GeneralUnit> energies(SireMM::SelectorMAngle {lvalue},SireBase::PropertyMap)

energy((SelectorMAngle)arg1) → GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::SelectorMAngle {lvalue})

energy( (SelectorMAngle)arg1, (PropertyMap)map) -> GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::SelectorMAngle {lvalue},SireBase::PropertyMap)

evaluate((SelectorMAngle)arg1) → EvaluatorM :

C++ signature :

SireMol::EvaluatorM evaluate(SireMM::SelectorMAngle {lvalue})

extract((SelectorMAngle)arg1) → SelectorMol :

C++ signature :

SireMol::SelectorMol extract(SireMM::SelectorMAngle {lvalue})

has_metadata()

hasMetadata( (SelectorMAngle)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasMetadata(SireMM::SelectorMAngle {lvalue},SireBase::PropertyName)

hasMetadata( (SelectorMAngle)arg1, (PropertyName)key, (PropertyName)metakey) -> bool :

C++ signature :

bool hasMetadata(SireMM::SelectorMAngle {lvalue},SireBase::PropertyName,SireBase::PropertyName)

has_property()

hasProperty( (SelectorMAngle)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasProperty(SireMM::SelectorMAngle {lvalue},SireBase::PropertyName)

ids()

IDs( (SelectorMAngle)arg1) -> object :

C++ signature :

QList<SireMol::AngleID> IDs(SireMM::SelectorMAngle {lvalue})

intersection((SelectorMAngle)arg1, (SelectorMAngle)other) → SelectorMAngle :

C++ signature :

SireMM::SelectorMAngle intersection(SireMM::SelectorMAngle {lvalue},SireMM::SelectorMAngle)

invert((SelectorMAngle)arg1[, (PropertyMap)map]) → SelectorMAngle :

C++ signature :

SireMM::SelectorMAngle invert(SireMM::SelectorMAngle {lvalue} [,SireBase::PropertyMap])

is_empty()

isEmpty( (SelectorMAngle)arg1) -> bool :

C++ signature :

bool isEmpty(SireMM::SelectorMAngle {lvalue})

is_selector()

isSelector( (SelectorMAngle)arg1) -> bool :

C++ signature :

bool isSelector(SireMM::SelectorMAngle {lvalue})

load_frame()

loadFrame( (SelectorMAngle)arg1, (int)frame) -> None :

C++ signature :

void loadFrame(SireMM::SelectorMAngle {lvalue},int)

loadFrame( (SelectorMAngle)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMM::SelectorMAngle {lvalue},int,SireBase::PropertyMap)

measures((SelectorMAngle)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> measures(SireMM::SelectorMAngle {lvalue})

measures( (SelectorMAngle)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> measures(SireMM::SelectorMAngle {lvalue},SireBase::PropertyMap)

metadata_keys()

metadataKeys( (SelectorMAngle)arg1) -> object :

C++ signature :

QStringList metadataKeys(SireMM::SelectorMAngle {lvalue})

metadataKeys( (SelectorMAngle)arg1, (PropertyName)key) -> object :

C++ signature :

QStringList metadataKeys(SireMM::SelectorMAngle {lvalue},SireBase::PropertyName)

minimisation(cutoff=None, cutoff_type=None, constraint=None, perturbable_constraint=None, include_constrained_energies: bool = True, schedule=None, lambda_value=None, swap_end_states=None, ignore_perturbations=None, vacuum=None, shift_delta=None, shift_coulomb=None, coulomb_power=None, platform=None, device=None, precision=None, restraints=None, fixed=None, dynamic_constraints: bool = True, map=None)

Return a Minimisation object that can be used to perform minimisation of the molecule(s) in this view

cutoff: Length

The size of the non-bonded cutoff

cutoff_type: str

The type of cutoff to use, e.g. “PME”, “RF” etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options

constraint: str

The type of constraint to use for bonds and/or angles, e.g. h-bonds, bonds etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This is none if it is not set.

perturbable_constraint: str

The type of constraint to use for perturbable bonds and/or angles, e.g. h-bonds, bonds etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This equal the value of constraint if it isn’t set.

include_constrained_energies: bool

Whether or not to include the energies of the perturbable bonds and angles. If this is False, then the internal bond or angle energy of the perturbable degrees of freedom are not included in the total energy, and their forces are not evaluated.

schedule: sire.cas.LambdaSchedule

The schedule used to control how perturbable forcefield parameters should be morphed as a function of lambda. If this is not set then a sire.cas.LambdaSchedule.standard_morph() is used.

lambda_value: float

The value of lambda at which to run minimisation. This only impacts perturbable molecules, whose forcefield parameters will be scaled according to the lambda schedule for the specified value of lambda.

swap_end_states: bool

Whether or not to swap the end states. If this is True, then the perturbation will run from the perturbed back to the reference molecule (the perturbed molecule will be at lambda=0, while the reference molecule will be at lambda=1). This will use the coordinates of the perturbed molecule as the starting point.

ignore_perturbations: bool

Whether or not to ignore perturbations. If this is True, then the perturbation will be ignored, and the simulation will be run using the properties of the reference molecule (or the perturbed molecule if swap_end_states is True). This is useful if you just want to run standard molecular dynamics of the reference or perturbed states.

vacuum: bool (optional)

Whether or not to run the simulation in vacuum. If this is set to True, then the simulation space automatically be replaced by a sire.vol.Cartesian space, and the simulation run in vacuum.

shift_delta: length

The shift_delta parameter that controls the Lennard-Jones softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 2.0 A.

shift_coulomb: length

The shift_coulomb parameter that controls the electrostatic softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 1.0 A.

coulomb_power: int

The coulomb power parmeter that controls the electrostatic softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 0.

restraints: sire.mm.Restraints or list[sire.mm.Restraints]

A single set of restraints, or a list of sets of restraints that will be applied to the atoms during the simulation.

fixed: molecule(s) view, search string, int, list[int] etc

Anything that can be used to identify the atom or atoms that should be fixed in place during the simulation. These atoms will not be moved by minimisation.

platform: str

The name of the OpenMM platform on which to run the dynamics, e.g. “CUDA”, “OpenCL”, “Metal” etc.

device: str or int

The ID of the GPU (or accelerator) used to accelerate minimisation. This would be CUDA_DEVICE_ID or similar if CUDA was used. This can be any valid OpenMM device string

precision: str

The desired precision for the simulation (e.g. single, mixed or double)

dynamic_constraints: bool

Whether or not to update the length of constraints of perturbable bonds with lambda. This defaults to True, meaning that changing lambda will change any constraint on a perturbable bond to equal to the value of r0 at that lambda value. If this is false, then the constraint is set based on the current length.

map: dict

A dictionary of additional options. Note that any options set in this dictionary that are also specified via one of the arguments above will be overridden by the argument value

molecule((SelectorMAngle)arg1, (int)i[, (PropertyMap)map={}]) → Molecule :

C++ signature :

SireMol::Molecule molecule(SireMM::SelectorMAngle {lvalue},int [,SireBase::PropertyMap={}])

molecule( (SelectorMAngle)arg1, (object)name [, (PropertyMap)map={}]) -> Molecule :

C++ signature :

SireMol::Molecule molecule(SireMM::SelectorMAngle {lvalue},QString [,SireBase::PropertyMap={}])

molecule( (SelectorMAngle)arg1, (MolID)molid [, (PropertyMap)map={}]) -> Molecule :

C++ signature :

SireMol::Molecule molecule(SireMM::SelectorMAngle {lvalue},SireMol::MolID [,SireBase::PropertyMap={}])

num_atoms()

nAtoms( (SelectorMAngle)arg1) -> int :

C++ signature :

int nAtoms(SireMM::SelectorMAngle {lvalue})

num_chains()

nChains( (SelectorMAngle)arg1) -> int :

C++ signature :

int nChains(SireMM::SelectorMAngle {lvalue})

num_cutgroups()

nCutGroups( (SelectorMAngle)arg1) -> int :

C++ signature :

int nCutGroups(SireMM::SelectorMAngle {lvalue})

num_frames()

nFrames( (SelectorMAngle)arg1) -> int :

C++ signature :

int nFrames(SireMM::SelectorMAngle {lvalue})

nFrames( (SelectorMAngle)arg1, (PropertyMap)map) -> int :

C++ signature :

int nFrames(SireMM::SelectorMAngle {lvalue},SireBase::PropertyMap)

num_molecules()

nMolecules( (SelectorMAngle)arg1) -> int :

C++ signature :

int nMolecules(SireMM::SelectorMAngle {lvalue})

num_residues()

nResidues( (SelectorMAngle)arg1) -> int :

C++ signature :

int nResidues(SireMM::SelectorMAngle {lvalue})

num_segments()

nSegments( (SelectorMAngle)arg1) -> int :

C++ signature :

int nSegments(SireMM::SelectorMAngle {lvalue})

potentials((SelectorMAngle)arg1) → object :

C++ signature :

QList<SireCAS::Expression> potentials(SireMM::SelectorMAngle {lvalue})

potentials( (SelectorMAngle)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireCAS::Expression> potentials(SireMM::SelectorMAngle {lvalue},SireBase::PropertyMap)

properties((SelectorMAngle)arg1) → object :

C++ signature :

QList<SireBase::Properties> properties(SireMM::SelectorMAngle {lvalue})

property_keys()

propertyKeys( (SelectorMAngle)arg1) -> object :

C++ signature :

QStringList propertyKeys(SireMM::SelectorMAngle {lvalue})

residue((SelectorMAngle)arg1, (int)i[, (PropertyMap)map={}]) → Residue :

C++ signature :

SireMol::Residue residue(SireMM::SelectorMAngle {lvalue},int [,SireBase::PropertyMap={}])

residue( (SelectorMAngle)arg1, (object)name [, (PropertyMap)map={}]) -> Residue :

C++ signature :

SireMol::Residue residue(SireMM::SelectorMAngle {lvalue},QString [,SireBase::PropertyMap={}])

residue( (SelectorMAngle)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Residue :

C++ signature :

SireMol::Residue residue(SireMM::SelectorMAngle {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

save_frame()

saveFrame( (SelectorMAngle)arg1 [, (int)frame]) -> None :

C++ signature :

void saveFrame(SireMM::SelectorMAngle {lvalue} [,int])

saveFrame( (SelectorMAngle)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMM::SelectorMAngle {lvalue},int,SireBase::PropertyMap)

saveFrame( (SelectorMAngle)arg1, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMM::SelectorMAngle {lvalue},SireBase::PropertyMap)

search((SelectorMAngle)arg1, (object)search_string) → SelectResult :

C++ signature :

SireMol::SelectResult search(SireMM::SelectorMAngle {lvalue},QString)

search( (SelectorMAngle)arg1, (object)search_string, (PropertyMap)map) -> SelectResult :

C++ signature :

SireMol::SelectResult search(SireMM::SelectorMAngle {lvalue},QString,SireBase::PropertyMap)

segment((SelectorMAngle)arg1, (int)i[, (PropertyMap)map={}]) → Segment :

C++ signature :

SireMol::Segment segment(SireMM::SelectorMAngle {lvalue},int [,SireBase::PropertyMap={}])

segment( (SelectorMAngle)arg1, (object)name [, (PropertyMap)map={}]) -> Segment :

C++ signature :

SireMol::Segment segment(SireMM::SelectorMAngle {lvalue},QString [,SireBase::PropertyMap={}])

segment( (SelectorMAngle)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Segment :

C++ signature :

SireMol::Segment segment(SireMM::SelectorMAngle {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

size()

__len__( (SelectorMAngle)arg1) -> int :

C++ signature :

unsigned long __len__(SireMM::SelectorMAngle {lvalue})

sizes((SelectorMAngle)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> sizes(SireMM::SelectorMAngle {lvalue})

sizes( (SelectorMAngle)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> sizes(SireMM::SelectorMAngle {lvalue},SireBase::PropertyMap)

smarts(as_search: bool = False, include_hydrogens: bool = False, map=None)

Return the molecule views in this container as smarts strings. Include hydrogens if ‘include_hydrogens’ is True. This returns a list of smarts strings, in the same order as the views in the container.

If ‘as_search’ is True then the smarts string is returned as a sire search string.

smiles(as_search: bool = True, include_hydrogens: bool = False, map=None)

Return the molecule views in this container as smiles strings. Include hydrogens if ‘include_hydrogens’ is True. This returns a list of smiles strings, in the same order as the views in the container.

If ‘as_search’ is True, then this returns the sire search smiles string

to_list()

toList( (SelectorMAngle)arg1) -> object :

C++ signature :

QList<SireBase::PropPtr<SireMol::MoleculeView>> toList(SireMM::SelectorMAngle {lvalue})

to_molecule_group()

toMoleculeGroup( (SelectorMAngle)arg1) -> MoleculeGroup :

C++ signature :

SireMol::MoleculeGroup toMoleculeGroup(SireMM::SelectorMAngle {lvalue})

to_molecules()

toMolecules( (SelectorMAngle)arg1) -> Molecules :

C++ signature :

SireMol::Molecules toMolecules(SireMM::SelectorMAngle {lvalue})

to_select_result()

toSelectResult( (SelectorMAngle)arg1) -> SelectResult :

C++ signature :

SireMol::SelectResult toSelectResult(SireMM::SelectorMAngle {lvalue})

to_string()

toString( (SelectorMAngle)arg1) -> object :

C++ signature :

QString toString(SireMM::SelectorMAngle {lvalue})

trajectory(align=None, smooth=None, wrap=None, mapping=None, frame=None, map=None)

Return an iterator over the trajectory of frames of this view.

align:

Pass in a selection string to select atoms against which every frame will be aligned. These atoms will be moved to the center of the periodic box (if a periodic box is used). If “True” is passed, then this will attempt to align ALL of the coordinates in the view.

You can also choose to pass in a molecular container, and it will align against the atoms in that container, assuming they are contained in this view. If not, then you need to supply a mapping that maps from the atoms in the align container, to the atoms in this view.

frame:

The frame of the trajectory against which the alignment should be based. For example, frame=3 would align based on the coordinates of the aligned atoms in frame 3 of the trajectory. If this is None (the default) then the first frame will be used.

mapping: AtomMapping

An AtomMapping object that maps from atoms in the alignment container to atoms in this view. You only need to supply this if all of the alignment atoms are not contained in this view.

smooth:

Pass in the number of frames to smooth (average) the view over. If ‘True’ is passed, then the recommended number of frames will be averaged over

wrap: bool

Whether or not to wrap the coordinates into the periodic box

typename()

typeName() -> str :

C++ signature :

char const* typeName()

update((SelectorMAngle)arg1, (MoleculeView)molecule) → None :

C++ signature :

void update(SireMM::SelectorMAngle {lvalue},SireMol::MoleculeView)

update( (SelectorMAngle)arg1, (MoleculeView)moldata) -> None :

C++ signature :

void update(SireMM::SelectorMAngle {lvalue},SireMol::MoleculeData)

update( (SelectorMAngle)arg1, (Molecules)molecules) -> None :

C++ signature :

void update(SireMM::SelectorMAngle {lvalue},SireMol::Molecules)

update( (SelectorMAngle)arg1, (SelectorMol)molecules) -> None :

C++ signature :

void update(SireMM::SelectorMAngle {lvalue},SireMol::SelectorMol)

view(default: bool = True, no_default: bool = False, orthographic: bool = True, protein: str = '', water: str = '', ions: str = '', rest: str = '', all: str = '', ball_and_stick: str = '', base: str = '', cartoon: str = '', hyperball: str = '', licorice: str = '', line: str = '', point: str = '', ribbon: str = '', rocket: str = '', rope: str = '', spacefill: str = '', surface: str = '', trace: str = '', tube: str = '', center: str = None, align: str = None, frame: int = None, smooth=False, wrap=True, mapping=None, bgcolor=None, stage_parameters: str = None, map=None)

Return an NGLView viewer for this view. The returned viewer can be passed directly to, e.g. a Jupyter notebook to directly view the molecule(s), or it can be captured in a variable so that it’s NGLViewer member functions can be called to edit the viewer before display.

Full instructions on how to use this view are in the cheatsheet (https://sire.openbiosim.org/cheatsheet/view)

center:

Pass in a selection string to select the atoms to center in the view. By default no atoms are centered

align:

Pass in a selection string to select atoms against which every frame will be aligned. These atoms will be moved to the center of the periodic box (if a periodic box is used). If “True” is passed, then this will attempt to align ALL of the coordinates in the view.

You can also choose to pass in a molecular container, and it will align against the atoms in that container, assuming they are contained in this view. If not, then you need to supply a mapping that maps from the atoms in the align container, to the atoms in this view.

frame:

The frame of the trajectory against which the alignment should be based. For example, frame=3 would align based on the coordinates of the aligned atoms in frame 3 of the trajectory. If this is None (the default) then the first frame will be used.

mapping: AtomMapping

An AtomMapping object that maps from atoms in the alignment container to atoms in this view. You only need to supply this if all of the alignment atoms are not contained in this view.

smooth:

Pass in the number of frames to smooth (average) the view over. If ‘True’ is passed, then the recommended number of frames will be averaged over

wrap: bool

Whether or not to wrap the coordinates into the periodic box.

orthographic:

Set to False to use a perspective view, or accept the default (True) for an orthographic view

default:

The default representation / color for the view. If this is set to False or None or “none” then default views are disabled.

no_default:

Set to False to disable all default views

protein, water, ions:

Set the default views for protein, water and ion molecules. Set to False, None or “none” to disable these default views.

rest:

Synonym for “default”, but does not disable all default views if set to None, False or “none”

all:

Set the representation for all atoms. Set to None, False or “none” to disable all views.

ball_and_stick, base, cartoon etc.

Set the selection strings for atoms that should be represented with these views.

bgcolor: str

The background color of the view. Set to ‘None’ to use the default background color (black)

stage_parameters: dict

An optional dictionary that will be passed directly to the NGLView object to set the stage parameters.

map: dict or sire.base.PropertyMap

An optional property map that can be used to control which properties are used to get the molecular data to be viewed.

class sire.mm.SelectorMBond

Multi-molecule selector for bonds

add((SelectorMBond)arg1, (SelectorMBond)other) → SelectorMBond :

C++ signature :

SireMM::SelectorMBond add(SireMM::SelectorMBond {lvalue},SireMM::SelectorMBond)

apply(func, *args, **kwargs)

Call the passed function on all views in the container, appending the result to a list of results, which is returned.

The function can be either;

1. a string containing the name of the function to call, or

2. an actual function (either a normal function or a lambda expression)

You can optionally pass in positional and keyword arguments here that will be passed to the function.

Parameters:

• objs (self) – The container itself (this is self)

• func (str or function) – The function to be called, or the name of the function to be called.

Returns:

A list of the results, with one result per view in the container.

Return type:

list

apply_reduce(func, reduction_func=None, *args, **kwargs)

Call the passed function on all views in the container, reducing the result into a single value via the ‘reduce’ function.

This is equivalent to calling

``` reduce(reduction_func, objs.apply(func, *args, **kwargs))

The function can be either;

1. a string containing the name of the function to call, or

2. an actual function (either a normal function or a lambda expression)

The reduction function should be a function that can be passed to reduce. If this isn’t passed, then it is assumed to be operator.add.

You can optionally pass in positional and keyword arguments here that will be passed to the applied function.

Parameters:

• objs (self) – The container itself (this is self)

• func (str or function) – The function to be called, or the name of the function to be called.

• reduction_func – The function used to reduce the result. This is operator.add by default.

Returns:

The reduced result

Return type:

result

assign((SelectorMBond)arg1, (SelectorMBond)other) → SelectorMBond :

C++ signature :

SireMM::SelectorMBond {lvalue} assign(SireMM::SelectorMBond {lvalue},SireMM::SelectorMBond)

chain((SelectorMBond)arg1, (int)i[, (PropertyMap)map={}]) → Chain :

C++ signature :

SireMol::Chain chain(SireMM::SelectorMBond {lvalue},int [,SireBase::PropertyMap={}])

chain( (SelectorMBond)arg1, (object)name [, (PropertyMap)map={}]) -> Chain :

C++ signature :

SireMol::Chain chain(SireMM::SelectorMBond {lvalue},QString [,SireBase::PropertyMap={}])

chain( (SelectorMBond)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Chain :

C++ signature :

SireMol::Chain chain(SireMM::SelectorMBond {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

clone((SelectorMBond)arg1) → SelectorMBond :

C++ signature :

SireMM::SelectorMBond clone(SireMM::SelectorMBond)

count()

__len__( (SelectorMBond)arg1) -> int :

C++ signature :

unsigned long __len__(SireMM::SelectorMBond {lvalue})

cutgroup()

cutGroup( (SelectorMBond)arg1, (int)i [, (PropertyMap)map={}]) -> CutGroup :

C++ signature :

SireMol::CutGroup cutGroup(SireMM::SelectorMBond {lvalue},int [,SireBase::PropertyMap={}])

cutGroup( (SelectorMBond)arg1, (object)name [, (PropertyMap)map={}]) -> CutGroup :

C++ signature :

SireMol::CutGroup cutGroup(SireMM::SelectorMBond {lvalue},QString [,SireBase::PropertyMap={}])

cutGroup( (SelectorMBond)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> CutGroup :

C++ signature :

SireMol::CutGroup cutGroup(SireMM::SelectorMBond {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutgroups()

cutGroups( (SelectorMBond)arg1) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMBond {lvalue})

cutGroups( (SelectorMBond)arg1, (int)i [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMBond {lvalue},int [,SireBase::PropertyMap={}])

cutGroups( (SelectorMBond)arg1, (object)slice [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMBond {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

cutGroups( (SelectorMBond)arg1, (object)idxs [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMBond {lvalue},QList<long long> [,SireBase::PropertyMap={}])

cutGroups( (SelectorMBond)arg1, (object)name [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMBond {lvalue},QString [,SireBase::PropertyMap={}])

cutGroups( (SelectorMBond)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMBond {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

delete_all_frames()

deleteAllFrames( (SelectorMBond)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMM::SelectorMBond {lvalue})

deleteAllFrames( (SelectorMBond)arg1, (PropertyMap)map) -> None :

C++ signature :

void deleteAllFrames(SireMM::SelectorMBond {lvalue},SireBase::PropertyMap)

delete_frame()

deleteFrame( (SelectorMBond)arg1, (int)frame) -> None :

C++ signature :

void deleteFrame(SireMM::SelectorMBond {lvalue},int)

deleteFrame( (SelectorMBond)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void deleteFrame(SireMM::SelectorMBond {lvalue},int,SireBase::PropertyMap)

dynamics(cutoff=None, cutoff_type=None, timestep=None, save_frequency=None, energy_frequency=None, frame_frequency=None, save_velocities=None, constraint=None, perturbable_constraint=None, include_constrained_energies: bool = True, integrator=None, schedule=None, lambda_value=None, swap_end_states=None, ignore_perturbations=None, temperature=None, pressure=None, rest2_scale=None, rest2_selection=None, vacuum=None, shift_delta=None, shift_coulomb=None, coulomb_power=None, restraints=None, fixed=None, platform=None, device=None, precision=None, com_reset_frequency=None, barostat_frequency=None, dynamic_constraints: bool = True, qm_engine=None, lambda_interpolate=None, map=None)

Return a Dynamics object that can be used to perform dynamics of the molecule(s) in this view

cutoff: Length

The size of the non-bonded cutoff

cutoff_type: str

The type of cutoff to use, e.g. “PME”, “RF” etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options

timestep: time

The size of the dynamics timestep

save_frequency: time

The amount of simulation time between saving energies and frames. This can be overridden using energy_frequency or frame_frequency, or by these options in individual dynamics runs. Set this to zero if you don’t want any saves.

energy_frequency: time

The amount of time between saving energies. This overrides the value in save_frequency. Set this to zero if you don’t want to save energies during the trajectory. This can be overridden by setting energy_frequency during an individual run.

frame_frequency: time

The amount of time between saving frames. This overrides the value in save_frequency. Set this to zero if you don’t want to save frames during the trajectory. This can be overridden by setting frame_frequency during an individual run.

save_velocities: bool

Whether or not to save velocities when saving trajectory frames during the simulation. This defaults to False, as velocity trajectories aren’t often needed, and they double the amount of space that is required for a trajectory.

constraint: str

The type of constraint to use for bonds and/or angles, e.g. h-bonds, bonds etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This will be automatically guessed from the timestep if it isn’t set.

perturbable_constraint: str

The type of constraint to use for perturbable bonds and/or angles, e.g. h-bonds, bonds etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This equal the value of constraint if it isn’t set.

include_constrained_energies: bool

Whether or not to include the energies of the constrained bonds and angles. If this is False, then the internal bond or angle energy of the constrained degrees of freedom are not included in the total energy, and their forces are not evaluated.

integrator: str

The type of integrator to use, e.g. langevin, verlet etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This will be automatically set to langevin_middle (NVT/NPT) or verlet (NVE) depending on the ensemble if this is not set (or is set to auto)

schedule: sire.cas.LambdaSchedule

The schedule used to control how perturbable forcefield parameters should be morphed as a function of lambda. If this is not set then a sire.cas.LambdaSchedule.standard_morph() is used.

lambda_value: float

The value of lambda at which to run dynamics. This only impacts perturbable molecules, whose forcefield parameters will be scaled according to the lambda schedule for the specified value of lambda.

swap_end_states: bool

Whether or not to swap the end states. If this is True, then the perturbation will run from the perturbed back to the reference molecule (the perturbed molecule will be at lambda=0, while the reference molecule will be at lambda=1). This will use the coordinates of the perturbed molecule as the starting point.

ignore_perturbations: bool

Whether or not to ignore perturbations. If this is True, then the perturbation will be ignored, and the simulation will be run using the properties of the reference molecule (or the perturbed molecule if swap_end_states is True). This is useful if you just want to run standard molecular dynamics of the reference or perturbed states.

temperature: temperature

The temperature at which to run the simulation. A microcanonical (NVE) simulation will be run if you don’t specify the temperature.

pressure: pressure

The pressure at which to run the simulation. A microcanonical (NVE) or canonical (NVT) simulation will be run if the pressure is not set.

rest2_scale: float

The scaling factor to apply when running a REST2 simulation (Replica Exchange with Solute Tempering). This defaults to 1.0. This specifies the ratio of the temperature of the REST2 region to the temperature of the rest of the system.

rest2_selection: str

A selection string for atoms to include in the REST2 region in addition to any perturbable molecules. For example, “molidx 0 and residx 0,1,2” would select atoms from the first three residues of the first molecule. If None, then all atoms within perturbable molecules will be included in the REST2 region. When atoms within a perturbable molecule are also included in the selection, then only those atoms will be considered as part of the REST2 region. This allows REST2 to be applied to protein mutations.

A selection string for atoms to include in the REST2 region in addition to the perturbable molecule. For example, “molidx 0 and residx 0,1,2” would select atoms from the first three residues of the first molecule. Selected atoms should be within the same molecule. If None, then only the perturbable molecule will be used for the REST2 region.

vacuum: bool (optional)

Whether or not to run the simulation in vacuum. If this is set to True, then the simulation space automatically be replaced by a sire.vol.Cartesian space, and the simulation run in vacuum.

shift_delta: length

The shift_delta parameter that controls the Lennard-Jones softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 2.0 A.

shift_coulomb: length

The shift_coulomb parameter that controls the electrostatic softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 1.0 A.

coulomb_power: int

The coulomb power parmeter that controls the electrostatic softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 0.

restraints: sire.mm.Restraints or list[sire.mm.Restraints]

A single set of restraints, or a list of sets of restraints that will be applied to the atoms during the simulation.

fixed: molecule(s) view, search string, int, list[int] etc

Anything that can be used to identify the atom or atoms that should be fixed in place during the simulation. These atoms will not be moved by dynamics.

platform: str

The name of the OpenMM platform on which to run the dynamics, e.g. “CUDA”, “OpenCL”, “Metal” etc.

device: str or int

The ID of the GPU (or accelerator) used to accelerate the simulation. This would be CUDA_DEVICE_ID or similar if CUDA was used. This can be any valid OpenMM device string

precision: str

The desired precision for the simulation (e.g. single, mixed or double)

com_reset_frequency:

Either the number of steps between center-of-mass resets, or the time between resets. If this is unset, then the center-of-mass is not reset during the simulation.

barostat_frequency:

Either the number of steps between MC moves to apply the barostat, of the time between moves. If this is unset, then the default of every 25 steps is used.

dynamic_constraints: bool

Whether or not to update the length of constraints of perturbable bonds with lambda. This defaults to True, meaning that changing lambda will change any constraint on a perturbable bond to equal to the value of r0 at that lambda value. If this is false, then the constraint is set based on the current length.

qm_engine:

A sire.qm.QMMMEngine object to used to compute QM/MM forces and energies on a subset of the atoms in the system.

lambda_interpolate: float

The lambda value at which to interpolate the QM/MM forces and energies, which can be used to perform end-state correction simulations. A value of 1.0 is full QM, whereas a value of 0.0 is full MM. If two values are specified, then lambda will be linearly interpolated between the two values over the course of the simulation, which lambda updated at the energy_frequency.

map: dict

A dictionary of additional options. Note that any options set in this dictionary that are also specified via one of the arguments above will be overridden by the argument value

energies((SelectorMBond)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::GeneralUnit> energies(SireMM::SelectorMBond {lvalue})

energies( (SelectorMBond)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::GeneralUnit> energies(SireMM::SelectorMBond {lvalue},SireBase::PropertyMap)

energy((SelectorMBond)arg1) → GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::SelectorMBond {lvalue})

energy( (SelectorMBond)arg1, (PropertyMap)map) -> GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::SelectorMBond {lvalue},SireBase::PropertyMap)

evaluate((SelectorMBond)arg1) → EvaluatorM :

C++ signature :

SireMol::EvaluatorM evaluate(SireMM::SelectorMBond {lvalue})

extract((SelectorMBond)arg1) → SelectorMol :

C++ signature :

SireMol::SelectorMol extract(SireMM::SelectorMBond {lvalue})

has_metadata()

hasMetadata( (SelectorMBond)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasMetadata(SireMM::SelectorMBond {lvalue},SireBase::PropertyName)

hasMetadata( (SelectorMBond)arg1, (PropertyName)key, (PropertyName)metakey) -> bool :

C++ signature :

bool hasMetadata(SireMM::SelectorMBond {lvalue},SireBase::PropertyName,SireBase::PropertyName)

has_property()

hasProperty( (SelectorMBond)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasProperty(SireMM::SelectorMBond {lvalue},SireBase::PropertyName)

ids()

IDs( (SelectorMBond)arg1) -> object :

C++ signature :

QList<SireMol::BondID> IDs(SireMM::SelectorMBond {lvalue})

intersection((SelectorMBond)arg1, (SelectorMBond)other) → SelectorMBond :

C++ signature :

SireMM::SelectorMBond intersection(SireMM::SelectorMBond {lvalue},SireMM::SelectorMBond)

invert((SelectorMBond)arg1[, (PropertyMap)map]) → SelectorMBond :

C++ signature :

SireMM::SelectorMBond invert(SireMM::SelectorMBond {lvalue} [,SireBase::PropertyMap])

is_empty()

isEmpty( (SelectorMBond)arg1) -> bool :

C++ signature :

bool isEmpty(SireMM::SelectorMBond {lvalue})

is_selector()

isSelector( (SelectorMBond)arg1) -> bool :

C++ signature :

bool isSelector(SireMM::SelectorMBond {lvalue})

lengths((SelectorMBond)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0>> lengths(SireMM::SelectorMBond {lvalue})

lengths( (SelectorMBond)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0>> lengths(SireMM::SelectorMBond {lvalue},SireBase::PropertyMap)

load_frame()

loadFrame( (SelectorMBond)arg1, (int)frame) -> None :

C++ signature :

void loadFrame(SireMM::SelectorMBond {lvalue},int)

loadFrame( (SelectorMBond)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMM::SelectorMBond {lvalue},int,SireBase::PropertyMap)

measures((SelectorMBond)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0>> measures(SireMM::SelectorMBond {lvalue})

measures( (SelectorMBond)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0>> measures(SireMM::SelectorMBond {lvalue},SireBase::PropertyMap)

metadata_keys()

metadataKeys( (SelectorMBond)arg1) -> object :

C++ signature :

QStringList metadataKeys(SireMM::SelectorMBond {lvalue})

metadataKeys( (SelectorMBond)arg1, (PropertyName)key) -> object :

C++ signature :

QStringList metadataKeys(SireMM::SelectorMBond {lvalue},SireBase::PropertyName)

minimisation(cutoff=None, cutoff_type=None, constraint=None, perturbable_constraint=None, include_constrained_energies: bool = True, schedule=None, lambda_value=None, swap_end_states=None, ignore_perturbations=None, vacuum=None, shift_delta=None, shift_coulomb=None, coulomb_power=None, platform=None, device=None, precision=None, restraints=None, fixed=None, dynamic_constraints: bool = True, map=None)

Return a Minimisation object that can be used to perform minimisation of the molecule(s) in this view

cutoff: Length

The size of the non-bonded cutoff

cutoff_type: str

The type of cutoff to use, e.g. “PME”, “RF” etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options

constraint: str

The type of constraint to use for bonds and/or angles, e.g. h-bonds, bonds etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This is none if it is not set.

perturbable_constraint: str

The type of constraint to use for perturbable bonds and/or angles, e.g. h-bonds, bonds etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This equal the value of constraint if it isn’t set.

include_constrained_energies: bool

Whether or not to include the energies of the perturbable bonds and angles. If this is False, then the internal bond or angle energy of the perturbable degrees of freedom are not included in the total energy, and their forces are not evaluated.

schedule: sire.cas.LambdaSchedule

The schedule used to control how perturbable forcefield parameters should be morphed as a function of lambda. If this is not set then a sire.cas.LambdaSchedule.standard_morph() is used.

lambda_value: float

The value of lambda at which to run minimisation. This only impacts perturbable molecules, whose forcefield parameters will be scaled according to the lambda schedule for the specified value of lambda.

swap_end_states: bool

Whether or not to swap the end states. If this is True, then the perturbation will run from the perturbed back to the reference molecule (the perturbed molecule will be at lambda=0, while the reference molecule will be at lambda=1). This will use the coordinates of the perturbed molecule as the starting point.

ignore_perturbations: bool

Whether or not to ignore perturbations. If this is True, then the perturbation will be ignored, and the simulation will be run using the properties of the reference molecule (or the perturbed molecule if swap_end_states is True). This is useful if you just want to run standard molecular dynamics of the reference or perturbed states.

vacuum: bool (optional)

Whether or not to run the simulation in vacuum. If this is set to True, then the simulation space automatically be replaced by a sire.vol.Cartesian space, and the simulation run in vacuum.

shift_delta: length

The shift_delta parameter that controls the Lennard-Jones softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 2.0 A.

shift_coulomb: length

The shift_coulomb parameter that controls the electrostatic softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 1.0 A.

coulomb_power: int

The coulomb power parmeter that controls the electrostatic softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 0.

restraints: sire.mm.Restraints or list[sire.mm.Restraints]

A single set of restraints, or a list of sets of restraints that will be applied to the atoms during the simulation.

fixed: molecule(s) view, search string, int, list[int] etc

Anything that can be used to identify the atom or atoms that should be fixed in place during the simulation. These atoms will not be moved by minimisation.

platform: str

The name of the OpenMM platform on which to run the dynamics, e.g. “CUDA”, “OpenCL”, “Metal” etc.

device: str or int

The ID of the GPU (or accelerator) used to accelerate minimisation. This would be CUDA_DEVICE_ID or similar if CUDA was used. This can be any valid OpenMM device string

precision: str

The desired precision for the simulation (e.g. single, mixed or double)

dynamic_constraints: bool

Whether or not to update the length of constraints of perturbable bonds with lambda. This defaults to True, meaning that changing lambda will change any constraint on a perturbable bond to equal to the value of r0 at that lambda value. If this is false, then the constraint is set based on the current length.

map: dict

A dictionary of additional options. Note that any options set in this dictionary that are also specified via one of the arguments above will be overridden by the argument value

molecule((SelectorMBond)arg1, (int)i[, (PropertyMap)map={}]) → Molecule :

C++ signature :

SireMol::Molecule molecule(SireMM::SelectorMBond {lvalue},int [,SireBase::PropertyMap={}])

molecule( (SelectorMBond)arg1, (object)name [, (PropertyMap)map={}]) -> Molecule :

C++ signature :

SireMol::Molecule molecule(SireMM::SelectorMBond {lvalue},QString [,SireBase::PropertyMap={}])

molecule( (SelectorMBond)arg1, (MolID)molid [, (PropertyMap)map={}]) -> Molecule :

C++ signature :

SireMol::Molecule molecule(SireMM::SelectorMBond {lvalue},SireMol::MolID [,SireBase::PropertyMap={}])

num_atoms()

nAtoms( (SelectorMBond)arg1) -> int :

C++ signature :

int nAtoms(SireMM::SelectorMBond {lvalue})

num_chains()

nChains( (SelectorMBond)arg1) -> int :

C++ signature :

int nChains(SireMM::SelectorMBond {lvalue})

num_cutgroups()

nCutGroups( (SelectorMBond)arg1) -> int :

C++ signature :

int nCutGroups(SireMM::SelectorMBond {lvalue})

num_frames()

nFrames( (SelectorMBond)arg1) -> int :

C++ signature :

int nFrames(SireMM::SelectorMBond {lvalue})

nFrames( (SelectorMBond)arg1, (PropertyMap)map) -> int :

C++ signature :

int nFrames(SireMM::SelectorMBond {lvalue},SireBase::PropertyMap)

num_molecules()

nMolecules( (SelectorMBond)arg1) -> int :

C++ signature :

int nMolecules(SireMM::SelectorMBond {lvalue})

num_residues()

nResidues( (SelectorMBond)arg1) -> int :

C++ signature :

int nResidues(SireMM::SelectorMBond {lvalue})

num_segments()

nSegments( (SelectorMBond)arg1) -> int :

C++ signature :

int nSegments(SireMM::SelectorMBond {lvalue})

potentials((SelectorMBond)arg1) → object :

C++ signature :

QList<SireCAS::Expression> potentials(SireMM::SelectorMBond {lvalue})

potentials( (SelectorMBond)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireCAS::Expression> potentials(SireMM::SelectorMBond {lvalue},SireBase::PropertyMap)

properties((SelectorMBond)arg1) → object :

C++ signature :

QList<SireBase::Properties> properties(SireMM::SelectorMBond {lvalue})

property_keys()

propertyKeys( (SelectorMBond)arg1) -> object :

C++ signature :

QStringList propertyKeys(SireMM::SelectorMBond {lvalue})

residue((SelectorMBond)arg1, (int)i[, (PropertyMap)map={}]) → Residue :

C++ signature :

SireMol::Residue residue(SireMM::SelectorMBond {lvalue},int [,SireBase::PropertyMap={}])

residue( (SelectorMBond)arg1, (object)name [, (PropertyMap)map={}]) -> Residue :

C++ signature :

SireMol::Residue residue(SireMM::SelectorMBond {lvalue},QString [,SireBase::PropertyMap={}])

residue( (SelectorMBond)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Residue :

C++ signature :

SireMol::Residue residue(SireMM::SelectorMBond {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

save_frame()

saveFrame( (SelectorMBond)arg1 [, (int)frame]) -> None :

C++ signature :

void saveFrame(SireMM::SelectorMBond {lvalue} [,int])

saveFrame( (SelectorMBond)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMM::SelectorMBond {lvalue},int,SireBase::PropertyMap)

saveFrame( (SelectorMBond)arg1, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMM::SelectorMBond {lvalue},SireBase::PropertyMap)

search((SelectorMBond)arg1, (object)search_string) → SelectResult :

C++ signature :

SireMol::SelectResult search(SireMM::SelectorMBond {lvalue},QString)

search( (SelectorMBond)arg1, (object)search_string, (PropertyMap)map) -> SelectResult :

C++ signature :

SireMol::SelectResult search(SireMM::SelectorMBond {lvalue},QString,SireBase::PropertyMap)

segment((SelectorMBond)arg1, (int)i[, (PropertyMap)map={}]) → Segment :

C++ signature :

SireMol::Segment segment(SireMM::SelectorMBond {lvalue},int [,SireBase::PropertyMap={}])

segment( (SelectorMBond)arg1, (object)name [, (PropertyMap)map={}]) -> Segment :

C++ signature :

SireMol::Segment segment(SireMM::SelectorMBond {lvalue},QString [,SireBase::PropertyMap={}])

segment( (SelectorMBond)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Segment :

C++ signature :

SireMol::Segment segment(SireMM::SelectorMBond {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

size()

__len__( (SelectorMBond)arg1) -> int :

C++ signature :

unsigned long __len__(SireMM::SelectorMBond {lvalue})

smarts(as_search: bool = False, include_hydrogens: bool = False, map=None)

Return the molecule views in this container as smarts strings. Include hydrogens if ‘include_hydrogens’ is True. This returns a list of smarts strings, in the same order as the views in the container.

If ‘as_search’ is True then the smarts string is returned as a sire search string.

smiles(as_search: bool = True, include_hydrogens: bool = False, map=None)

Return the molecule views in this container as smiles strings. Include hydrogens if ‘include_hydrogens’ is True. This returns a list of smiles strings, in the same order as the views in the container.

If ‘as_search’ is True, then this returns the sire search smiles string

to_list()

toList( (SelectorMBond)arg1) -> object :

C++ signature :

QList<SireBase::PropPtr<SireMol::MoleculeView>> toList(SireMM::SelectorMBond {lvalue})

to_molecule_group()

toMoleculeGroup( (SelectorMBond)arg1) -> MoleculeGroup :

C++ signature :

SireMol::MoleculeGroup toMoleculeGroup(SireMM::SelectorMBond {lvalue})

to_molecules()

toMolecules( (SelectorMBond)arg1) -> Molecules :

C++ signature :

SireMol::Molecules toMolecules(SireMM::SelectorMBond {lvalue})

to_select_result()

toSelectResult( (SelectorMBond)arg1) -> SelectResult :

C++ signature :

SireMol::SelectResult toSelectResult(SireMM::SelectorMBond {lvalue})

to_string()

toString( (SelectorMBond)arg1) -> object :

C++ signature :

QString toString(SireMM::SelectorMBond {lvalue})

trajectory(align=None, smooth=None, wrap=None, mapping=None, frame=None, map=None)

Return an iterator over the trajectory of frames of this view.

align:

Pass in a selection string to select atoms against which every frame will be aligned. These atoms will be moved to the center of the periodic box (if a periodic box is used). If “True” is passed, then this will attempt to align ALL of the coordinates in the view.

You can also choose to pass in a molecular container, and it will align against the atoms in that container, assuming they are contained in this view. If not, then you need to supply a mapping that maps from the atoms in the align container, to the atoms in this view.

frame:

The frame of the trajectory against which the alignment should be based. For example, frame=3 would align based on the coordinates of the aligned atoms in frame 3 of the trajectory. If this is None (the default) then the first frame will be used.

mapping: AtomMapping

An AtomMapping object that maps from atoms in the alignment container to atoms in this view. You only need to supply this if all of the alignment atoms are not contained in this view.

smooth:

Pass in the number of frames to smooth (average) the view over. If ‘True’ is passed, then the recommended number of frames will be averaged over

wrap: bool

Whether or not to wrap the coordinates into the periodic box

typename()

typeName() -> str :

C++ signature :

char const* typeName()

update((SelectorMBond)arg1, (MoleculeView)molecule) → None :

C++ signature :

void update(SireMM::SelectorMBond {lvalue},SireMol::MoleculeView)

update( (SelectorMBond)arg1, (MoleculeView)moldata) -> None :

C++ signature :

void update(SireMM::SelectorMBond {lvalue},SireMol::MoleculeData)

update( (SelectorMBond)arg1, (Molecules)molecules) -> None :

C++ signature :

void update(SireMM::SelectorMBond {lvalue},SireMol::Molecules)

update( (SelectorMBond)arg1, (SelectorMol)molecules) -> None :

C++ signature :

void update(SireMM::SelectorMBond {lvalue},SireMol::SelectorMol)

view(default: bool = True, no_default: bool = False, orthographic: bool = True, protein: str = '', water: str = '', ions: str = '', rest: str = '', all: str = '', ball_and_stick: str = '', base: str = '', cartoon: str = '', hyperball: str = '', licorice: str = '', line: str = '', point: str = '', ribbon: str = '', rocket: str = '', rope: str = '', spacefill: str = '', surface: str = '', trace: str = '', tube: str = '', center: str = None, align: str = None, frame: int = None, smooth=False, wrap=True, mapping=None, bgcolor=None, stage_parameters: str = None, map=None)

Return an NGLView viewer for this view. The returned viewer can be passed directly to, e.g. a Jupyter notebook to directly view the molecule(s), or it can be captured in a variable so that it’s NGLViewer member functions can be called to edit the viewer before display.

Full instructions on how to use this view are in the cheatsheet (https://sire.openbiosim.org/cheatsheet/view)

center:

Pass in a selection string to select the atoms to center in the view. By default no atoms are centered

align:

Pass in a selection string to select atoms against which every frame will be aligned. These atoms will be moved to the center of the periodic box (if a periodic box is used). If “True” is passed, then this will attempt to align ALL of the coordinates in the view.

You can also choose to pass in a molecular container, and it will align against the atoms in that container, assuming they are contained in this view. If not, then you need to supply a mapping that maps from the atoms in the align container, to the atoms in this view.

frame:

The frame of the trajectory against which the alignment should be based. For example, frame=3 would align based on the coordinates of the aligned atoms in frame 3 of the trajectory. If this is None (the default) then the first frame will be used.

mapping: AtomMapping

An AtomMapping object that maps from atoms in the alignment container to atoms in this view. You only need to supply this if all of the alignment atoms are not contained in this view.

smooth:

Pass in the number of frames to smooth (average) the view over. If ‘True’ is passed, then the recommended number of frames will be averaged over

wrap: bool

Whether or not to wrap the coordinates into the periodic box.

orthographic:

Set to False to use a perspective view, or accept the default (True) for an orthographic view

default:

The default representation / color for the view. If this is set to False or None or “none” then default views are disabled.

no_default:

Set to False to disable all default views

protein, water, ions:

Set the default views for protein, water and ion molecules. Set to False, None or “none” to disable these default views.

rest:

Synonym for “default”, but does not disable all default views if set to None, False or “none”

all:

Set the representation for all atoms. Set to None, False or “none” to disable all views.

ball_and_stick, base, cartoon etc.

Set the selection strings for atoms that should be represented with these views.

bgcolor: str

The background color of the view. Set to ‘None’ to use the default background color (black)

stage_parameters: dict

An optional dictionary that will be passed directly to the NGLView object to set the stage parameters.

map: dict or sire.base.PropertyMap

An optional property map that can be used to control which properties are used to get the molecular data to be viewed.

class sire.mm.SelectorMDihedral

Multi-molecule selector for dihedrals

add((SelectorMDihedral)arg1, (SelectorMDihedral)other) → SelectorMDihedral :

C++ signature :

SireMM::SelectorMDihedral add(SireMM::SelectorMDihedral {lvalue},SireMM::SelectorMDihedral)

apply(func, *args, **kwargs)

Call the passed function on all views in the container, appending the result to a list of results, which is returned.

The function can be either;

1. a string containing the name of the function to call, or

2. an actual function (either a normal function or a lambda expression)

You can optionally pass in positional and keyword arguments here that will be passed to the function.

Parameters:

• objs (self) – The container itself (this is self)

• func (str or function) – The function to be called, or the name of the function to be called.

Returns:

A list of the results, with one result per view in the container.

Return type:

list

apply_reduce(func, reduction_func=None, *args, **kwargs)

Call the passed function on all views in the container, reducing the result into a single value via the ‘reduce’ function.

This is equivalent to calling

``` reduce(reduction_func, objs.apply(func, *args, **kwargs))

The function can be either;

1. a string containing the name of the function to call, or

2. an actual function (either a normal function or a lambda expression)

The reduction function should be a function that can be passed to reduce. If this isn’t passed, then it is assumed to be operator.add.

You can optionally pass in positional and keyword arguments here that will be passed to the applied function.

Parameters:

• objs (self) – The container itself (this is self)

• func (str or function) – The function to be called, or the name of the function to be called.

• reduction_func – The function used to reduce the result. This is operator.add by default.

Returns:

The reduced result

Return type:

result

assign((SelectorMDihedral)arg1, (SelectorMDihedral)other) → SelectorMDihedral :

C++ signature :

SireMM::SelectorMDihedral {lvalue} assign(SireMM::SelectorMDihedral {lvalue},SireMM::SelectorMDihedral)

chain((SelectorMDihedral)arg1, (int)i[, (PropertyMap)map={}]) → Chain :

C++ signature :

SireMol::Chain chain(SireMM::SelectorMDihedral {lvalue},int [,SireBase::PropertyMap={}])

chain( (SelectorMDihedral)arg1, (object)name [, (PropertyMap)map={}]) -> Chain :

C++ signature :

SireMol::Chain chain(SireMM::SelectorMDihedral {lvalue},QString [,SireBase::PropertyMap={}])

chain( (SelectorMDihedral)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Chain :

C++ signature :

SireMol::Chain chain(SireMM::SelectorMDihedral {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

clone((SelectorMDihedral)arg1) → SelectorMDihedral :

C++ signature :

SireMM::SelectorMDihedral clone(SireMM::SelectorMDihedral)

count()

__len__( (SelectorMDihedral)arg1) -> int :

C++ signature :

unsigned long __len__(SireMM::SelectorMDihedral {lvalue})

cutgroup()

cutGroup( (SelectorMDihedral)arg1, (int)i [, (PropertyMap)map={}]) -> CutGroup :

C++ signature :

SireMol::CutGroup cutGroup(SireMM::SelectorMDihedral {lvalue},int [,SireBase::PropertyMap={}])

cutGroup( (SelectorMDihedral)arg1, (object)name [, (PropertyMap)map={}]) -> CutGroup :

C++ signature :

SireMol::CutGroup cutGroup(SireMM::SelectorMDihedral {lvalue},QString [,SireBase::PropertyMap={}])

cutGroup( (SelectorMDihedral)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> CutGroup :

C++ signature :

SireMol::CutGroup cutGroup(SireMM::SelectorMDihedral {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutgroups()

cutGroups( (SelectorMDihedral)arg1) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMDihedral {lvalue})

cutGroups( (SelectorMDihedral)arg1, (int)i [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMDihedral {lvalue},int [,SireBase::PropertyMap={}])

cutGroups( (SelectorMDihedral)arg1, (object)slice [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMDihedral {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

cutGroups( (SelectorMDihedral)arg1, (object)idxs [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMDihedral {lvalue},QList<long long> [,SireBase::PropertyMap={}])

cutGroups( (SelectorMDihedral)arg1, (object)name [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMDihedral {lvalue},QString [,SireBase::PropertyMap={}])

cutGroups( (SelectorMDihedral)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMDihedral {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

delete_all_frames()

deleteAllFrames( (SelectorMDihedral)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMM::SelectorMDihedral {lvalue})

deleteAllFrames( (SelectorMDihedral)arg1, (PropertyMap)map) -> None :

C++ signature :

void deleteAllFrames(SireMM::SelectorMDihedral {lvalue},SireBase::PropertyMap)

delete_frame()

deleteFrame( (SelectorMDihedral)arg1, (int)frame) -> None :

C++ signature :

void deleteFrame(SireMM::SelectorMDihedral {lvalue},int)

deleteFrame( (SelectorMDihedral)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void deleteFrame(SireMM::SelectorMDihedral {lvalue},int,SireBase::PropertyMap)

dynamics(cutoff=None, cutoff_type=None, timestep=None, save_frequency=None, energy_frequency=None, frame_frequency=None, save_velocities=None, constraint=None, perturbable_constraint=None, include_constrained_energies: bool = True, integrator=None, schedule=None, lambda_value=None, swap_end_states=None, ignore_perturbations=None, temperature=None, pressure=None, rest2_scale=None, rest2_selection=None, vacuum=None, shift_delta=None, shift_coulomb=None, coulomb_power=None, restraints=None, fixed=None, platform=None, device=None, precision=None, com_reset_frequency=None, barostat_frequency=None, dynamic_constraints: bool = True, qm_engine=None, lambda_interpolate=None, map=None)

Return a Dynamics object that can be used to perform dynamics of the molecule(s) in this view

cutoff: Length

The size of the non-bonded cutoff

cutoff_type: str

The type of cutoff to use, e.g. “PME”, “RF” etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options

timestep: time

The size of the dynamics timestep

save_frequency: time

The amount of simulation time between saving energies and frames. This can be overridden using energy_frequency or frame_frequency, or by these options in individual dynamics runs. Set this to zero if you don’t want any saves.

energy_frequency: time

The amount of time between saving energies. This overrides the value in save_frequency. Set this to zero if you don’t want to save energies during the trajectory. This can be overridden by setting energy_frequency during an individual run.

frame_frequency: time

The amount of time between saving frames. This overrides the value in save_frequency. Set this to zero if you don’t want to save frames during the trajectory. This can be overridden by setting frame_frequency during an individual run.

save_velocities: bool

Whether or not to save velocities when saving trajectory frames during the simulation. This defaults to False, as velocity trajectories aren’t often needed, and they double the amount of space that is required for a trajectory.

constraint: str

The type of constraint to use for bonds and/or angles, e.g. h-bonds, bonds etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This will be automatically guessed from the timestep if it isn’t set.

perturbable_constraint: str

The type of constraint to use for perturbable bonds and/or angles, e.g. h-bonds, bonds etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This equal the value of constraint if it isn’t set.

include_constrained_energies: bool

Whether or not to include the energies of the constrained bonds and angles. If this is False, then the internal bond or angle energy of the constrained degrees of freedom are not included in the total energy, and their forces are not evaluated.

integrator: str

The type of integrator to use, e.g. langevin, verlet etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This will be automatically set to langevin_middle (NVT/NPT) or verlet (NVE) depending on the ensemble if this is not set (or is set to auto)

schedule: sire.cas.LambdaSchedule

The schedule used to control how perturbable forcefield parameters should be morphed as a function of lambda. If this is not set then a sire.cas.LambdaSchedule.standard_morph() is used.

lambda_value: float

The value of lambda at which to run dynamics. This only impacts perturbable molecules, whose forcefield parameters will be scaled according to the lambda schedule for the specified value of lambda.

swap_end_states: bool

Whether or not to swap the end states. If this is True, then the perturbation will run from the perturbed back to the reference molecule (the perturbed molecule will be at lambda=0, while the reference molecule will be at lambda=1). This will use the coordinates of the perturbed molecule as the starting point.

ignore_perturbations: bool

Whether or not to ignore perturbations. If this is True, then the perturbation will be ignored, and the simulation will be run using the properties of the reference molecule (or the perturbed molecule if swap_end_states is True). This is useful if you just want to run standard molecular dynamics of the reference or perturbed states.

temperature: temperature

The temperature at which to run the simulation. A microcanonical (NVE) simulation will be run if you don’t specify the temperature.

pressure: pressure

The pressure at which to run the simulation. A microcanonical (NVE) or canonical (NVT) simulation will be run if the pressure is not set.

rest2_scale: float

The scaling factor to apply when running a REST2 simulation (Replica Exchange with Solute Tempering). This defaults to 1.0. This specifies the ratio of the temperature of the REST2 region to the temperature of the rest of the system.

rest2_selection: str

A selection string for atoms to include in the REST2 region in addition to any perturbable molecules. For example, “molidx 0 and residx 0,1,2” would select atoms from the first three residues of the first molecule. If None, then all atoms within perturbable molecules will be included in the REST2 region. When atoms within a perturbable molecule are also included in the selection, then only those atoms will be considered as part of the REST2 region. This allows REST2 to be applied to protein mutations.

A selection string for atoms to include in the REST2 region in addition to the perturbable molecule. For example, “molidx 0 and residx 0,1,2” would select atoms from the first three residues of the first molecule. Selected atoms should be within the same molecule. If None, then only the perturbable molecule will be used for the REST2 region.

vacuum: bool (optional)

Whether or not to run the simulation in vacuum. If this is set to True, then the simulation space automatically be replaced by a sire.vol.Cartesian space, and the simulation run in vacuum.

shift_delta: length

The shift_delta parameter that controls the Lennard-Jones softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 2.0 A.

shift_coulomb: length

The shift_coulomb parameter that controls the electrostatic softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 1.0 A.

coulomb_power: int

The coulomb power parmeter that controls the electrostatic softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 0.

restraints: sire.mm.Restraints or list[sire.mm.Restraints]

A single set of restraints, or a list of sets of restraints that will be applied to the atoms during the simulation.

fixed: molecule(s) view, search string, int, list[int] etc

Anything that can be used to identify the atom or atoms that should be fixed in place during the simulation. These atoms will not be moved by dynamics.

platform: str

The name of the OpenMM platform on which to run the dynamics, e.g. “CUDA”, “OpenCL”, “Metal” etc.

device: str or int

The ID of the GPU (or accelerator) used to accelerate the simulation. This would be CUDA_DEVICE_ID or similar if CUDA was used. This can be any valid OpenMM device string

precision: str

The desired precision for the simulation (e.g. single, mixed or double)

com_reset_frequency:

Either the number of steps between center-of-mass resets, or the time between resets. If this is unset, then the center-of-mass is not reset during the simulation.

barostat_frequency:

Either the number of steps between MC moves to apply the barostat, of the time between moves. If this is unset, then the default of every 25 steps is used.

dynamic_constraints: bool

Whether or not to update the length of constraints of perturbable bonds with lambda. This defaults to True, meaning that changing lambda will change any constraint on a perturbable bond to equal to the value of r0 at that lambda value. If this is false, then the constraint is set based on the current length.

qm_engine:

A sire.qm.QMMMEngine object to used to compute QM/MM forces and energies on a subset of the atoms in the system.

lambda_interpolate: float

The lambda value at which to interpolate the QM/MM forces and energies, which can be used to perform end-state correction simulations. A value of 1.0 is full QM, whereas a value of 0.0 is full MM. If two values are specified, then lambda will be linearly interpolated between the two values over the course of the simulation, which lambda updated at the energy_frequency.

map: dict

A dictionary of additional options. Note that any options set in this dictionary that are also specified via one of the arguments above will be overridden by the argument value

energies((SelectorMDihedral)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::GeneralUnit> energies(SireMM::SelectorMDihedral {lvalue})

energies( (SelectorMDihedral)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::GeneralUnit> energies(SireMM::SelectorMDihedral {lvalue},SireBase::PropertyMap)

energy((SelectorMDihedral)arg1) → GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::SelectorMDihedral {lvalue})

energy( (SelectorMDihedral)arg1, (PropertyMap)map) -> GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::SelectorMDihedral {lvalue},SireBase::PropertyMap)

evaluate((SelectorMDihedral)arg1) → EvaluatorM :

C++ signature :

SireMol::EvaluatorM evaluate(SireMM::SelectorMDihedral {lvalue})

extract((SelectorMDihedral)arg1) → SelectorMol :

C++ signature :

SireMol::SelectorMol extract(SireMM::SelectorMDihedral {lvalue})

has_metadata()

hasMetadata( (SelectorMDihedral)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasMetadata(SireMM::SelectorMDihedral {lvalue},SireBase::PropertyName)

hasMetadata( (SelectorMDihedral)arg1, (PropertyName)key, (PropertyName)metakey) -> bool :

C++ signature :

bool hasMetadata(SireMM::SelectorMDihedral {lvalue},SireBase::PropertyName,SireBase::PropertyName)

has_property()

hasProperty( (SelectorMDihedral)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasProperty(SireMM::SelectorMDihedral {lvalue},SireBase::PropertyName)

ids()

IDs( (SelectorMDihedral)arg1) -> object :

C++ signature :

QList<SireMol::DihedralID> IDs(SireMM::SelectorMDihedral {lvalue})

intersection((SelectorMDihedral)arg1, (SelectorMDihedral)other) → SelectorMDihedral :

C++ signature :

SireMM::SelectorMDihedral intersection(SireMM::SelectorMDihedral {lvalue},SireMM::SelectorMDihedral)

invert((SelectorMDihedral)arg1[, (PropertyMap)map]) → SelectorMDihedral :

C++ signature :

SireMM::SelectorMDihedral invert(SireMM::SelectorMDihedral {lvalue} [,SireBase::PropertyMap])

is_empty()

isEmpty( (SelectorMDihedral)arg1) -> bool :

C++ signature :

bool isEmpty(SireMM::SelectorMDihedral {lvalue})

is_selector()

isSelector( (SelectorMDihedral)arg1) -> bool :

C++ signature :

bool isSelector(SireMM::SelectorMDihedral {lvalue})

load_frame()

loadFrame( (SelectorMDihedral)arg1, (int)frame) -> None :

C++ signature :

void loadFrame(SireMM::SelectorMDihedral {lvalue},int)

loadFrame( (SelectorMDihedral)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMM::SelectorMDihedral {lvalue},int,SireBase::PropertyMap)

measures((SelectorMDihedral)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> measures(SireMM::SelectorMDihedral {lvalue})

measures( (SelectorMDihedral)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> measures(SireMM::SelectorMDihedral {lvalue},SireBase::PropertyMap)

metadata_keys()

metadataKeys( (SelectorMDihedral)arg1) -> object :

C++ signature :

QStringList metadataKeys(SireMM::SelectorMDihedral {lvalue})

metadataKeys( (SelectorMDihedral)arg1, (PropertyName)key) -> object :

C++ signature :

QStringList metadataKeys(SireMM::SelectorMDihedral {lvalue},SireBase::PropertyName)

minimisation(cutoff=None, cutoff_type=None, constraint=None, perturbable_constraint=None, include_constrained_energies: bool = True, schedule=None, lambda_value=None, swap_end_states=None, ignore_perturbations=None, vacuum=None, shift_delta=None, shift_coulomb=None, coulomb_power=None, platform=None, device=None, precision=None, restraints=None, fixed=None, dynamic_constraints: bool = True, map=None)

Return a Minimisation object that can be used to perform minimisation of the molecule(s) in this view

cutoff: Length

The size of the non-bonded cutoff

cutoff_type: str

The type of cutoff to use, e.g. “PME”, “RF” etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options

constraint: str

The type of constraint to use for bonds and/or angles, e.g. h-bonds, bonds etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This is none if it is not set.

perturbable_constraint: str

The type of constraint to use for perturbable bonds and/or angles, e.g. h-bonds, bonds etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This equal the value of constraint if it isn’t set.

include_constrained_energies: bool

Whether or not to include the energies of the perturbable bonds and angles. If this is False, then the internal bond or angle energy of the perturbable degrees of freedom are not included in the total energy, and their forces are not evaluated.

schedule: sire.cas.LambdaSchedule

The schedule used to control how perturbable forcefield parameters should be morphed as a function of lambda. If this is not set then a sire.cas.LambdaSchedule.standard_morph() is used.

lambda_value: float

The value of lambda at which to run minimisation. This only impacts perturbable molecules, whose forcefield parameters will be scaled according to the lambda schedule for the specified value of lambda.

swap_end_states: bool

Whether or not to swap the end states. If this is True, then the perturbation will run from the perturbed back to the reference molecule (the perturbed molecule will be at lambda=0, while the reference molecule will be at lambda=1). This will use the coordinates of the perturbed molecule as the starting point.

ignore_perturbations: bool

Whether or not to ignore perturbations. If this is True, then the perturbation will be ignored, and the simulation will be run using the properties of the reference molecule (or the perturbed molecule if swap_end_states is True). This is useful if you just want to run standard molecular dynamics of the reference or perturbed states.

vacuum: bool (optional)

Whether or not to run the simulation in vacuum. If this is set to True, then the simulation space automatically be replaced by a sire.vol.Cartesian space, and the simulation run in vacuum.

shift_delta: length

The shift_delta parameter that controls the Lennard-Jones softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 2.0 A.

shift_coulomb: length

The shift_coulomb parameter that controls the electrostatic softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 1.0 A.

coulomb_power: int

The coulomb power parmeter that controls the electrostatic softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 0.

restraints: sire.mm.Restraints or list[sire.mm.Restraints]

A single set of restraints, or a list of sets of restraints that will be applied to the atoms during the simulation.

fixed: molecule(s) view, search string, int, list[int] etc

Anything that can be used to identify the atom or atoms that should be fixed in place during the simulation. These atoms will not be moved by minimisation.

platform: str

The name of the OpenMM platform on which to run the dynamics, e.g. “CUDA”, “OpenCL”, “Metal” etc.

device: str or int

The ID of the GPU (or accelerator) used to accelerate minimisation. This would be CUDA_DEVICE_ID or similar if CUDA was used. This can be any valid OpenMM device string

precision: str

The desired precision for the simulation (e.g. single, mixed or double)

dynamic_constraints: bool

Whether or not to update the length of constraints of perturbable bonds with lambda. This defaults to True, meaning that changing lambda will change any constraint on a perturbable bond to equal to the value of r0 at that lambda value. If this is false, then the constraint is set based on the current length.

map: dict

A dictionary of additional options. Note that any options set in this dictionary that are also specified via one of the arguments above will be overridden by the argument value

molecule((SelectorMDihedral)arg1, (int)i[, (PropertyMap)map={}]) → Molecule :

C++ signature :

SireMol::Molecule molecule(SireMM::SelectorMDihedral {lvalue},int [,SireBase::PropertyMap={}])

molecule( (SelectorMDihedral)arg1, (object)name [, (PropertyMap)map={}]) -> Molecule :

C++ signature :

SireMol::Molecule molecule(SireMM::SelectorMDihedral {lvalue},QString [,SireBase::PropertyMap={}])

molecule( (SelectorMDihedral)arg1, (MolID)molid [, (PropertyMap)map={}]) -> Molecule :

C++ signature :

SireMol::Molecule molecule(SireMM::SelectorMDihedral {lvalue},SireMol::MolID [,SireBase::PropertyMap={}])

num_atoms()

nAtoms( (SelectorMDihedral)arg1) -> int :

C++ signature :

int nAtoms(SireMM::SelectorMDihedral {lvalue})

num_chains()

nChains( (SelectorMDihedral)arg1) -> int :

C++ signature :

int nChains(SireMM::SelectorMDihedral {lvalue})

num_cutgroups()

nCutGroups( (SelectorMDihedral)arg1) -> int :

C++ signature :

int nCutGroups(SireMM::SelectorMDihedral {lvalue})

num_frames()

nFrames( (SelectorMDihedral)arg1) -> int :

C++ signature :

int nFrames(SireMM::SelectorMDihedral {lvalue})

nFrames( (SelectorMDihedral)arg1, (PropertyMap)map) -> int :

C++ signature :

int nFrames(SireMM::SelectorMDihedral {lvalue},SireBase::PropertyMap)

num_molecules()

nMolecules( (SelectorMDihedral)arg1) -> int :

C++ signature :

int nMolecules(SireMM::SelectorMDihedral {lvalue})

num_residues()

nResidues( (SelectorMDihedral)arg1) -> int :

C++ signature :

int nResidues(SireMM::SelectorMDihedral {lvalue})

num_segments()

nSegments( (SelectorMDihedral)arg1) -> int :

C++ signature :

int nSegments(SireMM::SelectorMDihedral {lvalue})

potentials((SelectorMDihedral)arg1) → object :

C++ signature :

QList<SireCAS::Expression> potentials(SireMM::SelectorMDihedral {lvalue})

potentials( (SelectorMDihedral)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireCAS::Expression> potentials(SireMM::SelectorMDihedral {lvalue},SireBase::PropertyMap)

properties((SelectorMDihedral)arg1) → object :

C++ signature :

QList<SireBase::Properties> properties(SireMM::SelectorMDihedral {lvalue})

property_keys()

propertyKeys( (SelectorMDihedral)arg1) -> object :

C++ signature :

QStringList propertyKeys(SireMM::SelectorMDihedral {lvalue})

residue((SelectorMDihedral)arg1, (int)i[, (PropertyMap)map={}]) → Residue :

C++ signature :

SireMol::Residue residue(SireMM::SelectorMDihedral {lvalue},int [,SireBase::PropertyMap={}])

residue( (SelectorMDihedral)arg1, (object)name [, (PropertyMap)map={}]) -> Residue :

C++ signature :

SireMol::Residue residue(SireMM::SelectorMDihedral {lvalue},QString [,SireBase::PropertyMap={}])

residue( (SelectorMDihedral)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Residue :

C++ signature :

SireMol::Residue residue(SireMM::SelectorMDihedral {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

save_frame()

saveFrame( (SelectorMDihedral)arg1 [, (int)frame]) -> None :

C++ signature :

void saveFrame(SireMM::SelectorMDihedral {lvalue} [,int])

saveFrame( (SelectorMDihedral)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMM::SelectorMDihedral {lvalue},int,SireBase::PropertyMap)

saveFrame( (SelectorMDihedral)arg1, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMM::SelectorMDihedral {lvalue},SireBase::PropertyMap)

search((SelectorMDihedral)arg1, (object)search_string) → SelectResult :

C++ signature :

SireMol::SelectResult search(SireMM::SelectorMDihedral {lvalue},QString)

search( (SelectorMDihedral)arg1, (object)search_string, (PropertyMap)map) -> SelectResult :

C++ signature :

SireMol::SelectResult search(SireMM::SelectorMDihedral {lvalue},QString,SireBase::PropertyMap)

segment((SelectorMDihedral)arg1, (int)i[, (PropertyMap)map={}]) → Segment :

C++ signature :

SireMol::Segment segment(SireMM::SelectorMDihedral {lvalue},int [,SireBase::PropertyMap={}])

segment( (SelectorMDihedral)arg1, (object)name [, (PropertyMap)map={}]) -> Segment :

C++ signature :

SireMol::Segment segment(SireMM::SelectorMDihedral {lvalue},QString [,SireBase::PropertyMap={}])

segment( (SelectorMDihedral)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Segment :

C++ signature :

SireMol::Segment segment(SireMM::SelectorMDihedral {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

size()

__len__( (SelectorMDihedral)arg1) -> int :

C++ signature :

unsigned long __len__(SireMM::SelectorMDihedral {lvalue})

sizes((SelectorMDihedral)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> sizes(SireMM::SelectorMDihedral {lvalue})

sizes( (SelectorMDihedral)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> sizes(SireMM::SelectorMDihedral {lvalue},SireBase::PropertyMap)

smarts(as_search: bool = False, include_hydrogens: bool = False, map=None)

Return the molecule views in this container as smarts strings. Include hydrogens if ‘include_hydrogens’ is True. This returns a list of smarts strings, in the same order as the views in the container.

If ‘as_search’ is True then the smarts string is returned as a sire search string.

smiles(as_search: bool = True, include_hydrogens: bool = False, map=None)

Return the molecule views in this container as smiles strings. Include hydrogens if ‘include_hydrogens’ is True. This returns a list of smiles strings, in the same order as the views in the container.

If ‘as_search’ is True, then this returns the sire search smiles string

to_list()

toList( (SelectorMDihedral)arg1) -> object :

C++ signature :

QList<SireBase::PropPtr<SireMol::MoleculeView>> toList(SireMM::SelectorMDihedral {lvalue})

to_molecule_group()

toMoleculeGroup( (SelectorMDihedral)arg1) -> MoleculeGroup :

C++ signature :

SireMol::MoleculeGroup toMoleculeGroup(SireMM::SelectorMDihedral {lvalue})

to_molecules()

toMolecules( (SelectorMDihedral)arg1) -> Molecules :

C++ signature :

SireMol::Molecules toMolecules(SireMM::SelectorMDihedral {lvalue})

to_select_result()

toSelectResult( (SelectorMDihedral)arg1) -> SelectResult :

C++ signature :

SireMol::SelectResult toSelectResult(SireMM::SelectorMDihedral {lvalue})

to_string()

toString( (SelectorMDihedral)arg1) -> object :

C++ signature :

QString toString(SireMM::SelectorMDihedral {lvalue})

trajectory(align=None, smooth=None, wrap=None, mapping=None, frame=None, map=None)

Return an iterator over the trajectory of frames of this view.

align:

Pass in a selection string to select atoms against which every frame will be aligned. These atoms will be moved to the center of the periodic box (if a periodic box is used). If “True” is passed, then this will attempt to align ALL of the coordinates in the view.

You can also choose to pass in a molecular container, and it will align against the atoms in that container, assuming they are contained in this view. If not, then you need to supply a mapping that maps from the atoms in the align container, to the atoms in this view.

frame:

The frame of the trajectory against which the alignment should be based. For example, frame=3 would align based on the coordinates of the aligned atoms in frame 3 of the trajectory. If this is None (the default) then the first frame will be used.

mapping: AtomMapping

An AtomMapping object that maps from atoms in the alignment container to atoms in this view. You only need to supply this if all of the alignment atoms are not contained in this view.

smooth:

Pass in the number of frames to smooth (average) the view over. If ‘True’ is passed, then the recommended number of frames will be averaged over

wrap: bool

Whether or not to wrap the coordinates into the periodic box

typename()

typeName() -> str :

C++ signature :

char const* typeName()

update((SelectorMDihedral)arg1, (MoleculeView)molecule) → None :

C++ signature :

void update(SireMM::SelectorMDihedral {lvalue},SireMol::MoleculeView)

update( (SelectorMDihedral)arg1, (MoleculeView)moldata) -> None :

C++ signature :

void update(SireMM::SelectorMDihedral {lvalue},SireMol::MoleculeData)

update( (SelectorMDihedral)arg1, (Molecules)molecules) -> None :

C++ signature :

void update(SireMM::SelectorMDihedral {lvalue},SireMol::Molecules)

update( (SelectorMDihedral)arg1, (SelectorMol)molecules) -> None :

C++ signature :

void update(SireMM::SelectorMDihedral {lvalue},SireMol::SelectorMol)

view(default: bool = True, no_default: bool = False, orthographic: bool = True, protein: str = '', water: str = '', ions: str = '', rest: str = '', all: str = '', ball_and_stick: str = '', base: str = '', cartoon: str = '', hyperball: str = '', licorice: str = '', line: str = '', point: str = '', ribbon: str = '', rocket: str = '', rope: str = '', spacefill: str = '', surface: str = '', trace: str = '', tube: str = '', center: str = None, align: str = None, frame: int = None, smooth=False, wrap=True, mapping=None, bgcolor=None, stage_parameters: str = None, map=None)

Return an NGLView viewer for this view. The returned viewer can be passed directly to, e.g. a Jupyter notebook to directly view the molecule(s), or it can be captured in a variable so that it’s NGLViewer member functions can be called to edit the viewer before display.

Full instructions on how to use this view are in the cheatsheet (https://sire.openbiosim.org/cheatsheet/view)

center:

Pass in a selection string to select the atoms to center in the view. By default no atoms are centered

align:

Pass in a selection string to select atoms against which every frame will be aligned. These atoms will be moved to the center of the periodic box (if a periodic box is used). If “True” is passed, then this will attempt to align ALL of the coordinates in the view.

You can also choose to pass in a molecular container, and it will align against the atoms in that container, assuming they are contained in this view. If not, then you need to supply a mapping that maps from the atoms in the align container, to the atoms in this view.

frame:

The frame of the trajectory against which the alignment should be based. For example, frame=3 would align based on the coordinates of the aligned atoms in frame 3 of the trajectory. If this is None (the default) then the first frame will be used.

mapping: AtomMapping

An AtomMapping object that maps from atoms in the alignment container to atoms in this view. You only need to supply this if all of the alignment atoms are not contained in this view.

smooth:

Pass in the number of frames to smooth (average) the view over. If ‘True’ is passed, then the recommended number of frames will be averaged over

wrap: bool

Whether or not to wrap the coordinates into the periodic box.

orthographic:

Set to False to use a perspective view, or accept the default (True) for an orthographic view

default:

The default representation / color for the view. If this is set to False or None or “none” then default views are disabled.

no_default:

Set to False to disable all default views

protein, water, ions:

Set the default views for protein, water and ion molecules. Set to False, None or “none” to disable these default views.

rest:

Synonym for “default”, but does not disable all default views if set to None, False or “none”

all:

Set the representation for all atoms. Set to None, False or “none” to disable all views.

ball_and_stick, base, cartoon etc.

Set the selection strings for atoms that should be represented with these views.

bgcolor: str

The background color of the view. Set to ‘None’ to use the default background color (black)

stage_parameters: dict

An optional dictionary that will be passed directly to the NGLView object to set the stage parameters.

map: dict or sire.base.PropertyMap

An optional property map that can be used to control which properties are used to get the molecular data to be viewed.

class sire.mm.SelectorMImproper

Multi-molecule selector for impropers

add((SelectorMImproper)arg1, (SelectorMImproper)other) → SelectorMImproper :

C++ signature :

SireMM::SelectorMImproper add(SireMM::SelectorMImproper {lvalue},SireMM::SelectorMImproper)

apply(func, *args, **kwargs)

Call the passed function on all views in the container, appending the result to a list of results, which is returned.

The function can be either;

1. a string containing the name of the function to call, or

2. an actual function (either a normal function or a lambda expression)

You can optionally pass in positional and keyword arguments here that will be passed to the function.

Parameters:

• objs (self) – The container itself (this is self)

• func (str or function) – The function to be called, or the name of the function to be called.

Returns:

A list of the results, with one result per view in the container.

Return type:

list

apply_reduce(func, reduction_func=None, *args, **kwargs)

Call the passed function on all views in the container, reducing the result into a single value via the ‘reduce’ function.

This is equivalent to calling

``` reduce(reduction_func, objs.apply(func, *args, **kwargs))

The function can be either;

1. a string containing the name of the function to call, or

2. an actual function (either a normal function or a lambda expression)

The reduction function should be a function that can be passed to reduce. If this isn’t passed, then it is assumed to be operator.add.

You can optionally pass in positional and keyword arguments here that will be passed to the applied function.

Parameters:

• objs (self) – The container itself (this is self)

• func (str or function) – The function to be called, or the name of the function to be called.

• reduction_func – The function used to reduce the result. This is operator.add by default.

Returns:

The reduced result

Return type:

result

assign((SelectorMImproper)arg1, (SelectorMImproper)other) → SelectorMImproper :

C++ signature :

SireMM::SelectorMImproper {lvalue} assign(SireMM::SelectorMImproper {lvalue},SireMM::SelectorMImproper)

chain((SelectorMImproper)arg1, (int)i[, (PropertyMap)map={}]) → Chain :

C++ signature :

SireMol::Chain chain(SireMM::SelectorMImproper {lvalue},int [,SireBase::PropertyMap={}])

chain( (SelectorMImproper)arg1, (object)name [, (PropertyMap)map={}]) -> Chain :

C++ signature :

SireMol::Chain chain(SireMM::SelectorMImproper {lvalue},QString [,SireBase::PropertyMap={}])

chain( (SelectorMImproper)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Chain :

C++ signature :

SireMol::Chain chain(SireMM::SelectorMImproper {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

clone((SelectorMImproper)arg1) → SelectorMImproper :

C++ signature :

SireMM::SelectorMImproper clone(SireMM::SelectorMImproper)

count()

__len__( (SelectorMImproper)arg1) -> int :

C++ signature :

unsigned long __len__(SireMM::SelectorMImproper {lvalue})

cutgroup()

cutGroup( (SelectorMImproper)arg1, (int)i [, (PropertyMap)map={}]) -> CutGroup :

C++ signature :

SireMol::CutGroup cutGroup(SireMM::SelectorMImproper {lvalue},int [,SireBase::PropertyMap={}])

cutGroup( (SelectorMImproper)arg1, (object)name [, (PropertyMap)map={}]) -> CutGroup :

C++ signature :

SireMol::CutGroup cutGroup(SireMM::SelectorMImproper {lvalue},QString [,SireBase::PropertyMap={}])

cutGroup( (SelectorMImproper)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> CutGroup :

C++ signature :

SireMol::CutGroup cutGroup(SireMM::SelectorMImproper {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

cutgroups()

cutGroups( (SelectorMImproper)arg1) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMImproper {lvalue})

cutGroups( (SelectorMImproper)arg1, (int)i [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMImproper {lvalue},int [,SireBase::PropertyMap={}])

cutGroups( (SelectorMImproper)arg1, (object)slice [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMImproper {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

cutGroups( (SelectorMImproper)arg1, (object)idxs [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMImproper {lvalue},QList<long long> [,SireBase::PropertyMap={}])

cutGroups( (SelectorMImproper)arg1, (object)name [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMImproper {lvalue},QString [,SireBase::PropertyMap={}])

cutGroups( (SelectorMImproper)arg1, (CGID)cgid [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMM::SelectorMImproper {lvalue},SireMol::CGID [,SireBase::PropertyMap={}])

delete_all_frames()

deleteAllFrames( (SelectorMImproper)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMM::SelectorMImproper {lvalue})

deleteAllFrames( (SelectorMImproper)arg1, (PropertyMap)map) -> None :

C++ signature :

void deleteAllFrames(SireMM::SelectorMImproper {lvalue},SireBase::PropertyMap)

delete_frame()

deleteFrame( (SelectorMImproper)arg1, (int)frame) -> None :

C++ signature :

void deleteFrame(SireMM::SelectorMImproper {lvalue},int)

deleteFrame( (SelectorMImproper)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void deleteFrame(SireMM::SelectorMImproper {lvalue},int,SireBase::PropertyMap)

dynamics(cutoff=None, cutoff_type=None, timestep=None, save_frequency=None, energy_frequency=None, frame_frequency=None, save_velocities=None, constraint=None, perturbable_constraint=None, include_constrained_energies: bool = True, integrator=None, schedule=None, lambda_value=None, swap_end_states=None, ignore_perturbations=None, temperature=None, pressure=None, rest2_scale=None, rest2_selection=None, vacuum=None, shift_delta=None, shift_coulomb=None, coulomb_power=None, restraints=None, fixed=None, platform=None, device=None, precision=None, com_reset_frequency=None, barostat_frequency=None, dynamic_constraints: bool = True, qm_engine=None, lambda_interpolate=None, map=None)

Return a Dynamics object that can be used to perform dynamics of the molecule(s) in this view

cutoff: Length

The size of the non-bonded cutoff

cutoff_type: str

The type of cutoff to use, e.g. “PME”, “RF” etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options

timestep: time

The size of the dynamics timestep

save_frequency: time

The amount of simulation time between saving energies and frames. This can be overridden using energy_frequency or frame_frequency, or by these options in individual dynamics runs. Set this to zero if you don’t want any saves.

energy_frequency: time

The amount of time between saving energies. This overrides the value in save_frequency. Set this to zero if you don’t want to save energies during the trajectory. This can be overridden by setting energy_frequency during an individual run.

frame_frequency: time

The amount of time between saving frames. This overrides the value in save_frequency. Set this to zero if you don’t want to save frames during the trajectory. This can be overridden by setting frame_frequency during an individual run.

save_velocities: bool

Whether or not to save velocities when saving trajectory frames during the simulation. This defaults to False, as velocity trajectories aren’t often needed, and they double the amount of space that is required for a trajectory.

constraint: str

The type of constraint to use for bonds and/or angles, e.g. h-bonds, bonds etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This will be automatically guessed from the timestep if it isn’t set.

perturbable_constraint: str

The type of constraint to use for perturbable bonds and/or angles, e.g. h-bonds, bonds etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This equal the value of constraint if it isn’t set.

include_constrained_energies: bool

Whether or not to include the energies of the constrained bonds and angles. If this is False, then the internal bond or angle energy of the constrained degrees of freedom are not included in the total energy, and their forces are not evaluated.

integrator: str

The type of integrator to use, e.g. langevin, verlet etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This will be automatically set to langevin_middle (NVT/NPT) or verlet (NVE) depending on the ensemble if this is not set (or is set to auto)

schedule: sire.cas.LambdaSchedule

The schedule used to control how perturbable forcefield parameters should be morphed as a function of lambda. If this is not set then a sire.cas.LambdaSchedule.standard_morph() is used.

lambda_value: float

The value of lambda at which to run dynamics. This only impacts perturbable molecules, whose forcefield parameters will be scaled according to the lambda schedule for the specified value of lambda.

swap_end_states: bool

Whether or not to swap the end states. If this is True, then the perturbation will run from the perturbed back to the reference molecule (the perturbed molecule will be at lambda=0, while the reference molecule will be at lambda=1). This will use the coordinates of the perturbed molecule as the starting point.

ignore_perturbations: bool

Whether or not to ignore perturbations. If this is True, then the perturbation will be ignored, and the simulation will be run using the properties of the reference molecule (or the perturbed molecule if swap_end_states is True). This is useful if you just want to run standard molecular dynamics of the reference or perturbed states.

temperature: temperature

The temperature at which to run the simulation. A microcanonical (NVE) simulation will be run if you don’t specify the temperature.

pressure: pressure

The pressure at which to run the simulation. A microcanonical (NVE) or canonical (NVT) simulation will be run if the pressure is not set.

rest2_scale: float

The scaling factor to apply when running a REST2 simulation (Replica Exchange with Solute Tempering). This defaults to 1.0. This specifies the ratio of the temperature of the REST2 region to the temperature of the rest of the system.

rest2_selection: str

A selection string for atoms to include in the REST2 region in addition to any perturbable molecules. For example, “molidx 0 and residx 0,1,2” would select atoms from the first three residues of the first molecule. If None, then all atoms within perturbable molecules will be included in the REST2 region. When atoms within a perturbable molecule are also included in the selection, then only those atoms will be considered as part of the REST2 region. This allows REST2 to be applied to protein mutations.

A selection string for atoms to include in the REST2 region in addition to the perturbable molecule. For example, “molidx 0 and residx 0,1,2” would select atoms from the first three residues of the first molecule. Selected atoms should be within the same molecule. If None, then only the perturbable molecule will be used for the REST2 region.

vacuum: bool (optional)

Whether or not to run the simulation in vacuum. If this is set to True, then the simulation space automatically be replaced by a sire.vol.Cartesian space, and the simulation run in vacuum.

shift_delta: length

The shift_delta parameter that controls the Lennard-Jones softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 2.0 A.

shift_coulomb: length

The shift_coulomb parameter that controls the electrostatic softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 1.0 A.

coulomb_power: int

The coulomb power parmeter that controls the electrostatic softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 0.

restraints: sire.mm.Restraints or list[sire.mm.Restraints]

A single set of restraints, or a list of sets of restraints that will be applied to the atoms during the simulation.

fixed: molecule(s) view, search string, int, list[int] etc

Anything that can be used to identify the atom or atoms that should be fixed in place during the simulation. These atoms will not be moved by dynamics.

platform: str

The name of the OpenMM platform on which to run the dynamics, e.g. “CUDA”, “OpenCL”, “Metal” etc.

device: str or int

The ID of the GPU (or accelerator) used to accelerate the simulation. This would be CUDA_DEVICE_ID or similar if CUDA was used. This can be any valid OpenMM device string

precision: str

The desired precision for the simulation (e.g. single, mixed or double)

com_reset_frequency:

Either the number of steps between center-of-mass resets, or the time between resets. If this is unset, then the center-of-mass is not reset during the simulation.

barostat_frequency:

Either the number of steps between MC moves to apply the barostat, of the time between moves. If this is unset, then the default of every 25 steps is used.

dynamic_constraints: bool

Whether or not to update the length of constraints of perturbable bonds with lambda. This defaults to True, meaning that changing lambda will change any constraint on a perturbable bond to equal to the value of r0 at that lambda value. If this is false, then the constraint is set based on the current length.

qm_engine:

A sire.qm.QMMMEngine object to used to compute QM/MM forces and energies on a subset of the atoms in the system.

lambda_interpolate: float

The lambda value at which to interpolate the QM/MM forces and energies, which can be used to perform end-state correction simulations. A value of 1.0 is full QM, whereas a value of 0.0 is full MM. If two values are specified, then lambda will be linearly interpolated between the two values over the course of the simulation, which lambda updated at the energy_frequency.

map: dict

A dictionary of additional options. Note that any options set in this dictionary that are also specified via one of the arguments above will be overridden by the argument value

energies((SelectorMImproper)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::GeneralUnit> energies(SireMM::SelectorMImproper {lvalue})

energies( (SelectorMImproper)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::GeneralUnit> energies(SireMM::SelectorMImproper {lvalue},SireBase::PropertyMap)

energy((SelectorMImproper)arg1) → GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::SelectorMImproper {lvalue})

energy( (SelectorMImproper)arg1, (PropertyMap)map) -> GeneralUnit :

C++ signature :

SireUnits::Dimension::GeneralUnit energy(SireMM::SelectorMImproper {lvalue},SireBase::PropertyMap)

evaluate((SelectorMImproper)arg1) → EvaluatorM :

C++ signature :

SireMol::EvaluatorM evaluate(SireMM::SelectorMImproper {lvalue})

extract((SelectorMImproper)arg1) → SelectorMol :

C++ signature :

SireMol::SelectorMol extract(SireMM::SelectorMImproper {lvalue})

has_metadata()

hasMetadata( (SelectorMImproper)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasMetadata(SireMM::SelectorMImproper {lvalue},SireBase::PropertyName)

hasMetadata( (SelectorMImproper)arg1, (PropertyName)key, (PropertyName)metakey) -> bool :

C++ signature :

bool hasMetadata(SireMM::SelectorMImproper {lvalue},SireBase::PropertyName,SireBase::PropertyName)

has_property()

hasProperty( (SelectorMImproper)arg1, (PropertyName)key) -> bool :

C++ signature :

bool hasProperty(SireMM::SelectorMImproper {lvalue},SireBase::PropertyName)

ids()

IDs( (SelectorMImproper)arg1) -> object :

C++ signature :

QList<SireMol::ImproperID> IDs(SireMM::SelectorMImproper {lvalue})

intersection((SelectorMImproper)arg1, (SelectorMImproper)other) → SelectorMImproper :

C++ signature :

SireMM::SelectorMImproper intersection(SireMM::SelectorMImproper {lvalue},SireMM::SelectorMImproper)

invert((SelectorMImproper)arg1[, (PropertyMap)map]) → SelectorMImproper :

C++ signature :

SireMM::SelectorMImproper invert(SireMM::SelectorMImproper {lvalue} [,SireBase::PropertyMap])

is_empty()

isEmpty( (SelectorMImproper)arg1) -> bool :

C++ signature :

bool isEmpty(SireMM::SelectorMImproper {lvalue})

is_selector()

isSelector( (SelectorMImproper)arg1) -> bool :

C++ signature :

bool isSelector(SireMM::SelectorMImproper {lvalue})

load_frame()

loadFrame( (SelectorMImproper)arg1, (int)frame) -> None :

C++ signature :

void loadFrame(SireMM::SelectorMImproper {lvalue},int)

loadFrame( (SelectorMImproper)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void loadFrame(SireMM::SelectorMImproper {lvalue},int,SireBase::PropertyMap)

measures((SelectorMImproper)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> measures(SireMM::SelectorMImproper {lvalue})

measures( (SelectorMImproper)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> measures(SireMM::SelectorMImproper {lvalue},SireBase::PropertyMap)

metadata_keys()

metadataKeys( (SelectorMImproper)arg1) -> object :

C++ signature :

QStringList metadataKeys(SireMM::SelectorMImproper {lvalue})

metadataKeys( (SelectorMImproper)arg1, (PropertyName)key) -> object :

C++ signature :

QStringList metadataKeys(SireMM::SelectorMImproper {lvalue},SireBase::PropertyName)

minimisation(cutoff=None, cutoff_type=None, constraint=None, perturbable_constraint=None, include_constrained_energies: bool = True, schedule=None, lambda_value=None, swap_end_states=None, ignore_perturbations=None, vacuum=None, shift_delta=None, shift_coulomb=None, coulomb_power=None, platform=None, device=None, precision=None, restraints=None, fixed=None, dynamic_constraints: bool = True, map=None)

Return a Minimisation object that can be used to perform minimisation of the molecule(s) in this view

cutoff: Length

The size of the non-bonded cutoff

cutoff_type: str

The type of cutoff to use, e.g. “PME”, “RF” etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options

constraint: str

The type of constraint to use for bonds and/or angles, e.g. h-bonds, bonds etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This is none if it is not set.

perturbable_constraint: str

The type of constraint to use for perturbable bonds and/or angles, e.g. h-bonds, bonds etc. See https://sire.openbiosim.org/cheatsheet/openmm.html#choosing-options for the full list of options. This equal the value of constraint if it isn’t set.

include_constrained_energies: bool

Whether or not to include the energies of the perturbable bonds and angles. If this is False, then the internal bond or angle energy of the perturbable degrees of freedom are not included in the total energy, and their forces are not evaluated.

schedule: sire.cas.LambdaSchedule

The schedule used to control how perturbable forcefield parameters should be morphed as a function of lambda. If this is not set then a sire.cas.LambdaSchedule.standard_morph() is used.

lambda_value: float

The value of lambda at which to run minimisation. This only impacts perturbable molecules, whose forcefield parameters will be scaled according to the lambda schedule for the specified value of lambda.

swap_end_states: bool

Whether or not to swap the end states. If this is True, then the perturbation will run from the perturbed back to the reference molecule (the perturbed molecule will be at lambda=0, while the reference molecule will be at lambda=1). This will use the coordinates of the perturbed molecule as the starting point.

ignore_perturbations: bool

Whether or not to ignore perturbations. If this is True, then the perturbation will be ignored, and the simulation will be run using the properties of the reference molecule (or the perturbed molecule if swap_end_states is True). This is useful if you just want to run standard molecular dynamics of the reference or perturbed states.

vacuum: bool (optional)

Whether or not to run the simulation in vacuum. If this is set to True, then the simulation space automatically be replaced by a sire.vol.Cartesian space, and the simulation run in vacuum.

shift_delta: length

The shift_delta parameter that controls the Lennard-Jones softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 2.0 A.

shift_coulomb: length

The shift_coulomb parameter that controls the electrostatic softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 1.0 A.

coulomb_power: int

The coulomb power parmeter that controls the electrostatic softening potential that smooths the creation and deletion of ghost atoms during a potential. This defaults to 0.

restraints: sire.mm.Restraints or list[sire.mm.Restraints]

A single set of restraints, or a list of sets of restraints that will be applied to the atoms during the simulation.

fixed: molecule(s) view, search string, int, list[int] etc

Anything that can be used to identify the atom or atoms that should be fixed in place during the simulation. These atoms will not be moved by minimisation.

platform: str

The name of the OpenMM platform on which to run the dynamics, e.g. “CUDA”, “OpenCL”, “Metal” etc.

device: str or int

The ID of the GPU (or accelerator) used to accelerate minimisation. This would be CUDA_DEVICE_ID or similar if CUDA was used. This can be any valid OpenMM device string

precision: str

The desired precision for the simulation (e.g. single, mixed or double)

dynamic_constraints: bool

Whether or not to update the length of constraints of perturbable bonds with lambda. This defaults to True, meaning that changing lambda will change any constraint on a perturbable bond to equal to the value of r0 at that lambda value. If this is false, then the constraint is set based on the current length.

map: dict

A dictionary of additional options. Note that any options set in this dictionary that are also specified via one of the arguments above will be overridden by the argument value

molecule((SelectorMImproper)arg1, (int)i[, (PropertyMap)map={}]) → Molecule :

C++ signature :

SireMol::Molecule molecule(SireMM::SelectorMImproper {lvalue},int [,SireBase::PropertyMap={}])

molecule( (SelectorMImproper)arg1, (object)name [, (PropertyMap)map={}]) -> Molecule :

C++ signature :

SireMol::Molecule molecule(SireMM::SelectorMImproper {lvalue},QString [,SireBase::PropertyMap={}])

molecule( (SelectorMImproper)arg1, (MolID)molid [, (PropertyMap)map={}]) -> Molecule :

C++ signature :

SireMol::Molecule molecule(SireMM::SelectorMImproper {lvalue},SireMol::MolID [,SireBase::PropertyMap={}])

num_atoms()

nAtoms( (SelectorMImproper)arg1) -> int :

C++ signature :

int nAtoms(SireMM::SelectorMImproper {lvalue})

num_chains()

nChains( (SelectorMImproper)arg1) -> int :

C++ signature :

int nChains(SireMM::SelectorMImproper {lvalue})

num_cutgroups()

nCutGroups( (SelectorMImproper)arg1) -> int :

C++ signature :

int nCutGroups(SireMM::SelectorMImproper {lvalue})

num_frames()

nFrames( (SelectorMImproper)arg1) -> int :

C++ signature :

int nFrames(SireMM::SelectorMImproper {lvalue})

nFrames( (SelectorMImproper)arg1, (PropertyMap)map) -> int :

C++ signature :

int nFrames(SireMM::SelectorMImproper {lvalue},SireBase::PropertyMap)

num_molecules()

nMolecules( (SelectorMImproper)arg1) -> int :

C++ signature :

int nMolecules(SireMM::SelectorMImproper {lvalue})

num_residues()

nResidues( (SelectorMImproper)arg1) -> int :

C++ signature :

int nResidues(SireMM::SelectorMImproper {lvalue})

num_segments()

nSegments( (SelectorMImproper)arg1) -> int :

C++ signature :

int nSegments(SireMM::SelectorMImproper {lvalue})

potentials((SelectorMImproper)arg1) → object :

C++ signature :

QList<SireCAS::Expression> potentials(SireMM::SelectorMImproper {lvalue})

potentials( (SelectorMImproper)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireCAS::Expression> potentials(SireMM::SelectorMImproper {lvalue},SireBase::PropertyMap)

properties((SelectorMImproper)arg1) → object :

C++ signature :

QList<SireBase::Properties> properties(SireMM::SelectorMImproper {lvalue})

property_keys()

propertyKeys( (SelectorMImproper)arg1) -> object :

C++ signature :

QStringList propertyKeys(SireMM::SelectorMImproper {lvalue})

residue((SelectorMImproper)arg1, (int)i[, (PropertyMap)map={}]) → Residue :

C++ signature :

SireMol::Residue residue(SireMM::SelectorMImproper {lvalue},int [,SireBase::PropertyMap={}])

residue( (SelectorMImproper)arg1, (object)name [, (PropertyMap)map={}]) -> Residue :

C++ signature :

SireMol::Residue residue(SireMM::SelectorMImproper {lvalue},QString [,SireBase::PropertyMap={}])

residue( (SelectorMImproper)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Residue :

C++ signature :

SireMol::Residue residue(SireMM::SelectorMImproper {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

save_frame()

saveFrame( (SelectorMImproper)arg1 [, (int)frame]) -> None :

C++ signature :

void saveFrame(SireMM::SelectorMImproper {lvalue} [,int])

saveFrame( (SelectorMImproper)arg1, (int)frame, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMM::SelectorMImproper {lvalue},int,SireBase::PropertyMap)

saveFrame( (SelectorMImproper)arg1, (PropertyMap)map) -> None :

C++ signature :

void saveFrame(SireMM::SelectorMImproper {lvalue},SireBase::PropertyMap)

search((SelectorMImproper)arg1, (object)search_string) → SelectResult :

C++ signature :

SireMol::SelectResult search(SireMM::SelectorMImproper {lvalue},QString)

search( (SelectorMImproper)arg1, (object)search_string, (PropertyMap)map) -> SelectResult :

C++ signature :

SireMol::SelectResult search(SireMM::SelectorMImproper {lvalue},QString,SireBase::PropertyMap)

segment((SelectorMImproper)arg1, (int)i[, (PropertyMap)map={}]) → Segment :

C++ signature :

SireMol::Segment segment(SireMM::SelectorMImproper {lvalue},int [,SireBase::PropertyMap={}])

segment( (SelectorMImproper)arg1, (object)name [, (PropertyMap)map={}]) -> Segment :

C++ signature :

SireMol::Segment segment(SireMM::SelectorMImproper {lvalue},QString [,SireBase::PropertyMap={}])

segment( (SelectorMImproper)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Segment :

C++ signature :

SireMol::Segment segment(SireMM::SelectorMImproper {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

size()

__len__( (SelectorMImproper)arg1) -> int :

C++ signature :

unsigned long __len__(SireMM::SelectorMImproper {lvalue})

sizes((SelectorMImproper)arg1) → object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> sizes(SireMM::SelectorMImproper {lvalue})

sizes( (SelectorMImproper)arg1, (PropertyMap)map) -> object :

C++ signature :

QList<SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1>> sizes(SireMM::SelectorMImproper {lvalue},SireBase::PropertyMap)

smarts(as_search: bool = False, include_hydrogens: bool = False, map=None)

Return the molecule views in this container as smarts strings. Include hydrogens if ‘include_hydrogens’ is True. This returns a list of smarts strings, in the same order as the views in the container.

If ‘as_search’ is True then the smarts string is returned as a sire search string.

smiles(as_search: bool = True, include_hydrogens: bool = False, map=None)

Return the molecule views in this container as smiles strings. Include hydrogens if ‘include_hydrogens’ is True. This returns a list of smiles strings, in the same order as the views in the container.

If ‘as_search’ is True, then this returns the sire search smiles string

to_list()

toList( (SelectorMImproper)arg1) -> object :

C++ signature :

QList<SireBase::PropPtr<SireMol::MoleculeView>> toList(SireMM::SelectorMImproper {lvalue})

to_molecule_group()

toMoleculeGroup( (SelectorMImproper)arg1) -> MoleculeGroup :

C++ signature :

SireMol::MoleculeGroup toMoleculeGroup(SireMM::SelectorMImproper {lvalue})

to_molecules()

toMolecules( (SelectorMImproper)arg1) -> Molecules :

C++ signature :

SireMol::Molecules toMolecules(SireMM::SelectorMImproper {lvalue})

to_select_result()

toSelectResult( (SelectorMImproper)arg1) -> SelectResult :

C++ signature :

SireMol::SelectResult toSelectResult(SireMM::SelectorMImproper {lvalue})

to_string()

toString( (SelectorMImproper)arg1) -> object :

C++ signature :

QString toString(SireMM::SelectorMImproper {lvalue})

trajectory(align=None, smooth=None, wrap=None, mapping=None, frame=None, map=None)

Return an iterator over the trajectory of frames of this view.

align:

Pass in a selection string to select atoms against which every frame will be aligned. These atoms will be moved to the center of the periodic box (if a periodic box is used). If “True” is passed, then this will attempt to align ALL of the coordinates in the view.

You can also choose to pass in a molecular container, and it will align against the atoms in that container, assuming they are contained in this view. If not, then you need to supply a mapping that maps from the atoms in the align container, to the atoms in this view.

frame:

The frame of the trajectory against which the alignment should be based. For example, frame=3 would align based on the coordinates of the aligned atoms in frame 3 of the trajectory. If this is None (the default) then the first frame will be used.

mapping: AtomMapping

An AtomMapping object that maps from atoms in the alignment container to atoms in this view. You only need to supply this if all of the alignment atoms are not contained in this view.

smooth:

Pass in the number of frames to smooth (average) the view over. If ‘True’ is passed, then the recommended number of frames will be averaged over

wrap: bool

Whether or not to wrap the coordinates into the periodic box

typename()

typeName() -> str :

C++ signature :

char const* typeName()

update((SelectorMImproper)arg1, (MoleculeView)molecule) → None :

C++ signature :

void update(SireMM::SelectorMImproper {lvalue},SireMol::MoleculeView)

update( (SelectorMImproper)arg1, (MoleculeView)moldata) -> None :

C++ signature :

void update(SireMM::SelectorMImproper {lvalue},SireMol::MoleculeData)

update( (SelectorMImproper)arg1, (Molecules)molecules) -> None :

C++ signature :

void update(SireMM::SelectorMImproper {lvalue},SireMol::Molecules)

update( (SelectorMImproper)arg1, (SelectorMol)molecules) -> None :

C++ signature :

void update(SireMM::SelectorMImproper {lvalue},SireMol::SelectorMol)

view(default: bool = True, no_default: bool = False, orthographic: bool = True, protein: str = '', water: str = '', ions: str = '', rest: str = '', all: str = '', ball_and_stick: str = '', base: str = '', cartoon: str = '', hyperball: str = '', licorice: str = '', line: str = '', point: str = '', ribbon: str = '', rocket: str = '', rope: str = '', spacefill: str = '', surface: str = '', trace: str = '', tube: str = '', center: str = None, align: str = None, frame: int = None, smooth=False, wrap=True, mapping=None, bgcolor=None, stage_parameters: str = None, map=None)

Return an NGLView viewer for this view. The returned viewer can be passed directly to, e.g. a Jupyter notebook to directly view the molecule(s), or it can be captured in a variable so that it’s NGLViewer member functions can be called to edit the viewer before display.

Full instructions on how to use this view are in the cheatsheet (https://sire.openbiosim.org/cheatsheet/view)

center:

Pass in a selection string to select the atoms to center in the view. By default no atoms are centered

align:

Pass in a selection string to select atoms against which every frame will be aligned. These atoms will be moved to the center of the periodic box (if a periodic box is used). If “True” is passed, then this will attempt to align ALL of the coordinates in the view.

You can also choose to pass in a molecular container, and it will align against the atoms in that container, assuming they are contained in this view. If not, then you need to supply a mapping that maps from the atoms in the align container, to the atoms in this view.

frame:

The frame of the trajectory against which the alignment should be based. For example, frame=3 would align based on the coordinates of the aligned atoms in frame 3 of the trajectory. If this is None (the default) then the first frame will be used.

mapping: AtomMapping

An AtomMapping object that maps from atoms in the alignment container to atoms in this view. You only need to supply this if all of the alignment atoms are not contained in this view.

smooth:

Pass in the number of frames to smooth (average) the view over. If ‘True’ is passed, then the recommended number of frames will be averaged over

wrap: bool

Whether or not to wrap the coordinates into the periodic box.

orthographic:

Set to False to use a perspective view, or accept the default (True) for an orthographic view

default:

The default representation / color for the view. If this is set to False or None or “none” then default views are disabled.

no_default:

Set to False to disable all default views

protein, water, ions:

Set the default views for protein, water and ion molecules. Set to False, None or “none” to disable these default views.

rest:

Synonym for “default”, but does not disable all default views if set to None, False or “none”

all:

Set the representation for all atoms. Set to None, False or “none” to disable all views.

ball_and_stick, base, cartoon etc.

Set the selection strings for atoms that should be represented with these views.

bgcolor: str

The background color of the view. Set to ‘None’ to use the default background color (black)

stage_parameters: dict

An optional dictionary that will be passed directly to the NGLView object to set the stage parameters.

map: dict or sire.base.PropertyMap

An optional property map that can be used to control which properties are used to get the molecular data to be viewed.