Public API

View Module Index

class sire.mol.Atom

This is a single-atom view into a molecule.

Author: Christopher Woods

alternate_name()
alternateName( (Atom)arg1) -> AtomName :

Return the alternate name of the atom

C++ signature :

SireMol::AtomName alternateName(SireMol::Atom {lvalue})

assert_contains()
assertContains( (Atom)arg1, (AtomIdx)atomidx) -> None :

Assert that this atom is the atom at index atomidx Throw: SireMol::missing_atom

C++ signature :

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

assert_contains_metadata()
assertContainsMetadata( (Atom)arg1, (PropertyName)metakey) -> None :

Assert that this atom has an AtomProperty piece of metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

void assertContainsMetadata(SireMol::Atom {lvalue},SireBase::PropertyName)

assertContainsMetadata( (Atom)arg1, (PropertyName)key, (PropertyName)metakey) -> None :

Assert that the property at key key has an AtomProperty piece of metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

void assertContainsMetadata(SireMol::Atom {lvalue},SireBase::PropertyName,SireBase::PropertyName)

assert_contains_property()
assertContainsProperty( (Atom)arg1, (PropertyName)key) -> None :

Assert that this atom has an AtomProperty at key key Throw: SireBase::missing_property

C++ signature :

void assertContainsProperty(SireMol::Atom {lvalue},SireBase::PropertyName)

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((Atom)arg1, (Atom)other) → Atom :
C++ signature :

SireMol::Atom {lvalue} assign(SireMol::Atom {lvalue},SireMol::Atom)

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})

cg_atom_idx()
cgAtomIdx( (Atom)arg1) -> CGAtomIdx :

Return the CGAtomIdx of this atom

C++ signature :

SireMol::CGAtomIdx cgAtomIdx(SireMol::Atom {lvalue})

chain((Atom)arg1) → Chain :

Return the chain this atom is in Throw: SireMol::missing_chain

C++ signature :

SireMol::Chain chain(SireMol::Atom {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((Atom)arg1) → Atom :
C++ signature :

SireMol::Atom clone(SireMol::Atom)

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__( (Atom)arg1) -> int :

C++ signature :

unsigned long __len__(SireMol::Atom {lvalue})

cursor(map=None)

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

cutgroup()
cutGroup( (Atom)arg1) -> CutGroup :

Return the CutGroup this atom is in

C++ signature :

SireMol::CutGroup cutGroup(SireMol::Atom {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)

edit((Atom)arg1) → AtomEditor :

Return an editor that can be used to edit this atom

C++ signature :

SireMol::AtomEditor edit(SireMol::Atom {lvalue})

energy(other=None, map=None)

Calculate the total energy of the molecule view(s) in this collection.

other: (view or views, optional)

An optional second view (or collection of views). If this is passed, then the energy between the views in this collections and others will be calculated.

map: (dictionary, optional)

An optional property map that will be used to find or map the properties used for this energy calculation.

Returns:

Returns an energy, with attached components for the sub-components (if any) for this energy.

Return type:

sire.units.GeneralUnit (energy per quantity)

evaluate((Atom)arg1) → Evaluator :

Return an evaluator that can be used to evaluate properties of this atom

C++ signature :

SireMol::Evaluator evaluate(SireMol::Atom {lvalue})

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)

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})

hasLinks( (MoleculeView)arg1) -> bool :

Return whether or not this molecule has any property links

C++ signature :

bool hasLinks(SireMol::MoleculeView {lvalue})

has_metadata()
hasMetadata( (Atom)arg1, (PropertyName)metakey) -> bool :

Return whether or not there is an AtomProperty at metakey metakey

C++ signature :

bool hasMetadata(SireMol::Atom {lvalue},SireBase::PropertyName)

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

Return whether the metadata at metakey metakey for the property at key key is an AtomProperty Throw: SireBase::missing_property

C++ signature :

bool hasMetadata(SireMol::Atom {lvalue},SireBase::PropertyName,SireBase::PropertyName)

has_property()
hasProperty( (Atom)arg1, (PropertyName)key) -> bool :

Return whether or not there is an AtomProperty at key key

C++ signature :

bool hasProperty(SireMol::Atom {lvalue},SireBase::PropertyName)

index((Atom)arg1) → AtomIdx :

Return the index number of this atom in the molecule

C++ signature :

SireMol::AtomIdx index(SireMol::Atom {lvalue})

invert((Atom)arg1) → Selector_Atom_ :

Return a selector that has everything except this view

C++ signature :

SireMol::Selector<SireMol::Atom> invert(SireMol::Atom {lvalue})

is_empty()
isEmpty( (Atom)arg1) -> bool :

Is this atom empty?

C++ signature :

bool isEmpty(SireMol::Atom {lvalue})

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})

is_within_chain()
isWithinChain( (Atom)arg1) -> bool :

Return whether or not this atom is part of a chain

C++ signature :

bool isWithinChain(SireMol::Atom {lvalue})

is_within_residue()
isWithinResidue( (Atom)arg1) -> bool :

Return whether or not this atom is part of a residue

C++ signature :

bool isWithinResidue(SireMol::Atom {lvalue})

is_within_segment()
isWithinSegment( (Atom)arg1) -> bool :

Return whether or not this atom is part of a segment

C++ signature :

bool isWithinSegment(SireMol::Atom {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)

metadata_keys()
metadataKeys( (Atom)arg1) -> object :

Return the metakeys of all AtomProperty metadata

C++ signature :

QStringList metadataKeys(SireMol::Atom {lvalue})

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

Return the metakeys of all AtomProperty metadata for the property at key key Throw: SireBase::missing_property

C++ signature :

QStringList metadataKeys(SireMol::Atom {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)

molecule((Atom)arg1) → Molecule :

Return the molecule that contains this atom

C++ signature :

SireMol::Molecule molecule(SireMol::Atom {lvalue})

move((Atom)arg1) → Mover_Atom_ :

Return a Mover that can be used to move this atom

C++ signature :

SireMol::Mover<SireMol::Atom> move(SireMol::Atom {lvalue})

name((Atom)arg1) → AtomName :

Return the name of the atom

C++ signature :

SireMol::AtomName name(SireMol::Atom {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})

number((Atom)arg1) → AtomNum :

Return the number of the atom

C++ signature :

SireMol::AtomNum number(SireMol::Atom {lvalue})

property_as_property()
propertyAsProperty( (Atom)arg1, (PropertyName)key) -> object :

Return the specified property as a PropertyPtr

C++ signature :

SireBase::PropPtr<SireBase::Property> propertyAsProperty(SireMol::Atom {lvalue},SireBase::PropertyName)

property_as_variant()
propertyAsVariant( (Atom)arg1, (PropertyName)key) -> object :

Return the specified property as a QVariant

C++ signature :

QVariant propertyAsVariant(SireMol::Atom {lvalue},SireBase::PropertyName)

property_keys()
propertyKeys( (Atom)arg1) -> object :

Return the keys of all AtomProperty properties

C++ signature :

QStringList propertyKeys(SireMol::Atom {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)

residue((Atom)arg1) → Residue :

Return the residue that this atom is in Throw: SireMol::missing_residue

C++ signature :

SireMol::Residue residue(SireMol::Atom {lvalue})

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)

segment((Atom)arg1) → Segment :

Return the segment this atom is in Throw: SireMol::missing_segment

C++ signature :

SireMol::Segment segment(SireMol::Atom {lvalue})

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( (Atom)arg1) -> bool :

Is this atom a view of the whole (1 atom) molecule?

C++ signature :

bool selectedAll(SireMol::Atom {lvalue})

selection((Atom)arg1) → AtomSelection :

Return the selected atom

C++ signature :

SireMol::AtomSelection selection(SireMol::Atom {lvalue})

selector((Atom)arg1) → Selector_Atom_ :

Return a selector that can change the atom selection

C++ signature :

SireMol::Selector<SireMol::Atom> selector(SireMol::Atom {lvalue})

size()

__len__( (Atom)arg1) -> int :

C++ signature :

unsigned long __len__(SireMol::Atom {lvalue})

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( (Atom)arg1) -> object :

C++ signature :

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

to_string()
toString( (Atom)arg1) -> object :

Return a string representation of this atom

C++ signature :

QString toString(SireMol::Atom {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

class sire.mol.AtomIdx

This is an ID object that is used to index atoms (e.g. index in a list or array, or in a molecule).

Author: Christopher Woods

assign((AtomIdx)arg1, (AtomIdx)other) → AtomIdx :
C++ signature :

SireMol::AtomIdx {lvalue} assign(SireMol::AtomIdx {lvalue},SireMol::AtomIdx)

clone((AtomIdx)arg1) → AtomIdx :
C++ signature :

SireMol::AtomIdx clone(SireMol::AtomIdx)

hash((AtomIdx)arg1) → int :
C++ signature :

unsigned int hash(SireMol::AtomIdx {lvalue})

is_null()

isNull( (AtomIdx)arg1) -> bool :

C++ signature :

bool isNull(SireMol::AtomIdx {lvalue})

map((AtomIdx)arg1, (MolInfo)molinfo) → object :
C++ signature :

QList<SireMol::AtomIdx> map(SireMol::AtomIdx {lvalue},SireMol::MolInfo)

static null() → AtomIdx :
C++ signature :

SireMol::AtomIdx null()

to_string()

toString( (AtomIdx)arg1) -> object :

C++ signature :

QString toString(SireMol::AtomIdx {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((AtomIdx)arg1) → str :
C++ signature :

char const* what(SireMol::AtomIdx {lvalue})

class sire.mol.AtomMapping

This class holds the mapping from one set of atoms to another. This enables you associate, atom by atom, atoms in one set to atoms in another set. This is useful, e.g. for building perturbations, or for specifying mappings for alignments or RMSD calculations etc.

align((AtomMapping)arg1) → AtomMapping :
Return the mapping where the perturbed state (1) has been

aligned against the reference state (0).

C++ signature :

SireMol::AtomMapping align(SireMol::AtomMapping {lvalue})

align_to0()
alignTo0( (AtomMapping)arg1) -> AtomMapping :
Return the mapping where the perturbed state (1) has been

aligned against the reference state (0).

C++ signature :

SireMol::AtomMapping alignTo0(SireMol::AtomMapping {lvalue})

align_to1()
alignTo1( (AtomMapping)arg1) -> AtomMapping :
Return the mapping where the perturbed state (1) has been

aligned against the reference state (0).

C++ signature :

SireMol::AtomMapping alignTo1(SireMol::AtomMapping {lvalue})

assert_single_molecule()
assertSingleMolecule( (AtomMapping)arg1) -> None :

Assert that this mapping refers only to a single molecule

C++ signature :

void assertSingleMolecule(SireMol::AtomMapping {lvalue})

assign((AtomMapping)arg1, (AtomMapping)other) → AtomMapping :
C++ signature :

SireMol::AtomMapping {lvalue} assign(SireMol::AtomMapping {lvalue},SireMol::AtomMapping)

atoms0((AtomMapping)arg1) → SelectorM_Atom_ :
Return the original reference atoms. This is the collection of both

mapped and unmapped reference atoms

C++ signature :

SireMol::SelectorM<SireMol::Atom> atoms0(SireMol::AtomMapping {lvalue})

atoms1((AtomMapping)arg1) → SelectorM_Atom_ :
Return the original mapped atoms. This is the collection of both

mapped and unmapped mapped atoms

C++ signature :

SireMol::SelectorM<SireMol::Atom> atoms1(SireMol::AtomMapping {lvalue})

clone((AtomMapping)arg1) → AtomMapping :
C++ signature :

SireMol::AtomMapping clone(SireMol::AtomMapping)

contains((AtomMapping)arg1, (Atom)atom) → bool :
Return whether or not the forward mapping contains the

passed atom - this returns true if the atom is contained in the original reference atoms, i.e. it doesnt guarantee that the atom is mapped. Use the isMapped method to check if the atom is mapped.

C++ signature :

bool contains(SireMol::AtomMapping {lvalue},SireMol::Atom)

count((AtomMapping)arg1) → int :
C++ signature :

int count(SireMol::AtomMapping {lvalue})

is_empty()

isEmpty( (AtomMapping)arg1) -> bool :

C++ signature :

bool isEmpty(SireMol::AtomMapping {lvalue})

is_mapped()
isMapped( (AtomMapping)arg1, (Atom)atom) -> bool :
Return whether or not the passed reference atom has been

mapped to a mapped atom

C++ signature :

bool isMapped(SireMol::AtomMapping {lvalue},SireMol::Atom)

is_single_molecule()
isSingleMolecule( (AtomMapping)arg1) -> bool :

Return whether or not this mapping refers to only a single molecule

C++ signature :

bool isSingleMolecule(SireMol::AtomMapping {lvalue})

mapped_atoms0()
mappedAtoms0( (AtomMapping)arg1) -> SelectorM_Atom_ :
Return all of the reference atoms that have been mapped,

in the same order as the mapped atoms they match with

C++ signature :

SireMol::SelectorM<SireMol::Atom> mappedAtoms0(SireMol::AtomMapping {lvalue})

mapped_atoms1()
mappedAtoms1( (AtomMapping)arg1) -> SelectorM_Atom_ :
Return all of the mapped atoms that have been mapped,

in the same order as the reference atoms they match with

C++ signature :

SireMol::SelectorM<SireMol::Atom> mappedAtoms1(SireMol::AtomMapping {lvalue})

merge(as_new_molecule: bool = True, map=None)

Merge the atoms in this mapping and return as a single merged (perturbable) molecule. This function will conduct a merge and return a perturbable molecule such that it is equivalent to mol0 at the reference state (lambda=0) and equivalent to mol1 at the perturbed state (lambda=1).

Parameters:

  • as_new_molecule (bool, optional) – If True, the merged molecule will be assigned a new molecule number and treated as a new molecule. If False, the merged molecule will use the molecule number of the reference molecule.

  • map (dict, optional) – Property map to assign properties in the returned, merged molecule.

Returns:

The merged molecule

Return type:

Molecule

mutate(as_new_molecule: bool = True, map=None)

Mutate the reference atoms in this mapping to the perturbed atoms, returning the mutated (new) molecule.

This is equivalent to calling merge and then extracting the perturbed state from the returned merged molecule.

This function is most useful for mutating parts of molecules, e.g. calling this on a mapping of two residues would mutate one residue into another within the larger molecule containing the reference mapping. This can be used for mutating residues in proteins, or for copying and pasting parts of one molecule into another.

Parameters:

  • as_new_molecule (bool, optional) – Whether to return the mutated molecule as a new molecule, or to mutate the original molecule in place. Default is True.

  • map (dict, optional) – Property map to assign properties in the returned, mutated molecule.

Returns:

The mutated molecule

Return type:

Molecule

property_map0()
propertyMap0( (AtomMapping)arg1) -> PropertyMap :
Return the property map used to find properties of the

reference molecule

C++ signature :

SireBase::PropertyMap propertyMap0(SireMol::AtomMapping {lvalue})

property_map1()
propertyMap1( (AtomMapping)arg1) -> PropertyMap :
Return the property map used to find properties of the

mapped molecule

C++ signature :

SireBase::PropertyMap propertyMap1(SireMol::AtomMapping {lvalue})

size((AtomMapping)arg1) → int :
C++ signature :

int size(SireMol::AtomMapping {lvalue})

swap((AtomMapping)arg1) → AtomMapping :

Return an AtomMapping that swaps the reference and mapped atoms

C++ signature :

SireMol::AtomMapping swap(SireMol::AtomMapping {lvalue})

to_string()

toString( (AtomMapping)arg1) -> object :

C++ signature :

QString toString(SireMol::AtomMapping {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

unmapped_atoms0()
unmappedAtoms0( (AtomMapping)arg1) -> SelectorM_Atom_ :
Return all of the reference atoms that havent been mapped,

in the same order as they appear in the original reference

C++ signature :

SireMol::SelectorM<SireMol::Atom> unmappedAtoms0(SireMol::AtomMapping {lvalue})

unmapped_atoms1()
unmappedAtoms1( (AtomMapping)arg1) -> SelectorM_Atom_ :
Return all of the mapped atoms that havent been mapped,

in the same order as they appear in the original mapped atoms

C++ signature :

SireMol::SelectorM<SireMol::Atom> unmappedAtoms1(SireMol::AtomMapping {lvalue})

what((AtomMapping)arg1) → str :
C++ signature :

char const* what(SireMol::AtomMapping {lvalue})

class sire.mol.AtomMatch

This class holds the results of performing a match on a molecule.

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((AtomMatch)arg1, (AtomMatch)other) → AtomMatch :
C++ signature :

SireMol::AtomMatch {lvalue} assign(SireMol::AtomMatch {lvalue},SireMol::AtomMatch)

clone((AtomMatch)arg1) → AtomMatch :
C++ signature :

SireMol::AtomMatch clone(SireMol::AtomMatch)

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})

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)

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)

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})

group((AtomMatch)arg1, (int)i) → Selector_Atom_ :
C++ signature :

SireMol::Selector<SireMol::Atom> group(SireMol::AtomMatch {lvalue},int)

groups((AtomMatch)arg1) → object :
C++ signature :

QList<SireMol::Selector<SireMol::Atom>> groups(SireMol::AtomMatch {lvalue})

hasLinks( (MoleculeView)arg1) -> bool :

Return whether or not this molecule has any property links

C++ signature :

bool hasLinks(SireMol::MoleculeView {lvalue})

has_metadata()
hasMetadata( (PartialMolecule)arg1, (PropertyName)metakey) -> bool :

Return whether or not this molecule has some metadata at the metakey metakey

C++ signature :

bool hasMetadata(SireMol::PartialMolecule {lvalue},SireBase::PropertyName)

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

Return whether or not the property at key key has some metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

bool hasMetadata(SireMol::PartialMolecule {lvalue},SireBase::PropertyName,SireBase::PropertyName)

has_property()
hasProperty( (PartialMolecule)arg1, (PropertyName)key) -> bool :

Return whether or not this molecule has a property at key key

C++ signature :

bool hasProperty(SireMol::PartialMolecule {lvalue},SireBase::PropertyName)

is_empty()
isEmpty( (PartialMolecule)arg1) -> bool :

Return whether or not this is empty

C++ signature :

bool isEmpty(SireMol::PartialMolecule {lvalue})

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)

metadata_keys()
metadataKeys( (PartialMolecule)arg1) -> object :

Return the keys of all of the metadata contained directly by this molecule

C++ signature :

QStringList metadataKeys(SireMol::PartialMolecule {lvalue})

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

Return the keys of all metadata for the property at key key Throw: SireBase::missing_property

C++ signature :

QStringList metadataKeys(SireMol::PartialMolecule {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)

num_atoms()
nAtoms( (PartialMolecule)arg1) -> int :

Return the number of atoms in this view

C++ signature :

int nAtoms(SireMol::PartialMolecule {lvalue})

num_chains()
nChains( (PartialMolecule)arg1) -> int :

Return the number of chains in this view

C++ signature :

int nChains(SireMol::PartialMolecule {lvalue})

num_cutgroups()
nCutGroups( (PartialMolecule)arg1) -> int :

Return the number of CutGroups in this view

C++ signature :

int nCutGroups(SireMol::PartialMolecule {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_groups()

nGroups( (AtomMatch)arg1) -> int :

C++ signature :

int nGroups(SireMol::AtomMatch {lvalue})

num_residues()
nResidues( (PartialMolecule)arg1) -> int :

Return the number of residues in this view

C++ signature :

int nResidues(SireMol::PartialMolecule {lvalue})

num_segments()
nSegments( (PartialMolecule)arg1) -> int :

Return the number of segments in this view

C++ signature :

int nSegments(SireMol::PartialMolecule {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})

property_keys()
propertyKeys( (PartialMolecule)arg1) -> object :

Return the keys of all of the properties contained in this molecule

C++ signature :

QStringList propertyKeys(SireMol::PartialMolecule {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)

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)

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( (PartialMolecule)arg1) -> bool :

Return whether or not this contains the entire molecule

C++ signature :

bool selectedAll(SireMol::PartialMolecule {lvalue})

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( (PartialMolecule)arg1) -> object :

C++ signature :

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

to_string()

toString( (AtomMatch)arg1) -> object :

C++ signature :

QString toString(SireMol::AtomMatch {lvalue})

to_unit()
toUnit( (PartialMolecule)arg1) -> object :

Return a copy of this PartialMolecule that has been reduced to its unit type, i.e. if this is a single Atom, this returns the Atom, if this is a single residue, this returns the Residue etc.

C++ signature :

SireBase::PropPtr<SireMol::MoleculeView> toUnit(SireMol::PartialMolecule {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((AtomMatch)arg1) → str :
C++ signature :

char const* what(SireMol::AtomMatch {lvalue})

class sire.mol.AtomMatchM

This class holds the result of performing a match on multiple molecules

assign((AtomMatchM)arg1, (AtomMatchM)other) → AtomMatchM :
C++ signature :

SireMol::AtomMatchM {lvalue} assign(SireMol::AtomMatchM {lvalue},SireMol::AtomMatchM)

atom((AtomMatchM)arg1, (int)i[, (PropertyMap)map={}]) → Atom :
C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

atoms((AtomMatchM)arg1) → SelectorM_Atom_ :
C++ signature :

SireMol::SelectorM<SireMol::Atom> atoms(SireMol::AtomMatchM {lvalue})

atoms( (AtomMatchM)arg1, (int)i [, (PropertyMap)map={}]) -> SelectorM_Atom_ :

C++ signature :

SireMol::SelectorM<SireMol::Atom> atoms(SireMol::AtomMatchM {lvalue},int [,SireBase::PropertyMap={}])

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

C++ signature :

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

atoms( (AtomMatchM)arg1, (object)idxs [, (PropertyMap)map={}]) -> SelectorM_Atom_ :

C++ signature :

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

atoms( (AtomMatchM)arg1, (object)name [, (PropertyMap)map={}]) -> SelectorM_Atom_ :

C++ signature :

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

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

C++ signature :

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

chain((AtomMatchM)arg1, (int)i[, (PropertyMap)map={}]) → Chain :
C++ signature :

SireMol::Chain chain(SireMol::AtomMatchM {lvalue},int [,SireBase::PropertyMap={}])

chain( (AtomMatchM)arg1, (object)name [, (PropertyMap)map={}]) -> Chain :

C++ signature :

SireMol::Chain chain(SireMol::AtomMatchM {lvalue},QString [,SireBase::PropertyMap={}])

chain( (AtomMatchM)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Chain :

C++ signature :

SireMol::Chain chain(SireMol::AtomMatchM {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

chains((AtomMatchM)arg1) → SelectorM_Chain_ :
C++ signature :

SireMol::SelectorM<SireMol::Chain> chains(SireMol::AtomMatchM {lvalue})

chains( (AtomMatchM)arg1, (int)i [, (PropertyMap)map={}]) -> SelectorM_Chain_ :

C++ signature :

SireMol::SelectorM<SireMol::Chain> chains(SireMol::AtomMatchM {lvalue},int [,SireBase::PropertyMap={}])

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

C++ signature :

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

chains( (AtomMatchM)arg1, (object)idxs [, (PropertyMap)map={}]) -> SelectorM_Chain_ :

C++ signature :

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

chains( (AtomMatchM)arg1, (object)name [, (PropertyMap)map={}]) -> SelectorM_Chain_ :

C++ signature :

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

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

C++ signature :

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

clone((AtomMatchM)arg1) → AtomMatchM :
C++ signature :

SireMol::AtomMatchM clone(SireMol::AtomMatchM)

contains((AtomMatchM)arg1, (SelectorM_Atom_)other) → bool :
C++ signature :

bool contains(SireMol::AtomMatchM {lvalue},SireMol::SelectorM<SireMol::Atom>)

contains( (AtomMatchM)arg1, (Selector_Atom_)view) -> bool :

C++ signature :

bool contains(SireMol::AtomMatchM {lvalue},SireMol::Selector<SireMol::Atom>)

contains( (AtomMatchM)arg1, (Atom)view) -> bool :

C++ signature :

bool contains(SireMol::AtomMatchM {lvalue},SireMol::Atom)

count((AtomMatchM)arg1) → int :
C++ signature :

int count(SireMol::AtomMatchM {lvalue})

cutgroup()

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

cutgroups()

cutGroups( (AtomMatchM)arg1) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMol::AtomMatchM {lvalue})

cutGroups( (AtomMatchM)arg1, (int)i [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMol::AtomMatchM {lvalue},int [,SireBase::PropertyMap={}])

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

C++ signature :

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

cutGroups( (AtomMatchM)arg1, (object)idxs [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMol::AtomMatchM {lvalue},QList<long long> [,SireBase::PropertyMap={}])

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

C++ signature :

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

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

C++ signature :

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

delete_all_frames()

deleteAllFrames( (AtomMatchM)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMol::AtomMatchM {lvalue})

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

C++ signature :

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

delete_frame()

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

C++ signature :

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

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

C++ signature :

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

evaluate((AtomMatchM)arg1) → EvaluatorM :
C++ signature :

SireMol::EvaluatorM evaluate(SireMol::AtomMatchM {lvalue})

extract((AtomMatchM)arg1) → SelectorMol :
C++ signature :

SireMol::SelectorMol extract(SireMol::AtomMatchM {lvalue})

find((AtomMatchM)arg1, (Atom)view) → object :
C++ signature :

QList<long long> find(SireMol::AtomMatchM {lvalue},SireMol::Atom)

find( (AtomMatchM)arg1, (Selector_Atom_)views) -> object :

C++ signature :

QList<long long> find(SireMol::AtomMatchM {lvalue},SireMol::Selector<SireMol::Atom>)

find( (AtomMatchM)arg1, (SelectorM_Atom_)views) -> object :

C++ signature :

QList<long long> find(SireMol::AtomMatchM {lvalue},SireMol::SelectorM<SireMol::Atom>)

group((AtomMatchM)arg1, (int)i) → Selector_Atom_ :
C++ signature :

SireMol::Selector<SireMol::Atom> group(SireMol::AtomMatchM {lvalue},int)

groups((AtomMatchM)arg1) → object :
C++ signature :

QList<SireMol::Selector<SireMol::Atom>> groups(SireMol::AtomMatchM {lvalue})

has_metadata()

hasMetadata( (AtomMatchM)arg1, (PropertyName)metakey) -> bool :

C++ signature :

bool hasMetadata(SireMol::AtomMatchM {lvalue},SireBase::PropertyName)

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

C++ signature :

bool hasMetadata(SireMol::AtomMatchM {lvalue},SireBase::PropertyName,SireBase::PropertyName)

has_property()

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

C++ signature :

bool hasProperty(SireMol::AtomMatchM {lvalue},SireBase::PropertyName)

ids()

IDs( (AtomMatchM)arg1) -> object :

C++ signature :

QList<SireMol::AtomIdx> IDs(SireMol::AtomMatchM {lvalue})

indexes((AtomMatchM)arg1) → object :
C++ signature :

QList<SireMol::AtomIdx> indexes(SireMol::AtomMatchM {lvalue})

intersection((AtomMatchM)arg1, (SelectorM_Atom_)other) → SelectorM_Atom_ :
C++ signature :

SireMol::SelectorM<SireMol::Atom> intersection(SireMol::AtomMatchM {lvalue},SireMol::SelectorM<SireMol::Atom>)

intersection( (AtomMatchM)arg1, (Selector_Atom_)views) -> SelectorM_Atom_ :

C++ signature :

SireMol::SelectorM<SireMol::Atom> intersection(SireMol::AtomMatchM {lvalue},SireMol::Selector<SireMol::Atom>)

intersection( (AtomMatchM)arg1, (Atom)view) -> SelectorM_Atom_ :

C++ signature :

SireMol::SelectorM<SireMol::Atom> intersection(SireMol::AtomMatchM {lvalue},SireMol::Atom)

intersects((AtomMatchM)arg1, (SelectorM_Atom_)other) → bool :
C++ signature :

bool intersects(SireMol::AtomMatchM {lvalue},SireMol::SelectorM<SireMol::Atom>)

intersects( (AtomMatchM)arg1, (Selector_Atom_)view) -> bool :

C++ signature :

bool intersects(SireMol::AtomMatchM {lvalue},SireMol::Selector<SireMol::Atom>)

intersects( (AtomMatchM)arg1, (Atom)view) -> bool :

C++ signature :

bool intersects(SireMol::AtomMatchM {lvalue},SireMol::Atom)

invert((AtomMatchM)arg1) → SelectorM_Atom_ :
C++ signature :

SireMol::SelectorM<SireMol::Atom> invert(SireMol::AtomMatchM {lvalue})

is_empty()

isEmpty( (AtomMatchM)arg1) -> bool :

C++ signature :

bool isEmpty(SireMol::AtomMatchM {lvalue})

is_selector()

isSelector( (AtomMatchM)arg1) -> bool :

C++ signature :

bool isSelector(SireMol::AtomMatchM {lvalue})

load_frame()

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

metadata_keys()

metadataKeys( (AtomMatchM)arg1) -> object :

C++ signature :

QStringList metadataKeys(SireMol::AtomMatchM {lvalue})

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

C++ signature :

QStringList metadataKeys(SireMol::AtomMatchM {lvalue},SireBase::PropertyName)

molecule((AtomMatchM)arg1, (int)i[, (PropertyMap)map={}]) → Molecule :
C++ signature :

SireMol::Molecule molecule(SireMol::AtomMatchM {lvalue},int [,SireBase::PropertyMap={}])

molecule( (AtomMatchM)arg1, (object)name [, (PropertyMap)map={}]) -> Molecule :

C++ signature :

SireMol::Molecule molecule(SireMol::AtomMatchM {lvalue},QString [,SireBase::PropertyMap={}])

molecule( (AtomMatchM)arg1, (MolID)molid [, (PropertyMap)map={}]) -> Molecule :

C++ signature :

SireMol::Molecule molecule(SireMol::AtomMatchM {lvalue},SireMol::MolID [,SireBase::PropertyMap={}])

molecules((AtomMatchM)arg1) → SelectorMol :
C++ signature :

SireMol::SelectorMol molecules(SireMol::AtomMatchM {lvalue})

molecules( (AtomMatchM)arg1, (int)i [, (PropertyMap)map={}]) -> SelectorMol :

C++ signature :

SireMol::SelectorMol molecules(SireMol::AtomMatchM {lvalue},int [,SireBase::PropertyMap={}])

molecules( (AtomMatchM)arg1, (object)slice [, (PropertyMap)map={}]) -> SelectorMol :

C++ signature :

SireMol::SelectorMol molecules(SireMol::AtomMatchM {lvalue},SireBase::Slice [,SireBase::PropertyMap={}])

molecules( (AtomMatchM)arg1, (object)idxs [, (PropertyMap)map={}]) -> SelectorMol :

C++ signature :

SireMol::SelectorMol molecules(SireMol::AtomMatchM {lvalue},QList<long long> [,SireBase::PropertyMap={}])

molecules( (AtomMatchM)arg1, (object)name [, (PropertyMap)map={}]) -> SelectorMol :

C++ signature :

SireMol::SelectorMol molecules(SireMol::AtomMatchM {lvalue},QString [,SireBase::PropertyMap={}])

molecules( (AtomMatchM)arg1, (MolID)molid [, (PropertyMap)map={}]) -> SelectorMol :

C++ signature :

SireMol::SelectorMol molecules(SireMol::AtomMatchM {lvalue},SireMol::MolID [,SireBase::PropertyMap={}])

names((AtomMatchM)arg1) → object :
C++ signature :

QList<SireMol::AtomName> names(SireMol::AtomMatchM {lvalue})

num_atoms()

nAtoms( (AtomMatchM)arg1) -> int :

C++ signature :

int nAtoms(SireMol::AtomMatchM {lvalue})

num_chains()

nChains( (AtomMatchM)arg1) -> int :

C++ signature :

int nChains(SireMol::AtomMatchM {lvalue})

num_cutgroups()

nCutGroups( (AtomMatchM)arg1) -> int :

C++ signature :

int nCutGroups(SireMol::AtomMatchM {lvalue})

num_frames()

nFrames( (AtomMatchM)arg1) -> int :

C++ signature :

int nFrames(SireMol::AtomMatchM {lvalue})

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

C++ signature :

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

num_groups()

nGroups( (AtomMatchM)arg1) -> int :

C++ signature :

int nGroups(SireMol::AtomMatchM {lvalue})

num_molecules()

nMolecules( (AtomMatchM)arg1) -> int :

C++ signature :

int nMolecules(SireMol::AtomMatchM {lvalue})

num_residues()

nResidues( (AtomMatchM)arg1) -> int :

C++ signature :

int nResidues(SireMol::AtomMatchM {lvalue})

num_segments()

nSegments( (AtomMatchM)arg1) -> int :

C++ signature :

int nSegments(SireMol::AtomMatchM {lvalue})

numbers((AtomMatchM)arg1) → object :
C++ signature :

QList<SireMol::AtomNum> numbers(SireMol::AtomMatchM {lvalue})

property_keys()

propertyKeys( (AtomMatchM)arg1) -> object :

C++ signature :

QStringList propertyKeys(SireMol::AtomMatchM {lvalue})

residue((AtomMatchM)arg1, (int)i[, (PropertyMap)map={}]) → Residue :
C++ signature :

SireMol::Residue residue(SireMol::AtomMatchM {lvalue},int [,SireBase::PropertyMap={}])

residue( (AtomMatchM)arg1, (object)name [, (PropertyMap)map={}]) -> Residue :

C++ signature :

SireMol::Residue residue(SireMol::AtomMatchM {lvalue},QString [,SireBase::PropertyMap={}])

residue( (AtomMatchM)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Residue :

C++ signature :

SireMol::Residue residue(SireMol::AtomMatchM {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

residues((AtomMatchM)arg1) → SelectorM_Residue_ :
C++ signature :

SireMol::SelectorM<SireMol::Residue> residues(SireMol::AtomMatchM {lvalue})

residues( (AtomMatchM)arg1, (int)i [, (PropertyMap)map={}]) -> SelectorM_Residue_ :

C++ signature :

SireMol::SelectorM<SireMol::Residue> residues(SireMol::AtomMatchM {lvalue},int [,SireBase::PropertyMap={}])

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

C++ signature :

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

residues( (AtomMatchM)arg1, (object)idxs [, (PropertyMap)map={}]) -> SelectorM_Residue_ :

C++ signature :

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

residues( (AtomMatchM)arg1, (object)name [, (PropertyMap)map={}]) -> SelectorM_Residue_ :

C++ signature :

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

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

C++ signature :

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

save_frame()

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

search((AtomMatchM)arg1, (object)search_string) → SelectResult :
C++ signature :

SireMol::SelectResult search(SireMol::AtomMatchM {lvalue},QString)

search( (AtomMatchM)arg1, (object)search_string, (PropertyMap)map) -> SelectResult :

C++ signature :

SireMol::SelectResult search(SireMol::AtomMatchM {lvalue},QString,SireBase::PropertyMap)

segment((AtomMatchM)arg1, (int)i[, (PropertyMap)map={}]) → Segment :
C++ signature :

SireMol::Segment segment(SireMol::AtomMatchM {lvalue},int [,SireBase::PropertyMap={}])

segment( (AtomMatchM)arg1, (object)name [, (PropertyMap)map={}]) -> Segment :

C++ signature :

SireMol::Segment segment(SireMol::AtomMatchM {lvalue},QString [,SireBase::PropertyMap={}])

segment( (AtomMatchM)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Segment :

C++ signature :

SireMol::Segment segment(SireMol::AtomMatchM {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

segments((AtomMatchM)arg1) → SelectorM_Segment_ :
C++ signature :

SireMol::SelectorM<SireMol::Segment> segments(SireMol::AtomMatchM {lvalue})

segments( (AtomMatchM)arg1, (int)i [, (PropertyMap)map={}]) -> SelectorM_Segment_ :

C++ signature :

SireMol::SelectorM<SireMol::Segment> segments(SireMol::AtomMatchM {lvalue},int [,SireBase::PropertyMap={}])

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

C++ signature :

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

segments( (AtomMatchM)arg1, (object)idxs [, (PropertyMap)map={}]) -> SelectorM_Segment_ :

C++ signature :

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

segments( (AtomMatchM)arg1, (object)name [, (PropertyMap)map={}]) -> SelectorM_Segment_ :

C++ signature :

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

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

C++ signature :

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

size((AtomMatchM)arg1) → int :
C++ signature :

int size(SireMol::AtomMatchM {lvalue})

to_list()

toList( (AtomMatchM)arg1) -> object :

C++ signature :

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

to_molecule_group()

toMoleculeGroup( (AtomMatchM)arg1) -> MoleculeGroup :

C++ signature :

SireMol::MoleculeGroup toMoleculeGroup(SireMol::AtomMatchM {lvalue})

to_molecules()

toMolecules( (AtomMatchM)arg1) -> Molecules :

C++ signature :

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

to_select_result()

toSelectResult( (AtomMatchM)arg1) -> SelectResult :

C++ signature :

SireMol::SelectResult toSelectResult(SireMol::AtomMatchM {lvalue})

to_string()

toString( (AtomMatchM)arg1) -> object :

C++ signature :

QString toString(SireMol::AtomMatchM {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

update((AtomMatchM)arg1, (MoleculeView)molview) → None :
C++ signature :

void update(SireMol::AtomMatchM {lvalue},SireMol::MoleculeView)

update( (AtomMatchM)arg1, (MoleculeView)moldata) -> None :

C++ signature :

void update(SireMol::AtomMatchM {lvalue},SireMol::MoleculeData)

update( (AtomMatchM)arg1, (Molecules)molecules) -> None :

C++ signature :

void update(SireMol::AtomMatchM {lvalue},SireMol::Molecules)

update( (AtomMatchM)arg1, (SelectorMol)molecules) -> None :

C++ signature :

void update(SireMol::AtomMatchM {lvalue},SireMol::SelectorMol)

what((AtomMatchM)arg1) → str :
C++ signature :

char const* what(SireMol::AtomMatchM {lvalue})

class sire.mol.AtomName

This class holds the name of an atom. This can be used to identify an atom within a residue.

Author: Christopher Woods

assign((AtomName)arg1, (AtomName)other) → AtomName :
C++ signature :

SireMol::AtomName {lvalue} assign(SireMol::AtomName {lvalue},SireMol::AtomName)

clone((AtomName)arg1) → AtomName :
C++ signature :

SireMol::AtomName clone(SireMol::AtomName)

hash((AtomName)arg1) → int :
C++ signature :

unsigned int hash(SireMol::AtomName {lvalue})

is_null()

isNull( (AtomName)arg1) -> bool :

C++ signature :

bool isNull(SireMol::AtomName {lvalue})

map((AtomName)arg1, (MolInfo)molinfo) → object :
C++ signature :

QList<SireMol::AtomIdx> map(SireMol::AtomName {lvalue},SireMol::MolInfo)

to_string()

toString( (AtomName)arg1) -> object :

C++ signature :

QString toString(SireMol::AtomName {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((AtomName)arg1) → str :
C++ signature :

char const* what(SireMol::AtomName {lvalue})

class sire.mol.AtomNum

This ID number is used to identify an atom by the user-supplied atom number (this is typically the number assigned to the atom from the PDB or other coordinate file)

Be careful not to confuse this with AtomID, which is the index of the atom in the residue or CutGroup (e.g. the fifth atom in the residue would have AtomID 4 but has whatever AtomNum the user supplied.

Author: Christopher Woods

assign((AtomNum)arg1, (AtomNum)other) → AtomNum :
C++ signature :

SireMol::AtomNum {lvalue} assign(SireMol::AtomNum {lvalue},SireMol::AtomNum)

clone((AtomNum)arg1) → AtomNum :
C++ signature :

SireMol::AtomNum clone(SireMol::AtomNum)

hash((AtomNum)arg1) → int :
C++ signature :

unsigned int hash(SireMol::AtomNum {lvalue})

is_null()

isNull( (AtomNum)arg1) -> bool :

C++ signature :

bool isNull(SireMol::AtomNum {lvalue})

map((AtomNum)arg1, (MolInfo)molinfo) → object :
C++ signature :

QList<SireMol::AtomIdx> map(SireMol::AtomNum {lvalue},SireMol::MolInfo)

to_string()

toString( (AtomNum)arg1) -> object :

C++ signature :

QString toString(SireMol::AtomNum {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((AtomNum)arg1) → str :
C++ signature :

char const* what(SireMol::AtomNum {lvalue})

class sire.mol.BondOrder

This class represents a bond type (e.g. single, double etc.)

Author: Christopher Woods

aromatic_bond()
aromaticBond() -> BondOrder :

Return an aromatic bond

C++ signature :

SireMol::BondOrder aromaticBond()

assign((BondOrder)arg1, (BondOrder)other) → BondOrder :
C++ signature :

SireMol::BondOrder {lvalue} assign(SireMol::BondOrder {lvalue},SireMol::BondOrder)

clone((BondOrder)arg1) → BondOrder :
C++ signature :

SireMol::BondOrder clone(SireMol::BondOrder)

double_bond()
doubleBond() -> BondOrder :

Return a double bond

C++ signature :

SireMol::BondOrder doubleBond()

from_rdkit()
fromRDKit( (object)value) -> BondOrder :

Construct from a string representation of the RDKit type

C++ signature :

SireMol::BondOrder fromRDKit(QString)

from_s_d_f()
fromSDF( (int)value) -> BondOrder :

Construct from the the passed SDF number

C++ signature :

SireMol::BondOrder fromSDF(int)

is_defined()
isDefined( (BondOrder)arg1) -> bool :

Return whether or not the bond type is defined

C++ signature :

bool isDefined(SireMol::BondOrder {lvalue})

is_double()
isDouble( (BondOrder)arg1) -> bool :

Return whether or not this is a double bond

C++ signature :

bool isDouble(SireMol::BondOrder {lvalue})

is_single()
isSingle( (BondOrder)arg1) -> bool :

Return whether or not this is a single bond

C++ signature :

bool isSingle(SireMol::BondOrder {lvalue})

is_triple()
isTriple( (BondOrder)arg1) -> bool :

Return whether or not this is a triple bond

C++ signature :

bool isTriple(SireMol::BondOrder {lvalue})

isromatic()
isAromatic( (BondOrder)arg1) -> bool :

Return whether or not this is an aromatic bond

C++ signature :

bool isAromatic(SireMol::BondOrder {lvalue})

single_bond()
singleBond() -> BondOrder :

Return a single bond

C++ signature :

SireMol::BondOrder singleBond()

to_rdkit()
toRDKit( (BondOrder)arg1) -> object :

Return as a string representation of a RDKit bond order

C++ signature :

QString toRDKit(SireMol::BondOrder {lvalue})

to_s_d_f()
toSDF( (BondOrder)arg1) -> int :

Return the SDF-format value for this bond

C++ signature :

int toSDF(SireMol::BondOrder {lvalue})

to_string()

toString( (BondOrder)arg1) -> object :

C++ signature :

QString toString(SireMol::BondOrder {lvalue})

triple_bond()
tripleBond() -> BondOrder :

Return a triple bond

C++ signature :

SireMol::BondOrder tripleBond()

typename()

typeName() -> str :

C++ signature :

char const* typeName()

undefined_bond()
undefinedBond() -> BondOrder :

Return an undefined bond

C++ signature :

SireMol::BondOrder undefinedBond()

value((BondOrder)arg1) → int :

Return the bond type (0 to number of bonds)

C++ signature :

int value(SireMol::BondOrder {lvalue})

value_as_double()
valueAsDouble( (BondOrder)arg1) -> float :
Return the bond order as a double precision number. This matches

the value that would be returned by RDKit

C++ signature :

double valueAsDouble(SireMol::BondOrder {lvalue})

class sire.mol.Chain

This class represents a Chain in a Molecule.

Author: Christopher Woods

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_contains_metadata()
assertContainsMetadata( (Chain)arg1, (PropertyName)metakey) -> None :

Assert that this chain has an ChainProperty piece of metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

void assertContainsMetadata(SireMol::Chain {lvalue},SireBase::PropertyName)

assertContainsMetadata( (Chain)arg1, (PropertyName)key, (PropertyName)metakey) -> None :

Assert that the property at key key has an ChainProperty piece of metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

void assertContainsMetadata(SireMol::Chain {lvalue},SireBase::PropertyName,SireBase::PropertyName)

assert_contains_property()
assertContainsProperty( (Chain)arg1, (PropertyName)key) -> None :

Assert that this chain has an ChainProperty at key key Throw: SireBase::missing_property

C++ signature :

void assertContainsProperty(SireMol::Chain {lvalue},SireBase::PropertyName)

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((Chain)arg1, (Chain)other) → Chain :
C++ signature :

SireMol::Chain {lvalue} assign(SireMol::Chain {lvalue},SireMol::Chain)

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})

atom_idxs()
atomIdxs( (Chain)arg1) -> object :

Return the indicies of the atoms in this chain, in the order that they appear in this chain

C++ signature :

QList<SireMol::AtomIdx> atomIdxs(SireMol::Chain {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((Chain)arg1) → Chain :
C++ signature :

SireMol::Chain clone(SireMol::Chain)

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})

contains((Chain)arg1, (AtomIdx)atomidx) → bool :
Return whether or not this chain contains the atom

at index atomidx

C++ signature :

bool contains(SireMol::Chain {lvalue},SireMol::AtomIdx)

contains( (Chain)arg1, (AtomID)atomid) -> bool :

Return whether or not this chain contains all of the atoms identified by the ID atomid

C++ signature :

bool contains(SireMol::Chain {lvalue},SireMol::AtomID)

contains( (Chain)arg1, (ResIdx)residx) -> bool :

Return whether or not this chain contains the residue at index residx

C++ signature :

bool contains(SireMol::Chain {lvalue},SireMol::ResIdx)

contains( (Chain)arg1, (ResID)resid) -> bool :

Return whether or not this chain contains all of the residues identified by the ID resid

C++ signature :

bool contains(SireMol::Chain {lvalue},SireMol::ResID)

count()
nResidues( (Chain)arg1) -> int :

Return the number of residues in this chain

C++ signature :

int nResidues(SireMol::Chain {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)

edit((Chain)arg1) → ChainEditor :

Return an editor that can edit this chain

C++ signature :

SireMol::ChainEditor edit(SireMol::Chain {lvalue})

energy(other=None, map=None)

Calculate the total energy of the molecule view(s) in this collection.

other: (view or views, optional)

An optional second view (or collection of views). If this is passed, then the energy between the views in this collections and others will be calculated.

map: (dictionary, optional)

An optional property map that will be used to find or map the properties used for this energy calculation.

Returns:

Returns an energy, with attached components for the sub-components (if any) for this energy.

Return type:

sire.units.GeneralUnit (energy per quantity)

evaluate((Chain)arg1) → Evaluator :

Return an evaluator that can evaluate properties of this chain

C++ signature :

SireMol::Evaluator evaluate(SireMol::Chain {lvalue})

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)

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})

hasLinks( (MoleculeView)arg1) -> bool :

Return whether or not this molecule has any property links

C++ signature :

bool hasLinks(SireMol::MoleculeView {lvalue})

has_metadata()
hasMetadata( (Chain)arg1, (PropertyName)metakey) -> bool :

Return whether or not there is a ChainProperty at metakey metakey

C++ signature :

bool hasMetadata(SireMol::Chain {lvalue},SireBase::PropertyName)

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

Return whether the metadata at metakey metakey for the property at key key is a ChainProperty Throw: SireBase::missing_property

C++ signature :

bool hasMetadata(SireMol::Chain {lvalue},SireBase::PropertyName,SireBase::PropertyName)

has_property()
hasProperty( (Chain)arg1, (PropertyName)key) -> bool :

Return whether or not there is a ChainProperty at key key

C++ signature :

bool hasProperty(SireMol::Chain {lvalue},SireBase::PropertyName)

index((Chain)arg1) → ChainIdx :

Return the index of this chain in the molecule

C++ signature :

SireMol::ChainIdx index(SireMol::Chain {lvalue})

intersects((Chain)arg1, (AtomID)atomid) → bool :
Return whether or not this chain contains some of

the atoms identified by the ID atomid

C++ signature :

bool intersects(SireMol::Chain {lvalue},SireMol::AtomID)

intersects( (Chain)arg1, (ResID)resid) -> bool :

Return whether or not this chain contains some of the residues identified by the ID resid

C++ signature :

bool intersects(SireMol::Chain {lvalue},SireMol::ResID)

invert((Chain)arg1) → Selector_Chain_ :

Return a selector that has everything except this view

C++ signature :

SireMol::Selector<SireMol::Chain> invert(SireMol::Chain {lvalue})

is_empty()
isEmpty( (Chain)arg1) -> bool :

Is this chain empty?

C++ signature :

bool isEmpty(SireMol::Chain {lvalue})

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)

metadata_keys()
metadataKeys( (Chain)arg1) -> object :

Return the metakeys of all ChainProperty metadata

C++ signature :

QStringList metadataKeys(SireMol::Chain {lvalue})

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

Return the metakeys of all ChainProperty metadata for the property at key key Throw: SireBase::missing_property

C++ signature :

QStringList metadataKeys(SireMol::Chain {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)

move((Chain)arg1) → Mover_Chain_ :

Return an object that can move a copy of this chain

C++ signature :

SireMol::Mover<SireMol::Chain> move(SireMol::Chain {lvalue})

name((Chain)arg1) → ChainName :

Return the name of this chain

C++ signature :

SireMol::ChainName name(SireMol::Chain {lvalue})

num_atoms()
nAtoms( (Chain)arg1) -> int :

Return the number of atoms in this Chain

C++ signature :

int nAtoms(SireMol::Chain {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( (Chain)arg1) -> int :

Return the number of residues in this chain

C++ signature :

int nResidues(SireMol::Chain {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})

number((Chain)arg1) → ChainIdx :

Return the number of this chain (same as its index)

C++ signature :

SireMol::ChainIdx number(SireMol::Chain {lvalue})

property_as_property()
propertyAsProperty( (Chain)arg1, (PropertyName)key) -> object :

Return the specified property as a PropertyPtr

C++ signature :

SireBase::PropPtr<SireBase::Property> propertyAsProperty(SireMol::Chain {lvalue},SireBase::PropertyName)

property_as_variant()
propertyAsVariant( (Chain)arg1, (PropertyName)key) -> object :

Return the specified property as a QVariant

C++ signature :

QVariant propertyAsVariant(SireMol::Chain {lvalue},SireBase::PropertyName)

property_keys()
propertyKeys( (Chain)arg1) -> object :

Return the keys of all ChainProperty properties

C++ signature :

QStringList propertyKeys(SireMol::Chain {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)

res_idxs()
resIdxs( (Chain)arg1) -> object :

Return the list of indicies of residues that are in this chain, in the order they appear in this chain

C++ signature :

QList<SireMol::ResIdx> resIdxs(SireMol::Chain {lvalue})

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( (Chain)arg1) -> bool :

Is this chain the entire molecule?

C++ signature :

bool selectedAll(SireMol::Chain {lvalue})

selection((Chain)arg1) → AtomSelection :

Return the atoms that are in this chain

C++ signature :

SireMol::AtomSelection selection(SireMol::Chain {lvalue})

selector((Chain)arg1) → Selector_Chain_ :

Return a selector that change the selection of chains

C++ signature :

SireMol::Selector<SireMol::Chain> selector(SireMol::Chain {lvalue})

size()
nResidues( (Chain)arg1) -> int :

Return the number of residues in this chain

C++ signature :

int nResidues(SireMol::Chain {lvalue})

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( (Chain)arg1) -> object :

C++ signature :

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

to_string()
toString( (Chain)arg1) -> object :

Return a string representation of this chain

C++ signature :

QString toString(SireMol::Chain {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

update((Chain)arg1, (MoleculeView)moldata) → None :

Update this chain with the passed molecule data. Throw: SireError::incompatible_error

C++ signature :

void update(SireMol::Chain {lvalue},SireMol::MoleculeData)

class sire.mol.ChainIdx

This is an ID object that is used to index atoms (e.g. index in a list or array, or in a molecule).

Author: Christopher Woods

assign((ChainIdx)arg1, (ChainIdx)other) → ChainIdx :
C++ signature :

SireMol::ChainIdx {lvalue} assign(SireMol::ChainIdx {lvalue},SireMol::ChainIdx)

clone((ChainIdx)arg1) → ChainIdx :
C++ signature :

SireMol::ChainIdx clone(SireMol::ChainIdx)

hash((ChainIdx)arg1) → int :
C++ signature :

unsigned int hash(SireMol::ChainIdx {lvalue})

is_null()

isNull( (ChainIdx)arg1) -> bool :

C++ signature :

bool isNull(SireMol::ChainIdx {lvalue})

map((ChainIdx)arg1, (MolInfo)molinfo) → object :
C++ signature :

QList<SireMol::ChainIdx> map(SireMol::ChainIdx {lvalue},SireMol::MolInfo)

static null() → ChainIdx :
C++ signature :

SireMol::ChainIdx null()

to_string()

toString( (ChainIdx)arg1) -> object :

C++ signature :

QString toString(SireMol::ChainIdx {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((ChainIdx)arg1) → str :
C++ signature :

char const* what(SireMol::ChainIdx {lvalue})

class sire.mol.ChainName

This class holds the name of an atom. This can be used to identify an atom within a residue.

Author: Christopher Woods

assign((ChainName)arg1, (ChainName)other) → ChainName :
C++ signature :

SireMol::ChainName {lvalue} assign(SireMol::ChainName {lvalue},SireMol::ChainName)

clone((ChainName)arg1) → ChainName :
C++ signature :

SireMol::ChainName clone(SireMol::ChainName)

hash((ChainName)arg1) → int :
C++ signature :

unsigned int hash(SireMol::ChainName {lvalue})

is_null()

isNull( (ChainName)arg1) -> bool :

C++ signature :

bool isNull(SireMol::ChainName {lvalue})

map((ChainName)arg1, (MolInfo)molinfo) → object :
C++ signature :

QList<SireMol::ChainIdx> map(SireMol::ChainName {lvalue},SireMol::MolInfo)

to_string()

toString( (ChainName)arg1) -> object :

C++ signature :

QString toString(SireMol::ChainName {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((ChainName)arg1) → str :
C++ signature :

char const* what(SireMol::ChainName {lvalue})

class sire.mol.Cursor(molecule=None, internal=None, map=None)[source]

This class provides a cursor that can be used to navigate through and edit the properties of Molecules. This makes the whole getting and setting of properties more pythonic in writing style, while also saving some typing.

angle(*args, **kwargs)[source]

Return the Cursor for the specified angle.

angles(*args, **kwargs)[source]

Return cursors for all of the angles in this view or, if ‘id’ is supplied, the angles in this view that match ‘id’

apply(func, *args, **kwargs)[source]

Apply the passed function (with optional position and keyword arguments) to this Cursor. As the function is intended to use the Cursor to edit molecules, only this Cursor will be returned. This lets you run apply(…).commit() as a single line.

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:

func (str or function) – The function to be called, or the name of the function to be called.

Returns:

This cursor

Return type:

Cursor

atom(i)[source]

Return the atom in the molecule that matches the passed ID

atoms(id=None)[source]

Return cursors for all of atoms in this view, of, if ‘id’ is supplied, the atoms in this view that match ‘id’

bond(*args, **kwargs)[source]

Return the Cursor for the specified bond.

bonds(*args, **kwargs)[source]

Return cursors for all of the bonds in this view or, if ‘id’ is supplied, the bonds in this view that match ‘id’

chain(i=None)[source]

Return the chain in the molecule that matches the passed ID. If ‘i’ is None, then this returns the chain that contains this atom (if this is an atom)

chains(id=None)[source]

Return cursors for all of chains in this view, of, if ‘id’ is supplied, the chains in this view that match ‘id’

commit()[source]

Commit all of the changes and return the newly edited molecule (or MoleculeView)

delete(key)[source]

Remove the property associated with the key ‘key’

delete_frame(*args, **kwargs)[source]

Call the delete_frame function on the contained view, passing the arguments directly. This is equivalent to calling delete_frame directly on the contained view.

dihedral(*args, **kwargs)[source]

Return the Cursor for the specified dihedral.

dihedrals(*args, **kwargs)[source]

Return cursors for all of the dihedrals in this view or, if ‘id’ is supplied, the dihedrals in this view that match ‘id’

evaluate(*args, **kwargs)[source]

Return a sire.mol.Evaluator for the view in this cursor

get(key)[source]

Return the property associated with key ‘key’

get_index()[source]

Return the index of the current view. This returns it as as simple number (i.e. not as an AtomIdx, ResIdx etc)

get_name()[source]

Return the name of the current view. Note that this returns the name as a simple string (it is not a AtomName, ResName etc)

get_number()[source]

Return the number of the current view. This returns the number as a simple number (it is not a AtomNum, ResNum etc)

id()[source]

Return the ID of this view (e.g. AtomIdx, MolNum, BondID)

improper(*args, **kwargs)[source]

Return the Cursor for the specified improper.

impropers(*args, **kwargs)[source]

Return cursors for all of the impropers in this view or, if ‘id’ is supplied, the impropers in this view that match ‘id’

property index

Return the index of the current view. This returns it as as simple number (i.e. not as an AtomIdx, ResIdx etc)

is_angle()[source]

Return whether this is pointing to an Angle

is_atom()[source]

Return whether this is pointing to an Atom

is_bond()[source]

Return whether this is pointing to a Bond

is_chain()[source]

Return whether this is pointing to a Chain

is_dihedral()[source]

Return whether this is pointing to a Dihedral

is_improper()[source]

Return whether this is pointing to an Improper

is_internal()[source]

Return whether or not this is a view of an internal (i.e. bond, angle, dihedral or improper)

is_molecule()[source]

Return whether this is pointing to a Molecule

is_residue()[source]

Return whether this is pointing to a Residue

is_same_editor(other)[source]

Return whether this Cursor is using the same editor to edit the molecule as ‘other’. This returns true if the underlying editor for both cursors is the same, i.e. changes made by one cursor would be seen and be editable by the other cursor.

is_segment()[source]

Return whether this is pointing to a Segment

load_frame(*args, **kwargs)[source]

Call the load_frame function on the contained view, passing the arguments directly. This is equivalent to calling load_frame directly on the contained view.

make_whole(center=None, map=None)[source]

Make all of the atoms operated on by this cursor whole (they won’t be broken across a periodic box boundary) Use ‘map’ to specify the property map used to find the coordinates and space properties. Pass in ‘center’ to specify the center of the periodic box into which they should be wrapped.

molecule()[source]

Return the molecule

property name

Return the name of the current view. Note that this returns the name as a simple string (it is not a AtomName, ResName etc)

num_frames()[source]

Return the number of trajectory frames contained by the molecule

property number

Return the number of the current view. This returns the number as a simple number (it is not a AtomNum, ResNum etc)

parent()[source]

Return the cursor of the parent object (e.g. parent residue of the atom, parent chain of the residue, parent molecule of the bond etc. This will return the Cursor for the whole molecule if there isn’t a suitable parent

properties()[source]

Return the sire.base.Properties object for the properties of the current view

renumber()[source]

Renumber the underlying molecule holding this view. This makes the molecule distinct from its other copies (molecules are uniquely idenfied by their number). You don’t have control over the number - this is generated randomly and is guaranteed to not be a number of a molecule that already exists

residue(i=None)[source]

Return the residue in the molecule that matches the passed ID. If ‘i’ is None, then this returns the residue that contains this atom (if this is an atom)

residues(id=None)[source]

Return cursors for all of residues in this view, of, if ‘id’ is supplied, the residues in this view that match ‘id’

rotate(angle=None, axis=None, center=None, quaternion=None, matrix=None, rotate_velocities: bool = None, map=None)[source]

Rotate all of the atoms operated on by this cursor by the passed arguments. Use ‘map’ to specify the property map to use to find the coordinates property.

There are many ways to specify the rotation, hence the number of named arguments:

angle: (float or angle)

The angle to rotate by - this is interpreted as degrees if you pass in a float. Otherwise use sire.units.degrees or sire.units.radians to specify the angle unit. This is superseded by the quaternion or matrix arguments.

axis: sire.maths.Vector (or anything that can convert to a Vector)

The vector about which to rotate. If this is not specified, and no other rotation specification is used, then the rotation is about the z axis. This is superseded by the quaternion or matrix arguments.

center: sire.maths.Vector (or anything that can convert to a Vector)

The center for the rotation. If this isn’t passed then the center of mass of the atoms operated on by this cursor is used.

quaternion: sire.maths.Quaternion

The Quaternion description of the rotation. Note that, if you pass this, then the angle, axis and matrix arguments will be ignored.

matrix: sire.maths.Matrix

The 3x3 rotation matrix that describes the rotation. Note that, if you pass this, then the angle and axis arguments will be ignored. This is superseded by the quaternion argument.

rotate_velocities: bool

Whether or not to rotate the velocities as well as the coordinates (default True)

map: None, dict or sire.base.PropertyMap

The property map used to find the coordinates property

save_frame(*args, **kwargs)[source]

Call the save_frame function on the contained view, passing the arguments directly. This is equivalent to calling save_frame directly on the contained view.

segment(i=None)[source]

Return the segment in the molecule that matches the passed ID. If ‘i’ is None, then this returns the segment that contains this atom (if this is an atom)

segments(id=None)[source]

Return cursors for all of segments in this view, of, if ‘id’ is supplied, the segments in this view that match ‘id’

set(key, value)[source]

Set the property associated with key ‘key’ to the passed value

set_name(name)[source]

Set the name of the object in the current view

set_number(number)[source]

Set the number of the object in the current view

transform(transform, map=None)[source]

Move all of the atoms operated on by this cursor by the passed transformation (a sr.maths.Transform object). Use ‘map’ to specify the property map used to find the coordinates property.

translate(*args, map=None)[source]

Translate all of the atoms operated on by this cursor by the passed arguments (these are converted automatically to a sr.maths.Vector). Use ‘map’ to specify the property map to use to find the coordinates property

type()[source]

Return the type of this Cursor (e.g. ‘atom’, ‘bond’, ‘residue’, ‘chain’, ‘segment’ or ‘molecule’)

view()[source]

Return the view underpinning this cursor. This is actually the same as committing the changes

class sire.mol.Cursors(parent: Cursor, cursors: List[Cursor], view)[source]

This class holds a list of Cursors. It provides some convenience functions that make working with lists of Cursor objects easier.

This includes being able to commit back to the Cursor that created the list, plus being able to apply a function to each Cursor in the list

angle(*args, **kwargs)[source]

Return the Cursor for the specified angle.

angles(*args, **kwargs)[source]

Return cursors for all of the angles in this view or, if ‘id’ is supplied, the angles in this view that match ‘id’

apply(func, *args, **kwargs)[source]

Apply the passed function (with optional position and keyword arguments) to all of the cursors in this list of Cursors (i.e. everything except the parent). As the function is intended to use the Cursor to edit molecules, only this Cursors object will be returned.

This lets you run apply(…).commit() as a single line.

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:

func (str or function) – The function to be called, or the name of the function to be called.

Returns:

This list of cursors

Return type:

Cursors

atom(i)[source]

Return the atom in the molecule that matches the passed ID

atoms(id=None)[source]

Return cursors for all of atoms in this view, of, if ‘id’ is supplied, the atoms in this view that match ‘id’

bond(*args, **kwargs)[source]

Return the Cursor for the specified bond.

bonds(*args, **kwargs)[source]

Return cursors for all of the bonds in this view or, if ‘id’ is supplied, the bonds in this view that match ‘id’

chain(i=None)[source]

Return the chain in the molecule that matches the passed ID. If ‘i’ is None, then this returns the chain that contains this atom (if this is an atom)

chains(id=None)[source]

Return cursors for all of chains in this view, of, if ‘id’ is supplied, the chains in this view that match ‘id’

commit()[source]

Commit all of the changes and return the newly edited molecule (or MoleculeView). This commits on the parent Cursor that was used to create this list, e.g.

>>> mol.cursor().atoms().commit()

will commit and return the updated molecule (mol).

This is equivalent to self.parent().commit()

delete(key)[source]

Remove the property associated with the key ‘key’

delete_frame(*args, **kwargs)[source]

Call ‘delete_frame’ with these arguments on all contained cursors

dihedral(*args, **kwargs)[source]

Return the Cursor for the specified dihedral.

dihedrals(*args, **kwargs)[source]

Return cursors for all of the dihedrals in this view or, if ‘id’ is supplied, the dihedrals in this view that match ‘id’

get(key)[source]

Return the property associated with key ‘key’

improper(*args, **kwargs)[source]

Return the Cursor for the specified improper.

impropers(*args, **kwargs)[source]

Return cursors for all of the impropers in this view or, if ‘id’ is supplied, the impropers in this view that match ‘id’

invert()[source]

Return the inverse view of this cursor (i.e. all views that are not selected - same as view.invert())

is_same_editor(other)[source]

Return whether this is using the same editor to edit the molecule as ‘other’. This returns true if the underlying editor for both cursors is the same, i.e. changes made by one cursor would be seen and be editable by the other cursor.

load_frame(*args, **kwargs)[source]

Call load_frame with these arguments on all contained cursors

make_whole(center=None, map=None)[source]

Make all of the atoms operated on by this cursor whole (they won’t be broken across a periodic box boundary) Use ‘map’ to specify the property map used to find the coordinates and space properties. Pass in ‘center’ to specify the center of the periodic box into which they should be wrapped.

molecule()[source]

Return the molecule

num_frames()[source]

Return the number of frames in the trajectory held by this molecule

parent()[source]

Return the parent cursor

residue(i=None)[source]

Return the residue in the molecule that matches the passed ID. If ‘i’ is None, then this returns the residue that contains this atom (if this is an atom)

residues(id=None)[source]

Return cursors for all of residues in this view, of, if ‘id’ is supplied, the residues in this view that match ‘id’

rotate(angle=None, axis=None, center=None, quaternion=None, matrix=None, rotate_velocities: bool = None, map=None)[source]

Rotate all of the atoms operated on by this cursor by the passed arguments. Use ‘map’ to specify the property map to use to find the coordinates property.

There are many ways to specify the rotation, hence the number of named arguments:

angle: (float or angle)

The angle to rotate by - this is interpreted as degrees if you pass in a float. Otherwise use sire.units.degrees or sire.units.radians to specify the angle unit. This is superseded by the quaternion or matrix arguments.

axis: sire.maths.Vector (or anything that can convert to a Vector)

The vector about which to rotate. If this is not specified, and no other rotation specification is used, then the rotation is about the z axis. This is superseded by the quaternion or matrix arguments.

center: sire.maths.Vector (or anything that can convert to a Vector)

The center for the rotation. If this isn’t passed then the center of mass of the atoms operated on by this cursor is used.

quaternion: sire.maths.Quaternion

The Quaternion description of the rotation. Note that, if you pass this, then the angle, axis and matrix arguments will be ignored.

matrix: sire.maths.Matrix

The 3x3 rotation matrix that describes the rotation. Note that, if you pass this, then the angle and axis arguments will be ignored. This is superseded by the quaternion argument.

rotate_velocities: bool

Whether or not to rotate the velocities as well as the coordinates (default True)

map: None, dict or sire.base.PropertyMap

The property map used to find the coordinates property

save_frame(*args, **kwargs)[source]

Call ‘save_frame’ with these arguments on all contained cursors

segment(i=None)[source]

Return the segment in the molecule that matches the passed ID. If ‘i’ is None, then this returns the segment that contains this atom (if this is an atom)

segments(id=None)[source]

Return cursors for all of segments in this view, of, if ‘id’ is supplied, the segments in this view that match ‘id’

set(key, value)[source]

Set the property associated with key ‘key’ to the passed value

transform(transform, map=None)[source]

Move all of the atoms operated on by this cursor by the passed transformation (a sr.maths.Transform object). Use ‘map’ to specify the property map used to find the coordinates property.

translate(*args, map=None)[source]

Translate all of the atoms operated on by these cursors by the passed arguments (these are converted automatically to a sr.maths.Vector). Use ‘map’ to specify the property map to use to find the coordinates property

view()[source]

Return the view underpinning this cursor. This is the same as calling ‘.commit()’

class sire.mol.CursorsM(parent=None, map=None)[source]

This class holds a list of Cursor/Cursors that operate across multiple molecules. This allows you to perform editing operations across many molecules at the same time.

angle(*args, **kwargs)[source]

Return the Cursor for the specified angle.

angles(*args, **kwargs)[source]

Return cursors for all of the angles in this view or, if ‘id’ is supplied, the angles in this view that match ‘id’

apply(func, *args, **kwargs)[source]

Apply the passed function (with optional position and keyword arguments) to all of the cursors in this list of Cursors. As the function is intended to use the Cursor to edit molecules, only this Cursors object will be returned.

This lets you run apply(…).commit() as a single line.

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:

func (str or function) – The function to be called, or the name of the function to be called.

Returns:

This list of cursors

Return type:

Cursors

atom(i)[source]

Return the atom in the molecule that matches the passed ID

atoms(id=None)[source]

Return cursors for all of atoms in this view, or, if ‘id’ is supplied, the atoms in this view that match ‘id’

bond(*args, **kwargs)[source]

Return the Cursor for the specified bond.

bonds(*args, **kwargs)[source]

Return cursors for all of the bonds in this view or, if ‘id’ is supplied, the bonds in this view that match ‘id’

chain(i=None)[source]

Return the chain in the molecule that matches the passed ID. If ‘i’ is None, then this returns the chain that contains this atom (if this is an atom)

chains(id=None)[source]

Return cursors for all of chains in this view, or, if ‘id’ is supplied, the chains in this view that match ‘id’

commit()[source]

Commit all of the changes and return the newly edited multi-molecule view.

delete(key)[source]

Remove the property associated with the key ‘key’

delete_frame(*args, **kwargs)[source]

Call the ‘delete_frame’ function with these arguments on all contained cursors

dihedral(*args, **kwargs)[source]

Return the Cursor for the specified dihedral.

dihedrals(*args, **kwargs)[source]

Return cursors for all of the dihedrals in this view or, if ‘id’ is supplied, the dihedrals in this view that match ‘id’

get(key)[source]

Return the property associated with key ‘key’

improper(*args, **kwargs)[source]

Return the Cursor for the specified improper.

impropers(*args, **kwargs)[source]

Return cursors for all of the impropers in this view or, if ‘id’ is supplied, the impropers in this view that match ‘id’

invert()[source]

Return the inverse view of this cursor (i.e. all views that are not selected - same as view.invert())

load_frame(*args, **kwargs)[source]

Call the ‘load_frame’ function with these arguments on all contained cursors

make_whole(center=None, map=None)[source]

Make all of the atoms operated on by this cursor whole (they won’t be broken across a periodic box boundary) Use ‘map’ to specify the property map used to find the coordinates and space properties. Pass in ‘center’ to specify the center of the periodic box into which they should be wrapped.

molecule(i=None)[source]

Return the molecule

molecules(id=None)[source]

Return cursors for all of the molecules in this view, or, if ‘id’ is supplied, the molecules in this view that match ‘id’

num_frames()[source]

Return the number of frames in the trajectories held by this cursor

residue(i=None)[source]

Return the residue in the molecule that matches the passed ID. If ‘i’ is None, then this returns the residue that contains this atom (if this is an atom)

residues(id=None)[source]

Return cursors for all of residues in this view, or, if ‘id’ is supplied, the residues in this view that match ‘id’

rotate(angle=None, axis=None, center=None, quaternion=None, matrix=None, rotate_velocities: bool = None, map=None)[source]

Rotate all of the atoms operated on by this cursor by the passed arguments. Use ‘map’ to specify the property map to use to find the coordinates property.

There are many ways to specify the rotation, hence the number of named arguments:

angle: (float or angle)

The angle to rotate by - this is interpreted as degrees if you pass in a float. Otherwise use sire.units.degrees or sire.units.radians to specify the angle unit. This is superseded by the quaternion or matrix arguments.

axis: sire.maths.Vector (or anything that can convert to a Vector)

The vector about which to rotate. If this is not specified, and no other rotation specification is used, then the rotation is about the z axis. This is superseded by the quaternion or matrix arguments.

center: sire.maths.Vector (or anything that can convert to a Vector)

The center for the rotation. If this isn’t passed then the center of mass of the atoms operated on by this cursor is used.

quaternion: sire.maths.Quaternion

The Quaternion description of the rotation. Note that, if you pass this, then the angle, axis and matrix arguments will be ignored.

matrix: sire.maths.Matrix

The 3x3 rotation matrix that describes the rotation. Note that, if you pass this, then the angle and axis arguments will be ignored. This is superseded by the quaternion argument.

rotate_velocities: bool

Whether or not to rotate the velocities as well as the coordinates (default True)

map: None, dict or sire.base.PropertyMap

The property map used to find the coordinates property

save_frame(*args, **kwargs)[source]

Call the ‘save_frame’ function with these arguments on all contained cursors

segment(i=None)[source]

Return the segment in the molecule that matches the passed ID. If ‘i’ is None, then this returns the segment that contains this atom (if this is an atom)

segments(id=None)[source]

Return cursors for all of segments in this view, or, if ‘id’ is supplied, the segments in this view that match ‘id’

set(key, value)[source]

Set the property associated with key ‘key’ to the passed value

transform(transform, map=None)[source]

Move all of the atoms operated on by this cursor by the passed transformation (a sr.maths.Transform object). Use ‘map’ to specify the property map used to find the coordinates property.

translate(*args, map=None)[source]

Translate all of the atoms operated on by these cursors by the passed arguments (these are converted automatically to a sr.maths.Vector). Use ‘map’ to specify the property map to use to find the coordinates property

view()[source]

Return the view that underlies this Cursor. Note that this may not be updated to reflect the edits made. Use .commit() to get the up-to-date version of this view.

class sire.mol.Dynamics(mols=None, map=None, cutoff=None, cutoff_type=None, timestep=None, constraint=None, perturbable_constraint=None, schedule=None, lambda_value=None, swap_end_states=None, ignore_perturbations=None, shift_delta=None, shift_coulomb=None, coulomb_power=None, restraints=None, fixed=None, qm_engine=None, lambda_interpolate=None)[source]

Class that runs dynamics on the contained molecule(s). Note that this class is not designed to be constructed directly. You should only use this class by calling dynamics() on the molecules(s) you want to simulate

commit(return_as_system: bool = False)[source]

Commit the dynamics and return the molecules after the simulation. Normally this will return the same view of as was used for construction. If return_as_system is True, then this will return a System object instead.

constraint()[source]

Return the constraint used for the dynamics (e.g. constraining bonds involving hydrogens etc.)

context()[source]

Return the underlying OpenMM context that is being driven by this dynamics object.

current_energy()[source]

Return the current total energy

current_kinetic_energy()[source]

Return the current kinetic energy

current_potential_energy(lambda_values=None)[source]

Return the current potential energy.

If lambda_values is passed (which should be a list of lambda values) then this will return the energies (as a list) at the requested lambda values

current_space()[source]

Return the current space in which the simulation is being performed

current_step()[source]

Return the current number of completed steps of dynamics

current_time()[source]

Return the current amount of completed time of dynamics

elapsed_time()[source]

Return the total amount of elapsed time of dynamics. This will be the same as the current_time if this run started from time=0. Otherwise this will be the difference between the start time and the current time.

energy_trajectory(to_pandas: bool = False, to_alchemlyb: bool = False)[source]

Return the energy trajectory. This is the trajectory of energy values that have been captured during dynamics.

If ‘to_pandas’ is True, (the default) then this will be returned as a pandas dataframe, with times and energies in the defined default units

ensemble()[source]

Return the ensemble in which the simulation is being performed

get_constraints()[source]

Return the actual list of constraints that have been applied to this system. This is two lists of atoms, plus a list of distances. The constraint is atom0[i]::atom1[i] with distance[i]

get_lambda()[source]

Return the current value of lambda for this system. This does nothing if this isn’t a perturbable system

get_schedule()[source]

Return the LambdaSchedule that shows how lambda changes the underlying forcefield parameters in the system. Returns None if this isn’t a perturbable system.

info()[source]

Return the information that describes the forcefield that will be used for dynamics

integrator()[source]

Return the integrator that is used to run dynamics

minimise(max_iterations: int = 10000, tolerance: float = 10.0, max_restarts: int = 10, max_ratchets: int = 20, ratchet_frequency: int = 500, starting_k: float = 100.0, ratchet_scale: float = 2.0, max_constraint_error: float = 0.001)[source]

Internal method that runs minimisation on the molecules.

If the system is constrained, then a ratcheting algorithm is used. The constraints are replaced by harmonic restraints with an force constant based on tolerance and starting_k. Minimisation is performed, with the actual constrained bond lengths checked whenever minimisation converges, or when ratchet_frequency steps have completed (whichever is sooner). The force constant of the restraints is ratcheted up by ratchet_scale, and minimisation continues until there is no large change in energy or the maximum number of ratchets has been reached. In addition, at each ratchet, the actual bond lengths of constrained bonds are compared against the constrained values. If these have drifted too far away from the constrained values, then the minimisation is restarted, going back to the starting conformation and starting minimisation at one higher ratchet level. This will repeat a maximum of max_restarts times.

If a stable structure cannot be reached, then an exception will be raised.

Parameters:

  • max_iterations (int): The maximum number of iterations to run

  • tolerance (float): The tolerance to use for the minimisation

  • max_restarts (int): The maximum number of restarts before giving up

  • max_ratchets (int): The maximum number of ratchets before giving up

  • ratchet_frequency (int): The maximum number of steps between ratchets

  • starting_k (float): The starting value of k for the minimisation

  • ratchet_scale (float): The amount to scale k at each ratchet

  • max_constraint_error (float): The maximum error in the constraints in nm

perturbable_constraint()[source]

Return the perturbable constraint used for the dynamics (e.g. constraining bonds involving hydrogens etc.)

platform()[source]

Return the name of the OpenMM platform being used for dynamics

randomise_velocities(temperature=None, random_seed: int = None)[source]

Set the velocities to random values, drawn from the Boltzmann distribution for the current temperature.

Parameters:

  • (temperature) (- temperature) – the current temperature will be used

  • (int) (- random_seed) – a random seed will be generated

run(time, save_frequency=None, frame_frequency=None, energy_frequency=None, lambda_windows=None, save_velocities: bool = None, auto_fix_minimise: bool = True)[source]

Perform dynamics on the molecules.

Parameters

time: Time

The amount of simulation time to run, e.g. dynamics.run(sr.u(“5 ps”)) would perform 5 picoseconds of dynamics. The number of steps is determined automatically based on the current timestep (e.g. if the timestep was 1 femtosecond, then 5 picoseconds would involve running 5000 steps)

save_frequency: Time

The amount of simulation time between saving frames (coordinates, velocities) and energies from the trajectory. The number of timesteps between saves will depend on the timestep. For example, if save_frequency was 0.1 picoseconds and the timestep was 2 femtoseconds, then the coordinates would be saved every 50 steps of dynamics. Note that frame_frequency or energy_frequency can be used to override the frequency of saving frames or energies, if you want them to be saved with different frequencies. Specifying both will mean that the value of save_frequency will be ignored.

frame_frequency: Time

The amount of simulation time between saving frames (coordinates, velocities) from the trajectory. The number of timesteps between saves will depend on the timestep. For example, if save_frequency was 0.1 picoseconds and the timestep was 2 femtoseconds, then the coordinates would be saved every 50 steps of dynamics. The energies will be saved into this object and are accessible via the energy_trajectory function.

energy_frequency: Time

The amount of simulation time between saving energies (kinetic and potential) from the trajectory. The number of timesteps between saves will depend on the timestep. For example, if save_frequency was 0.1 picoseconds and the timestep was 2 femtoseconds, then the coordinates would be saved every 50 steps of dynamics. The energies will be saved into this object and are accessible via the energy_trajectory function.

lambda_windows: list[float]

The values of lambda for which the potential energy will be evaluated at every save. If this is None (the default) then only the current energy will be saved every energy_frequency time. If this is not None, then the potential energy for each of the lambda values in this list will be saved. Note that we always save the potential energy of the simulated lambda value, even if it is not in the list of lambda windows.

save_velocities: bool

Whether or not to save the velocities when running dynamics. By default this is False. Set this to True if you are interested in saving the velocities.

auto_fix_minimise: bool

Whether or not to automatically run minimisation if the trajectory exits with an error in the first few steps. Such failures often indicate that the system needs minimsing. This automatically runs the minimisation in these cases, and then runs the requested dynamics.

set_ensemble(ensemble)[source]

Set the ensemble that should be used for this simulation. Note that you can only use this function to change temperature and/or pressure values. You can’t change the fundemental ensemble of the simulation.

set_lambda(lambda_value: float, update_constraints: bool = True)[source]

Set the current value of lambda for this system. This will update the forcefield parameters in the context according to the data in the LambdaSchedule. This does nothing if this isn’t a perturbable system.

If update_constraints is True, then this will also update the constraint length of any constrained perturbable bonds. These will be set to the r0 value for that bond at this value of lambda. If update_constraints is False, then the constraint will not be changed.

set_pressure(pressure)[source]

Set the pressure for the dynamics. Note that this will only let you change the pressure of the ensemble. You can’t change its fundemental nature.

set_schedule(schedule)[source]

Set the LambdaSchedule that will be used to control how lambda changes the underlying forcefield parameters in the system. This does nothing if this isn’t a perturbable system

set_temperature(temperature, rescale_velocities: bool = True)[source]

Set the temperature for the dynamics. Note that this will only let you change the temperature of the ensemble. You can’t change its fundemental nature.

If rescale_velocities is True, then the velocities will be rescaled to the new temperature.

step(num_steps: int = 1)[source]

Simple function that performs num_steps steps of dynamics. This does not save any frames or energies - it is designed for times when you want to run a small number of steps quickly with minimal overhead.

step_speed(time_unit=None)[source]

Return the speed of this simulation in number of steps per second

time_speed(elapsed_unit=None, time_unit=None)[source]

Return the speed of this simulation in simulation time per real time (e.g. nanoseconds simulated per day)

timestep()[source]

Return the timestep used for this simulation

to_xml(f=None)[source]

Save the current state of the dynamics to XML. This is mostly used for debugging. This will return the XML string if ‘f’ is None. Otherwise it will write the XML to ‘f’ (either a filename, or a FILE object)

walltime()[source]

Return the walltime (real actual runtime) of dynamics, i.e. how much real time has been consumed by the simulation

class sire.mol.Element

This class is used to represent a chemical element. The implementation of this class is such that it is quick and easy to pass and copy Elements, while the storage requirements are very low (just a single pointer). The actual element data is held in a private ElementData class that is declared in elementdb.cpp

Author: Christopher Woods

actinide((Element)arg1) → bool :

Return whether or not this is an actinide

C++ signature :

bool actinide(SireMol::Element {lvalue})

alkali_earth_metal()
alkaliEarthMetal( (Element)arg1) -> bool :

Return whether or not this is an alkali earth metal (group 2)

C++ signature :

bool alkaliEarthMetal(SireMol::Element {lvalue})

alkali_metal()
alkaliMetal( (Element)arg1) -> bool :

Return whether or not this is an alkali metal (group 1 or 2)

C++ signature :

bool alkaliMetal(SireMol::Element {lvalue})

assign((Element)arg1, (Element)element) → Element :
C++ signature :

SireMol::Element assign(SireMol::Element {lvalue},SireMol::Element)

biological((Element)arg1) → bool :

Return whether or not this is biological (in first three periods and not a noble gas, or a halogen) (this does preclude iron, potassium and calcium, which are rather biological… :-)

C++ signature :

bool biological(SireMol::Element {lvalue})

biological_element()
biologicalElement( (object)name) -> Element :

Return a biological element that has been guessed from the passed name. Note that if no biological element was guessed, then the nearest non-biological element match is used. A biological element is one that is in the list of biological elements

C++ signature :

SireMol::Element biologicalElement(QString)

blue((Element)arg1) → float :

Return the blue colour components (0.0->1.0) for the colour of this element

C++ signature :

float blue(SireMol::Element {lvalue})

bond_order_radius()
bondOrderRadius( (Element)arg1) -> object :

Return the bond order radius

C++ signature :

SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0> bondOrderRadius(SireMol::Element {lvalue})

clone((Element)arg1) → Element :
C++ signature :

SireMol::Element clone(SireMol::Element)

color()

Return the color of the element, as a RGB triple (three integers from 0 to 255). Note that this is the color typically used to represent the element in a molecular viewer, not the actual color of the element.

color_name()

Return the color name of the element. Note that this is the color typically used to represent the element in a molecular viewer, not the actual color of the element.

covalent_radius()
covalentRadius( (Element)arg1) -> object :

Return the elements covalent radius

C++ signature :

SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0> covalentRadius(SireMol::Element {lvalue})

element_with_mass()
elementWithMass( (object)mass) -> Element :

Return an element which has the closest mass to mass (in atomic mass units, g mol-1)

C++ signature :

SireMol::Element elementWithMass(SireUnits::Dimension::PhysUnit<1, 0, 0, 0, 0, -1, 0>)

get_biological_elements()
getBiologicalElements() -> object :
Return a list of all of the elements that are considered

to be biological

C++ signature :

QList<SireMol::Element> getBiologicalElements()

green((Element)arg1) → float :

Return the green colour components (0.0->1.0) for the colour of this element

C++ signature :

float green(SireMol::Element {lvalue})

group((Element)arg1) → int :

Return the group number of this element (IUPAC group, from 1-18) (lanthanides and actinides have a group number of 0 - this should not be too big a problem as I would be surprised to hear of anyone using this code to simulate them…)

C++ signature :

int group(SireMol::Element {lvalue})

halogen((Element)arg1) → bool :

Return whether or not this is a halogen

C++ signature :

bool halogen(SireMol::Element {lvalue})

hex_color()

Return the color of the element as a hex string

lanthanide((Element)arg1) → bool :

Return whether or not this is a lanthanide

C++ signature :

bool lanthanide(SireMol::Element {lvalue})

mass((Element)arg1) → object :

Return the average mass of this element

C++ signature :

SireUnits::Dimension::PhysUnit<1, 0, 0, 0, 0, -1, 0> mass(SireMol::Element {lvalue})

max_bonds()
maxBonds( (Element)arg1) -> int :

Return the maximum number of simultaneous bonds that this element can form

C++ signature :

int maxBonds(SireMol::Element {lvalue})

name((Element)arg1) → object :

Return the name of the element in the local language

C++ signature :

QString name(SireMol::Element {lvalue})

noble_gas()
nobleGas( (Element)arg1) -> bool :

Return whether or not this is a noble gas

C++ signature :

bool nobleGas(SireMol::Element {lvalue})

num_protons()
nProtons( (Element)arg1) -> int :

Return the number of protons in the element

C++ signature :

int nProtons(SireMol::Element {lvalue})

period((Element)arg1) → int :

Return the period (the row number) of the element (IUPAC period, from 1-7)

C++ signature :

int period(SireMol::Element {lvalue})

rare_earth()
rareEarth( (Element)arg1) -> bool :

Return whether or not this is a rare earth element (e.g. a lanthanide or actinide)

C++ signature :

bool rareEarth(SireMol::Element {lvalue})

red((Element)arg1) → float :

Return the red colour components (0.0->1.0) for the colour of this element

C++ signature :

float red(SireMol::Element {lvalue})

reset_biological_elements()

resetBiologicalElements() -> None :

C++ signature :

void resetBiologicalElements()

set_element_is_biological()
setElementIsBiological( (Element)element) -> None :

Set that the passed element should be considered to be biological

C++ signature :

void setElementIsBiological(SireMol::Element)

set_element_is_not_biological()
setElementIsNotBiological( (Element)element) -> None :
Set that the passed element should considered to definitely

not be biological

C++ signature :

void setElementIsNotBiological(SireMol::Element)

symbol((Element)arg1) → object :

Return the IUPAC symbol for the element

C++ signature :

QString symbol(SireMol::Element {lvalue})

to_string()
toString( (Element)arg1) -> object :

Return a string representation of the Element

C++ signature :

QString toString(SireMol::Element {lvalue})

transition_metal()
transitionMetal( (Element)arg1) -> bool :

Return whether or not this is a transition metal

C++ signature :

bool transitionMetal(SireMol::Element {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

vdw_radius()
vdwRadius( (Element)arg1) -> object :

Return the van der waals radius

C++ signature :

SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0> vdwRadius(SireMol::Element {lvalue})

what((Element)arg1) → str :
C++ signature :

char const* what(SireMol::Element {lvalue})

class sire.mol.Minimisation(mols=None, map=None, cutoff=None, cutoff_type=None, schedule=None, lambda_value=None, swap_end_states=None, ignore_perturbations=None, shift_delta=None, shift_coulomb=None, coulomb_power=None, restraints=None, fixed=None)[source]

Class that runs minimisation on the contained molecule(s). Note that this class is not designed to be constructed directly. You should only use this class by calling minimisation() on the molecules(s) you want to minimise

commit(return_as_system: bool = False)[source]

Commit the minimisation to the molecules, returning the minimised molecules.

Normally this will return the same view of as was used for construction. If return_as_system is True, then this will return a System object instead.

constraint()[source]

Return the constraint used for the minimisation (e.g. constraining bonds involving hydrogens etc.)

get_constraints()[source]

Return the actual list of constraints that have been applied to this system. This is two lists of atoms, plus a list of distances. The constraint is atom0[i]::atom1[i] with distance[i]

get_log()[source]

Return the log of the minimisation

perturbable_constraint()[source]

Return the perturbable constraint used for the minimisation (e.g. constraining bonds involving hydrogens etc.)

run(max_iterations: int = 10000, tolerance: float = 10.0, max_restarts: int = 10, max_ratchets: int = 20, ratchet_frequency: int = 500, starting_k: float = 400.0, ratchet_scale: float = 10.0, max_constraint_error: float = 0.001, timeout: str = '300s')[source]

Internal method that runs minimisation on the molecules.

If the system is constrained, then a ratcheting algorithm is used. The constraints are replaced by harmonic restraints with an force constant based on tolerance and starting_k. Minimisation is performed, with the actual constrained bond lengths checked whenever minimisation converges, or when ratchet_frequency steps have completed (whichever is sooner). The force constant of the restraints is ratcheted up by ratchet_scale, and minimisation continues until there is no large change in energy or the maximum number of ratchets has been reached. In addition, at each ratchet, the actual bond lengths of constrained bonds are compared against the constrained values. If these have drifted too far away from the constrained values, then the minimisation is restarted, going back to the starting conformation and starting minimisation at one higher ratchet level. This will repeat a maximum of max_restarts times.

If a stable structure cannot be reached, then an exception will be raised.

Parameters:

  • max_iterations (int): The maximum number of iterations to run

  • tolerance (float): The tolerance to use for the minimisation

  • max_restarts (int): The maximum number of restarts before giving up

  • max_ratchets (int): The maximum number of ratchets before giving up

  • ratchet_frequency (int): The maximum number of steps between ratchets

  • starting_k (float): The starting value of k for the minimisation

  • ratchet_scale (float): The amount to scale k at each ratchet

  • max_constraint_error (float): The maximum error in the constraint in nm

  • timeout (float): The maximum time to run the minimisation for in seconds.

    A value of <=0 will disable the timeout.

class sire.mol.MolIdx

This is an ID object that is used to index molecules (e.g. index in a list or array, or in a MoleculeGroup).

Author: Christopher Woods

assign((MolIdx)arg1, (MolIdx)other) → MolIdx :
C++ signature :

SireMol::MolIdx {lvalue} assign(SireMol::MolIdx {lvalue},SireMol::MolIdx)

clone((MolIdx)arg1) → MolIdx :
C++ signature :

SireMol::MolIdx clone(SireMol::MolIdx)

hash((MolIdx)arg1) → int :
C++ signature :

unsigned int hash(SireMol::MolIdx {lvalue})

is_null()

isNull( (MolIdx)arg1) -> bool :

C++ signature :

bool isNull(SireMol::MolIdx {lvalue})

map((MolIdx)arg1, (Molecules)molecules) → object :
C++ signature :

QList<SireMol::MolNum> map(SireMol::MolIdx {lvalue},SireMol::Molecules)

map( (MolIdx)arg1, (MoleculeGroup)molgroup) -> object :

C++ signature :

QList<SireMol::MolNum> map(SireMol::MolIdx {lvalue},SireMol::MoleculeGroup)

map( (MolIdx)arg1, (MolGroupsBase)molgroups) -> object :

C++ signature :

QList<SireMol::MolNum> map(SireMol::MolIdx {lvalue},SireMol::MolGroupsBase)

static null() → MolIdx :
C++ signature :

SireMol::MolIdx null()

to_string()

toString( (MolIdx)arg1) -> object :

C++ signature :

QString toString(SireMol::MolIdx {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((MolIdx)arg1) → str :
C++ signature :

char const* what(SireMol::MolIdx {lvalue})

class sire.mol.MolName

This class holds the name of a Molecule.

Author: Christopher Woods

assign((MolName)arg1, (MolName)other) → MolName :
C++ signature :

SireMol::MolName {lvalue} assign(SireMol::MolName {lvalue},SireMol::MolName)

clone((MolName)arg1) → MolName :
C++ signature :

SireMol::MolName clone(SireMol::MolName)

hash((MolName)arg1) → int :
C++ signature :

unsigned int hash(SireMol::MolName {lvalue})

is_null()

isNull( (MolName)arg1) -> bool :

C++ signature :

bool isNull(SireMol::MolName {lvalue})

map((MolName)arg1, (Molecules)molecules) → object :
C++ signature :

QList<SireMol::MolNum> map(SireMol::MolName {lvalue},SireMol::Molecules)

map( (MolName)arg1, (MoleculeGroup)molgroup) -> object :

C++ signature :

QList<SireMol::MolNum> map(SireMol::MolName {lvalue},SireMol::MoleculeGroup)

map( (MolName)arg1, (MolGroupsBase)molgroups) -> object :

C++ signature :

QList<SireMol::MolNum> map(SireMol::MolName {lvalue},SireMol::MolGroupsBase)

to_string()

toString( (MolName)arg1) -> object :

C++ signature :

QString toString(SireMol::MolName {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((MolName)arg1) → str :
C++ signature :

char const* what(SireMol::MolName {lvalue})

class sire.mol.MolNum

This ID number is used to identify a Molecule by a unique, program-supplied ID number

Author: Christopher Woods

assign((MolNum)arg1, (MolNum)other) → MolNum :
C++ signature :

SireMol::MolNum {lvalue} assign(SireMol::MolNum {lvalue},SireMol::MolNum)

clone((MolNum)arg1) → MolNum :
C++ signature :

SireMol::MolNum clone(SireMol::MolNum)

get_unique_number()

getUniqueNumber() -> MolNum :

C++ signature :

SireMol::MolNum getUniqueNumber()

hash((MolNum)arg1) → int :
C++ signature :

unsigned int hash(SireMol::MolNum {lvalue})

is_null()

isNull( (MolNum)arg1) -> bool :

C++ signature :

bool isNull(SireMol::MolNum {lvalue})

map((MolNum)arg1, (Molecules)molecules) → object :
C++ signature :

QList<SireMol::MolNum> map(SireMol::MolNum {lvalue},SireMol::Molecules)

map( (MolNum)arg1, (MoleculeGroup)arg0) -> object :

C++ signature :

QList<SireMol::MolNum> map(SireMol::MolNum {lvalue},SireMol::MoleculeGroup)

map( (MolNum)arg1, (MolGroupsBase)arg0) -> object :

C++ signature :

QList<SireMol::MolNum> map(SireMol::MolNum {lvalue},SireMol::MolGroupsBase)

to_string()

toString( (MolNum)arg1) -> object :

C++ signature :

QString toString(SireMol::MolNum {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((MolNum)arg1) → str :
C++ signature :

char const* what(SireMol::MolNum {lvalue})

class sire.mol.Molecule

A Molecule represents a complete molecule.

Most of the manipulation of a molecule is handled by the orer classes, e.g. Mover, Selector, Editer, Evaluator.

These classes provide additional member functions, thereby allowing me to keep the API of Molecule small.

Examples of use include;

mol = mol.move().translate( Vector(1,2,3) ) point = mol.evaluate().center() mass = mol.evaluate().mass()

mol = mol.edit().rename( ResNum(43)[0], ALA ).commit()

Equally, we can quickly select well-defined subgroups within the molecule, e.g. atom(s), residue(e), chain(s), CutGroup(s) and segment(s), via the select functions, e.g.

ala49 = mol.select( ResName(ala) + ResNum(49) );

or if there is more than one residue designate ALA:49

ala49_0 = mol.select( (ResName(ala)+ResNum(49))[0] );

or to get all of these residues, do

all_ala49 = mol.selectAll( ResName(ala) + ResNum(49) );

Author: Christopher Woods

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_contains_metadata()
assertContainsMetadata( (Molecule)arg1, (PropertyName)metakey) -> None :

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

C++ signature :

void assertContainsMetadata(SireMol::Molecule {lvalue},SireBase::PropertyName)

assertContainsMetadata( (Molecule)arg1, (PropertyName)key, (PropertyName)metakey) -> None :

Assert that this molecule contains some metadata at metakey metakey associated with the property at key key Throw: SireBase::missing_property

C++ signature :

void assertContainsMetadata(SireMol::Molecule {lvalue},SireBase::PropertyName,SireBase::PropertyName)

assert_contains_property()
assertContainsProperty( (Molecule)arg1, (PropertyName)key) -> None :

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

C++ signature :

void assertContainsProperty(SireMol::Molecule {lvalue},SireBase::PropertyName)

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((Molecule)arg1, (Molecule)other) → Molecule :
C++ signature :

SireMol::Molecule {lvalue} assign(SireMol::Molecule {lvalue},SireMol::Molecule)

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((Molecule)arg1) → Molecule :
C++ signature :

SireMol::Molecule clone(SireMol::Molecule)

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( (Molecule)arg1) -> int :

Return the number of atoms in this molecule

C++ signature :

int nAtoms(SireMol::Molecule {lvalue})

nAtoms( (Molecule)arg1, (ResID)id) -> int :

Return the number of atoms in the identified residue(s)

C++ signature :

int nAtoms(SireMol::Molecule {lvalue},SireMol::ResID)

nAtoms( (Molecule)arg1, (ChainID)id) -> int :

Return the number of atoms in the identified chain(s)

C++ signature :

int nAtoms(SireMol::Molecule {lvalue},SireMol::ChainID)

nAtoms( (Molecule)arg1, (SegID)seg) -> int :

Return the number of atoms in the identified segment(s)

C++ signature :

int nAtoms(SireMol::Molecule {lvalue},SireMol::SegID)

nAtoms( (Molecule)arg1, (CGID)id) -> int :

Return the number of atoms in the identified cutgroups(s)

C++ signature :

int nAtoms(SireMol::Molecule {lvalue},SireMol::CGID)

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)

edit((Molecule)arg1) → MolEditor :

Return an Editor that can edit any part of this molecule

C++ signature :

SireMol::MolEditor edit(SireMol::Molecule {lvalue})

energy(other=None, map=None)

Calculate the total energy of the molecule view(s) in this collection.

other: (view or views, optional)

An optional second view (or collection of views). If this is passed, then the energy between the views in this collections and others will be calculated.

map: (dictionary, optional)

An optional property map that will be used to find or map the properties used for this energy calculation.

Returns:

Returns an energy, with attached components for the sub-components (if any) for this energy.

Return type:

sire.units.GeneralUnit (energy per quantity)

evaluate((Molecule)arg1) → Evaluator :

Return an Evaluator that evaluates values using all of the atoms in this molecule

C++ signature :

SireMol::Evaluator evaluate(SireMol::Molecule {lvalue})

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)

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})

hasLinks( (MoleculeView)arg1) -> bool :

Return whether or not this molecule has any property links

C++ signature :

bool hasLinks(SireMol::MoleculeView {lvalue})

has_metadata()
hasMetadata( (Molecule)arg1, (PropertyName)metakey) -> bool :

Return whether or not this molecule posseses metadata with metakey metakey

C++ signature :

bool hasMetadata(SireMol::Molecule {lvalue},SireBase::PropertyName)

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

Return whether or not the property of this molecule at key key has metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

bool hasMetadata(SireMol::Molecule {lvalue},SireBase::PropertyName,SireBase::PropertyName)

has_property()
hasProperty( (Molecule)arg1, (PropertyName)key) -> bool :

Return whether or not this molecule posseses a property at key key

C++ signature :

bool hasProperty(SireMol::Molecule {lvalue},SireBase::PropertyName)

info((Molecule)arg1) → MoleculeInfo :

Return the MoleculeInfo object that holds information about the layout of the atoms, residues, chains and segments in the molecule

C++ signature :

SireMol::MoleculeInfo info(SireMol::Molecule {lvalue})

invert((Molecule)arg1) → SelectorMol :
C++ signature :

SireMol::SelectorMol invert(SireMol::Molecule {lvalue})

is_empty()
isEmpty( (Molecule)arg1) -> bool :

Return whether or not this is empty

C++ signature :

bool isEmpty(SireMol::Molecule {lvalue})

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

Return whether or not this molecule is perturbable (can be morphed with a lambda coordinate)

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})

static join(views)

Join the passed views of a molecule into a single molecule

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)

metadata((Molecule)arg1, (PropertyName)metakey) → Property :
Return the metadata for the metakey metakey

Throw: SireMol::missing_property

C++ signature :

SireBase::Property metadata(SireMol::Molecule {lvalue},SireBase::PropertyName)

metadata( (Molecule)arg1, (PropertyName)key, (PropertyName)metakey) -> Property :

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

C++ signature :

SireBase::Property metadata(SireMol::Molecule {lvalue},SireBase::PropertyName,SireBase::PropertyName)

metadata_keys()
metadataKeys( (Molecule)arg1) -> object :

Return the metakeys of all the metadata in this molecule

C++ signature :

QStringList metadataKeys(SireMol::Molecule {lvalue})

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

Return the metakeys for all of the metadata for the property at key key Throw: SireBase::missing_property

C++ signature :

QStringList metadataKeys(SireMol::Molecule {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)

move((Molecule)arg1) → Mover_Molecule_ :

Return a Mover that moves all of the atoms in this molecule

C++ signature :

SireMol::Mover<SireMol::Molecule> move(SireMol::Molecule {lvalue})

name((Molecule)arg1) → MolName :

Return the name of this molecule

C++ signature :

SireMol::MolName name(SireMol::Molecule {lvalue})

num_atoms()
nAtoms( (Molecule)arg1) -> int :

Return the number of atoms in this molecule

C++ signature :

int nAtoms(SireMol::Molecule {lvalue})

nAtoms( (Molecule)arg1, (ResID)id) -> int :

Return the number of atoms in the identified residue(s)

C++ signature :

int nAtoms(SireMol::Molecule {lvalue},SireMol::ResID)

nAtoms( (Molecule)arg1, (ChainID)id) -> int :

Return the number of atoms in the identified chain(s)

C++ signature :

int nAtoms(SireMol::Molecule {lvalue},SireMol::ChainID)

nAtoms( (Molecule)arg1, (SegID)seg) -> int :

Return the number of atoms in the identified segment(s)

C++ signature :

int nAtoms(SireMol::Molecule {lvalue},SireMol::SegID)

nAtoms( (Molecule)arg1, (CGID)id) -> int :

Return the number of atoms in the identified cutgroups(s)

C++ signature :

int nAtoms(SireMol::Molecule {lvalue},SireMol::CGID)

num_chains()
nChains( (Molecule)arg1) -> int :

Return the number of chains in this molecule

C++ signature :

int nChains(SireMol::Molecule {lvalue})

num_cutgroups()
nCutGroups( (Molecule)arg1) -> int :

Return the number of CutGroups in this molecule

C++ signature :

int nCutGroups(SireMol::Molecule {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( (Molecule)arg1) -> int :

Return the number of residues in this molecule

C++ signature :

int nResidues(SireMol::Molecule {lvalue})

nResidues( (Molecule)arg1, (ChainID)id) -> int :

Return the number of residues in the identified chain(s)

C++ signature :

int nResidues(SireMol::Molecule {lvalue},SireMol::ChainID)

num_segments()
nSegments( (Molecule)arg1) -> int :

Return the number of segments in this molecule

C++ signature :

int nSegments(SireMol::Molecule {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})

number((Molecule)arg1) → MolNum :

Return the number of this molecule - this is used to identify the molecule

C++ signature :

SireMol::MolNum number(SireMol::Molecule {lvalue})

perturbation(map=None)

Return an interface to the perturbable properties of this molecule. Note that the molecule must be perturbable to call this function

properties((Molecule)arg1) → Properties :

Return all of the properties of this molecule

C++ signature :

SireBase::Properties properties(SireMol::Molecule {lvalue})

property((Molecule)arg1, (PropertyName)key) → Property :

Return the property associated with the key key Throw: SireMol::missing_property

C++ signature :

SireBase::Property property(SireMol::Molecule {lvalue},SireBase::PropertyName)

property_keys()
propertyKeys( (Molecule)arg1) -> object :

Return the keys of all of the properties in this molecule

C++ signature :

QStringList propertyKeys(SireMol::Molecule {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( (Molecule)arg1) -> bool :

Return whether or not this is a complete molecule

C++ signature :

bool selectedAll(SireMol::Molecule {lvalue})

selection((Molecule)arg1) → AtomSelection :

Return which atoms are selected in this view

C++ signature :

SireMol::AtomSelection selection(SireMol::Molecule {lvalue})

selector((Molecule)arg1) → SelectorMol :
C++ signature :

SireMol::SelectorMol selector(SireMol::Molecule {lvalue})

size()
nAtoms( (Molecule)arg1) -> int :

Return the number of atoms in this molecule

C++ signature :

int nAtoms(SireMol::Molecule {lvalue})

nAtoms( (Molecule)arg1, (ResID)id) -> int :

Return the number of atoms in the identified residue(s)

C++ signature :

int nAtoms(SireMol::Molecule {lvalue},SireMol::ResID)

nAtoms( (Molecule)arg1, (ChainID)id) -> int :

Return the number of atoms in the identified chain(s)

C++ signature :

int nAtoms(SireMol::Molecule {lvalue},SireMol::ChainID)

nAtoms( (Molecule)arg1, (SegID)seg) -> int :

Return the number of atoms in the identified segment(s)

C++ signature :

int nAtoms(SireMol::Molecule {lvalue},SireMol::SegID)

nAtoms( (Molecule)arg1, (CGID)id) -> int :

Return the number of atoms in the identified cutgroups(s)

C++ signature :

int nAtoms(SireMol::Molecule {lvalue},SireMol::CGID)

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( (Molecule)arg1) -> object :

C++ signature :

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

to_string()
toString( (Molecule)arg1) -> object :

Return a string representation of this molecule

C++ signature :

QString toString(SireMol::Molecule {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

version((Molecule)arg1) → int :
Return the version number of this molecule - all molecules

with the same ID number and version number must be identical

C++ signature :

unsigned long long version(SireMol::Molecule {lvalue})

version( (Molecule)arg1, (PropertyName)key) -> int :

Return the version number of the property at key key. All molecules with the same ID number and same property version number must have the same value of this property (although this says nothing about any metadata associated with this property) Throw: SireBase::missing_property

C++ signature :

unsigned long long version(SireMol::Molecule {lvalue},SireBase::PropertyName)

class sire.mol.ResIdx

This is an ID object that is used to index CutGroups

Author: Christopher Woods

assign((ResIdx)arg1, (ResIdx)other) → ResIdx :
C++ signature :

SireMol::ResIdx {lvalue} assign(SireMol::ResIdx {lvalue},SireMol::ResIdx)

clone((ResIdx)arg1) → ResIdx :
C++ signature :

SireMol::ResIdx clone(SireMol::ResIdx)

hash((ResIdx)arg1) → int :
C++ signature :

unsigned int hash(SireMol::ResIdx {lvalue})

is_null()

isNull( (ResIdx)arg1) -> bool :

C++ signature :

bool isNull(SireMol::ResIdx {lvalue})

map((ResIdx)arg1, (MolInfo)molinfo) → object :
C++ signature :

QList<SireMol::ResIdx> map(SireMol::ResIdx {lvalue},SireMol::MolInfo)

static null() → ResIdx :
C++ signature :

SireMol::ResIdx null()

to_string()

toString( (ResIdx)arg1) -> object :

C++ signature :

QString toString(SireMol::ResIdx {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((ResIdx)arg1) → str :
C++ signature :

char const* what(SireMol::ResIdx {lvalue})

class sire.mol.ResName

This class holds the name of a CutGroup.

Author: Christopher Woods

assign((ResName)arg1, (ResName)other) → ResName :
C++ signature :

SireMol::ResName {lvalue} assign(SireMol::ResName {lvalue},SireMol::ResName)

clone((ResName)arg1) → ResName :
C++ signature :

SireMol::ResName clone(SireMol::ResName)

hash((ResName)arg1) → int :
C++ signature :

unsigned int hash(SireMol::ResName {lvalue})

is_null()

isNull( (ResName)arg1) -> bool :

C++ signature :

bool isNull(SireMol::ResName {lvalue})

map((ResName)arg1, (MolInfo)molinfo) → object :
C++ signature :

QList<SireMol::ResIdx> map(SireMol::ResName {lvalue},SireMol::MolInfo)

to_string()

toString( (ResName)arg1) -> object :

C++ signature :

QString toString(SireMol::ResName {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((ResName)arg1) → str :
C++ signature :

char const* what(SireMol::ResName {lvalue})

class sire.mol.ResNum

This ID number is used to identify a CutGroup by the user-supplied number

Author: Christopher Woods

assign((ResNum)arg1, (ResNum)other) → ResNum :
C++ signature :

SireMol::ResNum {lvalue} assign(SireMol::ResNum {lvalue},SireMol::ResNum)

clone((ResNum)arg1) → ResNum :
C++ signature :

SireMol::ResNum clone(SireMol::ResNum)

hash((ResNum)arg1) → int :
C++ signature :

unsigned int hash(SireMol::ResNum {lvalue})

is_null()

isNull( (ResNum)arg1) -> bool :

C++ signature :

bool isNull(SireMol::ResNum {lvalue})

map((ResNum)arg1, (MolInfo)molinfo) → object :
C++ signature :

QList<SireMol::ResIdx> map(SireMol::ResNum {lvalue},SireMol::MolInfo)

to_string()

toString( (ResNum)arg1) -> object :

C++ signature :

QString toString(SireMol::ResNum {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((ResNum)arg1) → str :
C++ signature :

char const* what(SireMol::ResNum {lvalue})

class sire.mol.Residue

This class represents a Residue in a Molecule.

Author: Christopher Woods

alternate_name()
alternateName( (Residue)arg1) -> ResName :

Return the alternate name of this residue

C++ signature :

SireMol::ResName alternateName(SireMol::Residue {lvalue})

assert_contains_metadata()
assertContainsMetadata( (Residue)arg1, (PropertyName)metakey) -> None :

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

C++ signature :

void assertContainsMetadata(SireMol::Residue {lvalue},SireBase::PropertyName)

assertContainsMetadata( (Residue)arg1, (PropertyName)key, (PropertyName)metakey) -> None :

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

C++ signature :

void assertContainsMetadata(SireMol::Residue {lvalue},SireBase::PropertyName,SireBase::PropertyName)

assert_contains_property()
assertContainsProperty( (Residue)arg1, (PropertyName)key) -> None :

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

C++ signature :

void assertContainsProperty(SireMol::Residue {lvalue},SireBase::PropertyName)

assign((Residue)arg1, (Residue)other) → Residue :
C++ signature :

SireMol::Residue {lvalue} assign(SireMol::Residue {lvalue},SireMol::Residue)

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})

atom_idxs()
atomIdxs( (Residue)arg1) -> object :

Return the indicies of the atoms in this residue, in the order that they appear in this residue

C++ signature :

QList<SireMol::AtomIdx> atomIdxs(SireMol::Residue {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((Residue)arg1) → Residue :
C++ signature :

SireMol::Residue clone(SireMol::Residue)

contains((Residue)arg1, (AtomIdx)atomidx) → bool :
Return whether or not this residue contains the atom

at index atomidx

C++ signature :

bool contains(SireMol::Residue {lvalue},SireMol::AtomIdx)

contains( (Residue)arg1, (AtomID)atomid) -> bool :

Return whether or not this residue contains all of the atoms identified by the ID atomid

C++ signature :

bool contains(SireMol::Residue {lvalue},SireMol::AtomID)

count()
nAtoms( (Residue)arg1) -> int :

Return the number of atoms in this residue

C++ signature :

int nAtoms(SireMol::Residue {lvalue})

cursor(map=None)

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

edit((Residue)arg1) → ResEditor :

Return an editor that can be used to edit any of the atoms of this residue

C++ signature :

SireMol::ResEditor edit(SireMol::Residue {lvalue})

energy(other=None, map=None)

Calculate the total energy of the molecule view(s) in this collection.

other: (view or views, optional)

An optional second view (or collection of views). If this is passed, then the energy between the views in this collections and others will be calculated.

map: (dictionary, optional)

An optional property map that will be used to find or map the properties used for this energy calculation.

Returns:

Returns an energy, with attached components for the sub-components (if any) for this energy.

Return type:

sire.units.GeneralUnit (energy per quantity)

evaluate((Residue)arg1) → Evaluator :

Return an Evaluator that evaluates values using all of the atoms in the residue

C++ signature :

SireMol::Evaluator evaluate(SireMol::Residue {lvalue})

has_metadata()
hasMetadata( (Residue)arg1, (PropertyName)metakey) -> bool :

Return whether or not there is a ResProperty at metakey metakey

C++ signature :

bool hasMetadata(SireMol::Residue {lvalue},SireBase::PropertyName)

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

Return whether the metadata at metakey metakey for the property at key key is a ResProperty Throw: SireBase::missing_property

C++ signature :

bool hasMetadata(SireMol::Residue {lvalue},SireBase::PropertyName,SireBase::PropertyName)

has_property()
hasProperty( (Residue)arg1, (PropertyName)key) -> bool :

Return whether or not there is a ResProperty at key key

C++ signature :

bool hasProperty(SireMol::Residue {lvalue},SireBase::PropertyName)

index((Residue)arg1) → ResIdx :

Return the index of this residue in the molecule

C++ signature :

SireMol::ResIdx index(SireMol::Residue {lvalue})

intersects((Residue)arg1, (AtomID)atomid) → bool :

Return whether or not this residue contains some of the atoms identified by the ID atomid

C++ signature :

bool intersects(SireMol::Residue {lvalue},SireMol::AtomID)

invert((Residue)arg1) → Selector_Residue_ :

Return a selector that has everything except this view

C++ signature :

SireMol::Selector<SireMol::Residue> invert(SireMol::Residue {lvalue})

is_empty()
isEmpty( (Residue)arg1) -> bool :

Is this residue empty?

C++ signature :

bool isEmpty(SireMol::Residue {lvalue})

is_within_chain()
isWithinChain( (Residue)arg1) -> bool :

Return whether or not this residue is part of a chain

C++ signature :

bool isWithinChain(SireMol::Residue {lvalue})

metadata_keys()
metadataKeys( (Residue)arg1) -> object :

Return the metakeys of all ResProperty metadata

C++ signature :

QStringList metadataKeys(SireMol::Residue {lvalue})

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

Return the metakeys of all ResProperty metadata for the property at key key Throw: SireBase::missing_property

C++ signature :

QStringList metadataKeys(SireMol::Residue {lvalue},SireBase::PropertyName)

move((Residue)arg1) → Mover_Residue_ :

Return a Mover that moves all of the atoms in this residue

C++ signature :

SireMol::Mover<SireMol::Residue> move(SireMol::Residue {lvalue})

name((Residue)arg1) → ResName :

Return the name of this residue

C++ signature :

SireMol::ResName name(SireMol::Residue {lvalue})

num_atoms()
nAtoms( (Residue)arg1) -> int :

Return the number of atoms in this residue

C++ signature :

int nAtoms(SireMol::Residue {lvalue})

number((Residue)arg1) → ResNum :

Return the number of this residue

C++ signature :

SireMol::ResNum number(SireMol::Residue {lvalue})

property_as_property()
propertyAsProperty( (Residue)arg1, (PropertyName)key) -> object :

Return the specified property as a PropertyPtr

C++ signature :

SireBase::PropPtr<SireBase::Property> propertyAsProperty(SireMol::Residue {lvalue},SireBase::PropertyName)

property_as_variant()
propertyAsVariant( (Residue)arg1, (PropertyName)key) -> object :

Return the specified property as a QVariant

C++ signature :

QVariant propertyAsVariant(SireMol::Residue {lvalue},SireBase::PropertyName)

property_keys()
propertyKeys( (Residue)arg1) -> object :

Return the keys of all ResProperty properties

C++ signature :

QStringList propertyKeys(SireMol::Residue {lvalue})

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})

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})

selected_all()
selectedAll( (Residue)arg1) -> bool :

Is this residue the entire molecule?

C++ signature :

bool selectedAll(SireMol::Residue {lvalue})

selection((Residue)arg1) → AtomSelection :

Return the identities of the atoms that are selected as part of this residue

C++ signature :

SireMol::AtomSelection selection(SireMol::Residue {lvalue})

selector((Residue)arg1) → Selector_Residue_ :

Return a selector that can change the selection of residues

C++ signature :

SireMol::Selector<SireMol::Residue> selector(SireMol::Residue {lvalue})

size()
nAtoms( (Residue)arg1) -> int :

Return the number of atoms in this residue

C++ signature :

int nAtoms(SireMol::Residue {lvalue})

to_selector()

toSelector( (Residue)arg1) -> object :

C++ signature :

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

to_string()
toString( (Residue)arg1) -> object :

Return a string representation of this residue

C++ signature :

QString toString(SireMol::Residue {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

class sire.mol.SegIdx

This is an ID object that is used to index CutGroups

Author: Christopher Woods

assign((SegIdx)arg1, (SegIdx)other) → SegIdx :
C++ signature :

SireMol::SegIdx {lvalue} assign(SireMol::SegIdx {lvalue},SireMol::SegIdx)

clone((SegIdx)arg1) → SegIdx :
C++ signature :

SireMol::SegIdx clone(SireMol::SegIdx)

hash((SegIdx)arg1) → int :
C++ signature :

unsigned int hash(SireMol::SegIdx {lvalue})

is_null()

isNull( (SegIdx)arg1) -> bool :

C++ signature :

bool isNull(SireMol::SegIdx {lvalue})

map((SegIdx)arg1, (MolInfo)molinfo) → object :
C++ signature :

QList<SireMol::SegIdx> map(SireMol::SegIdx {lvalue},SireMol::MolInfo)

static null() → SegIdx :
C++ signature :

SireMol::SegIdx null()

to_string()

toString( (SegIdx)arg1) -> object :

C++ signature :

QString toString(SireMol::SegIdx {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((SegIdx)arg1) → str :
C++ signature :

char const* what(SireMol::SegIdx {lvalue})

class sire.mol.SegName

This class holds the name of a CutGroup.

Author: Christopher Woods

assign((SegName)arg1, (SegName)other) → SegName :
C++ signature :

SireMol::SegName {lvalue} assign(SireMol::SegName {lvalue},SireMol::SegName)

clone((SegName)arg1) → SegName :
C++ signature :

SireMol::SegName clone(SireMol::SegName)

hash((SegName)arg1) → int :
C++ signature :

unsigned int hash(SireMol::SegName {lvalue})

is_null()

isNull( (SegName)arg1) -> bool :

C++ signature :

bool isNull(SireMol::SegName {lvalue})

map((SegName)arg1, (MolInfo)molinfo) → object :
C++ signature :

QList<SireMol::SegIdx> map(SireMol::SegName {lvalue},SireMol::MolInfo)

to_string()

toString( (SegName)arg1) -> object :

C++ signature :

QString toString(SireMol::SegName {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((SegName)arg1) → str :
C++ signature :

char const* what(SireMol::SegName {lvalue})

class sire.mol.Segment

This is a view of a single segment within a molecule

Author: Christopher Woods

assert_contains_metadata()
assertContainsMetadata( (Segment)arg1, (PropertyName)metakey) -> None :

Assert that this segment has an SegProperty piece of metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

void assertContainsMetadata(SireMol::Segment {lvalue},SireBase::PropertyName)

assertContainsMetadata( (Segment)arg1, (PropertyName)key, (PropertyName)metakey) -> None :

Assert that the property at key key has an SegProperty piece of metadata at metakey metakey Throw: SireBase::missing_property

C++ signature :

void assertContainsMetadata(SireMol::Segment {lvalue},SireBase::PropertyName,SireBase::PropertyName)

assert_contains_property()
assertContainsProperty( (Segment)arg1, (PropertyName)key) -> None :

Assert that this segment has an SegProperty at key key Throw: SireBase::missing_property

C++ signature :

void assertContainsProperty(SireMol::Segment {lvalue},SireBase::PropertyName)

assign((Segment)arg1, (Segment)other) → Segment :
C++ signature :

SireMol::Segment {lvalue} assign(SireMol::Segment {lvalue},SireMol::Segment)

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})

atom_idxs()
atomIdxs( (Segment)arg1) -> object :

Return the indicies of the atoms in this segment, in the order that they appear in this segment

C++ signature :

QList<SireMol::AtomIdx> atomIdxs(SireMol::Segment {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((Segment)arg1) → Segment :
C++ signature :

SireMol::Segment clone(SireMol::Segment)

contains((Segment)arg1, (AtomIdx)atomidx) → bool :
Return whether or not this segment contains the atom

at index atomidx

C++ signature :

bool contains(SireMol::Segment {lvalue},SireMol::AtomIdx)

contains( (Segment)arg1, (AtomID)atomid) -> bool :

Return whether or not this segment contains all of the atoms identified by the ID atomid

C++ signature :

bool contains(SireMol::Segment {lvalue},SireMol::AtomID)

count()
nAtoms( (Segment)arg1) -> int :

Return the number of atoms in this Segment

C++ signature :

int nAtoms(SireMol::Segment {lvalue})

cursor(map=None)

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

edit((Segment)arg1) → SegEditor :

Return an editor that can edit this Segment

C++ signature :

SireMol::SegEditor edit(SireMol::Segment {lvalue})

energy(other=None, map=None)

Calculate the total energy of the molecule view(s) in this collection.

other: (view or views, optional)

An optional second view (or collection of views). If this is passed, then the energy between the views in this collections and others will be calculated.

map: (dictionary, optional)

An optional property map that will be used to find or map the properties used for this energy calculation.

Returns:

Returns an energy, with attached components for the sub-components (if any) for this energy.

Return type:

sire.units.GeneralUnit (energy per quantity)

evaluate((Segment)arg1) → Evaluator :

Return an evaluator that can evaluate properties of this Segment

C++ signature :

SireMol::Evaluator evaluate(SireMol::Segment {lvalue})

has_metadata()
hasMetadata( (Segment)arg1, (PropertyName)metakey) -> bool :

Return whether or not there is a SegProperty at metakey metakey

C++ signature :

bool hasMetadata(SireMol::Segment {lvalue},SireBase::PropertyName)

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

Return whether the metadata at metakey metakey for the property at key key is a SegProperty Throw: SireBase::missing_property

C++ signature :

bool hasMetadata(SireMol::Segment {lvalue},SireBase::PropertyName,SireBase::PropertyName)

has_property()
hasProperty( (Segment)arg1, (PropertyName)key) -> bool :

Return whether or not there is a SegProperty at key key

C++ signature :

bool hasProperty(SireMol::Segment {lvalue},SireBase::PropertyName)

index((Segment)arg1) → SegIdx :

Return the index of this Segment in the molecule

C++ signature :

SireMol::SegIdx index(SireMol::Segment {lvalue})

intersects((Segment)arg1, (AtomID)atomid) → bool :

Return whether or not this segment contains some of the atoms identified by the ID atomid

C++ signature :

bool intersects(SireMol::Segment {lvalue},SireMol::AtomID)

invert((Segment)arg1) → Selector_Segment_ :

Return a selector that has everything except this view

C++ signature :

SireMol::Selector<SireMol::Segment> invert(SireMol::Segment {lvalue})

is_empty()
isEmpty( (Segment)arg1) -> bool :

Return whether or not this segment is empty

C++ signature :

bool isEmpty(SireMol::Segment {lvalue})

metadata_keys()
metadataKeys( (Segment)arg1) -> object :

Return the metakeys of all SegProperty metadata

C++ signature :

QStringList metadataKeys(SireMol::Segment {lvalue})

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

Return the metakeys of all SegProperty metadata for the property at key key Throw: SireBase::missing_property

C++ signature :

QStringList metadataKeys(SireMol::Segment {lvalue},SireBase::PropertyName)

move((Segment)arg1) → Mover_Segment_ :

Return an object that can move a copy of this Segment

C++ signature :

SireMol::Mover<SireMol::Segment> move(SireMol::Segment {lvalue})

name((Segment)arg1) → SegName :

Return the name of this Segment

C++ signature :

SireMol::SegName name(SireMol::Segment {lvalue})

num_atoms()
nAtoms( (Segment)arg1) -> int :

Return the number of atoms in this Segment

C++ signature :

int nAtoms(SireMol::Segment {lvalue})

number((Segment)arg1) → SegIdx :

Return the number of this segment (same as its index)

C++ signature :

SireMol::SegIdx number(SireMol::Segment {lvalue})

property_as_property()
propertyAsProperty( (Segment)arg1, (PropertyName)key) -> object :

Return the specified property as a PropertyPtr

C++ signature :

SireBase::PropPtr<SireBase::Property> propertyAsProperty(SireMol::Segment {lvalue},SireBase::PropertyName)

property_as_variant()
propertyAsVariant( (Segment)arg1, (PropertyName)key) -> object :

Return the specified property as a QVariant

C++ signature :

QVariant propertyAsVariant(SireMol::Segment {lvalue},SireBase::PropertyName)

property_keys()
propertyKeys( (Segment)arg1) -> object :

Return the keys of all SegProperty properties

C++ signature :

QStringList propertyKeys(SireMol::Segment {lvalue})

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})

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})

selected_all()
selectedAll( (Segment)arg1) -> bool :

Return whether or not this segment contains the entire molecule

C++ signature :

bool selectedAll(SireMol::Segment {lvalue})

selection((Segment)arg1) → AtomSelection :

Return the atoms that are in this Segment

C++ signature :

SireMol::AtomSelection selection(SireMol::Segment {lvalue})

selector((Segment)arg1) → Selector_Segment_ :

Return a selector that can be used to change the selection of segments from the molecule

C++ signature :

SireMol::Selector<SireMol::Segment> selector(SireMol::Segment {lvalue})

size()
nAtoms( (Segment)arg1) -> int :

Return the number of atoms in this Segment

C++ signature :

int nAtoms(SireMol::Segment {lvalue})

to_selector()

toSelector( (Segment)arg1) -> object :

C++ signature :

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

to_string()
toString( (Segment)arg1) -> object :

Return a string representation of this segment

C++ signature :

QString toString(SireMol::Segment {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

class sire.mol.SelectorMol

This class provides a Selector<T>-type interface to a collection of molecules.

append((SelectorMol)arg1, (Molecule)mol) → None :
C++ signature :

void append(SireMol::SelectorMol {lvalue},SireMol::Molecule)

append( (SelectorMol)arg1, (SelectorMol)mols) -> None :

C++ signature :

void append(SireMol::SelectorMol {lvalue},SireMol::SelectorMol)

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((SelectorMol)arg1, (SelectorMol)other) → SelectorMol :
C++ signature :

SireMol::SelectorMol {lvalue} assign(SireMol::SelectorMol {lvalue},SireMol::SelectorMol)

chain((SelectorMol)arg1, (int)i[, (PropertyMap)map={}]) → Chain :
C++ signature :

SireMol::Chain chain(SireMol::SelectorMol {lvalue},int [,SireBase::PropertyMap={}])

chain( (SelectorMol)arg1, (object)name [, (PropertyMap)map={}]) -> Chain :

C++ signature :

SireMol::Chain chain(SireMol::SelectorMol {lvalue},QString [,SireBase::PropertyMap={}])

chain( (SelectorMol)arg1, (ChainID)chainid [, (PropertyMap)map={}]) -> Chain :

C++ signature :

SireMol::Chain chain(SireMol::SelectorMol {lvalue},SireMol::ChainID [,SireBase::PropertyMap={}])

clone((SelectorMol)arg1) → SelectorMol :
C++ signature :

SireMol::SelectorMol clone(SireMol::SelectorMol)

contains((SelectorMol)arg1, (MolNum)molnum) → bool :
C++ signature :

bool contains(SireMol::SelectorMol {lvalue},SireMol::MolNum)

count()

__len__( (SelectorMol)arg1) -> int :

C++ signature :

unsigned long __len__(SireMol::SelectorMol {lvalue})

cutgroup()

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

cutgroups()

cutGroups( (SelectorMol)arg1) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMol::SelectorMol {lvalue})

cutGroups( (SelectorMol)arg1, (int)i [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMol::SelectorMol {lvalue},int [,SireBase::PropertyMap={}])

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

C++ signature :

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

cutGroups( (SelectorMol)arg1, (object)idxs [, (PropertyMap)map={}]) -> SelectorM_CutGroup_ :

C++ signature :

SireMol::SelectorM<SireMol::CutGroup> cutGroups(SireMol::SelectorMol {lvalue},QList<long long> [,SireBase::PropertyMap={}])

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

C++ signature :

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

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

C++ signature :

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

delete_all_frames()

deleteAllFrames( (SelectorMol)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMol::SelectorMol {lvalue})

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

C++ signature :

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

delete_frame()

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

C++ signature :

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

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

C++ signature :

void deleteFrame(SireMol::SelectorMol {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, 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.

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(other=None, map=None)

Calculate the total energy of the molecule view(s) in this collection.

other: (view or views, optional)

An optional second view (or collection of views). If this is passed, then the energy between the views in this collections and others will be calculated.

map: (dictionary, optional)

An optional property map that will be used to find or map the properties used for this energy calculation.

Returns:

Returns an energy, with attached components for the sub-components (if any) for this energy.

Return type:

sire.units.GeneralUnit (energy per quantity)

energy(other=None, map=None)

Calculate the total energy of the molecule view(s) in this collection.

other: (view or views, optional)

An optional second view (or collection of views). If this is passed, then the energy between the views in this collections and others will be calculated.

map: (dictionary, optional)

An optional property map that will be used to find or map the properties used for this energy calculation.

Returns:

Returns an energy, with attached components for the sub-components (if any) for this energy.

Return type:

sire.units.GeneralUnit (energy per quantity)

evaluate((SelectorMol)arg1) → EvaluatorM :
C++ signature :

SireMol::EvaluatorM evaluate(SireMol::SelectorMol {lvalue})

extract((SelectorMol)arg1) → SelectorMol :
C++ signature :

SireMol::SelectorMol extract(SireMol::SelectorMol {lvalue})

find(views)

Find the index(es) of the passed view(s) in this container. This returns a single index if a single view is passed, or a list of indexes if multiple views are passed (in the same order as the passed views).

This raises an IndexError if any of the views are not in this container.

ids()

IDs( (SelectorMol)arg1) -> object :

C++ signature :

QList<SireMol::MolNum> IDs(SireMol::SelectorMol {lvalue})

indexes((SelectorMol)arg1) → object :
C++ signature :

QList<SireMol::MolIdx> indexes(SireMol::SelectorMol {lvalue})

is_empty()

isEmpty( (SelectorMol)arg1) -> bool :

C++ signature :

bool isEmpty(SireMol::SelectorMol {lvalue})

is_selector()

isSelector( (SelectorMol)arg1) -> bool :

C++ signature :

bool isSelector(SireMol::SelectorMol {lvalue})

load_frame()

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

mol_nums()

molNums( (SelectorMol)arg1) -> object :

C++ signature :

QVector<SireMol::MolNum> molNums(SireMol::SelectorMol {lvalue})

molecule((SelectorMol)arg1, (int)i[, (PropertyMap)map={}]) → Molecule :
C++ signature :

SireMol::Molecule molecule(SireMol::SelectorMol {lvalue},int [,SireBase::PropertyMap={}])

molecule( (SelectorMol)arg1, (object)name [, (PropertyMap)map={}]) -> Molecule :

C++ signature :

SireMol::Molecule molecule(SireMol::SelectorMol {lvalue},QString [,SireBase::PropertyMap={}])

molecule( (SelectorMol)arg1, (MolIdx)molidx [, (PropertyMap)map={}]) -> Molecule :

C++ signature :

SireMol::Molecule molecule(SireMol::SelectorMol {lvalue},SireMol::MolIdx [,SireBase::PropertyMap={}])

molecule( (SelectorMol)arg1, (MolName)molname [, (PropertyMap)map={}]) -> Molecule :

C++ signature :

SireMol::Molecule molecule(SireMol::SelectorMol {lvalue},SireMol::MolName [,SireBase::PropertyMap={}])

molecule( (SelectorMol)arg1, (MolNum)molnum [, (PropertyMap)map={}]) -> Molecule :

C++ signature :

SireMol::Molecule molecule(SireMol::SelectorMol {lvalue},SireMol::MolNum [,SireBase::PropertyMap={}])

molecule( (SelectorMol)arg1, (MolID)molid [, (PropertyMap)map={}]) -> Molecule :

C++ signature :

SireMol::Molecule molecule(SireMol::SelectorMol {lvalue},SireMol::MolID [,SireBase::PropertyMap={}])

names((SelectorMol)arg1) → object :
C++ signature :

QList<SireMol::MolName> names(SireMol::SelectorMol {lvalue})

num_atoms()

nAtoms( (SelectorMol)arg1) -> int :

C++ signature :

int nAtoms(SireMol::SelectorMol {lvalue})

num_chains()

nChains( (SelectorMol)arg1) -> int :

C++ signature :

int nChains(SireMol::SelectorMol {lvalue})

num_cutgroups()

nCutGroups( (SelectorMol)arg1) -> int :

C++ signature :

int nCutGroups(SireMol::SelectorMol {lvalue})

num_frames()

nFrames( (SelectorMol)arg1) -> int :

C++ signature :

int nFrames(SireMol::SelectorMol {lvalue})

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

C++ signature :

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

num_molecules()

nMolecules( (SelectorMol)arg1) -> int :

C++ signature :

int nMolecules(SireMol::SelectorMol {lvalue})

num_residues()

nResidues( (SelectorMol)arg1) -> int :

C++ signature :

int nResidues(SireMol::SelectorMol {lvalue})

num_segments()

nSegments( (SelectorMol)arg1) -> int :

C++ signature :

int nSegments(SireMol::SelectorMol {lvalue})

numbers((SelectorMol)arg1) → object :
C++ signature :

QList<SireMol::MolNum> numbers(SireMol::SelectorMol {lvalue})

residue((SelectorMol)arg1, (int)i[, (PropertyMap)map={}]) → Residue :
C++ signature :

SireMol::Residue residue(SireMol::SelectorMol {lvalue},int [,SireBase::PropertyMap={}])

residue( (SelectorMol)arg1, (object)name [, (PropertyMap)map={}]) -> Residue :

C++ signature :

SireMol::Residue residue(SireMol::SelectorMol {lvalue},QString [,SireBase::PropertyMap={}])

residue( (SelectorMol)arg1, (ResID)resid [, (PropertyMap)map={}]) -> Residue :

C++ signature :

SireMol::Residue residue(SireMol::SelectorMol {lvalue},SireMol::ResID [,SireBase::PropertyMap={}])

save_frame()

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

search((SelectorMol)arg1, (object)search_string) → SelectResult :
C++ signature :

SireMol::SelectResult search(SireMol::SelectorMol {lvalue},QString)

search( (SelectorMol)arg1, (object)search_string, (PropertyMap)map) -> SelectResult :

C++ signature :

SireMol::SelectResult search(SireMol::SelectorMol {lvalue},QString,SireBase::PropertyMap)

segment((SelectorMol)arg1, (int)i[, (PropertyMap)map={}]) → Segment :
C++ signature :

SireMol::Segment segment(SireMol::SelectorMol {lvalue},int [,SireBase::PropertyMap={}])

segment( (SelectorMol)arg1, (object)name [, (PropertyMap)map={}]) -> Segment :

C++ signature :

SireMol::Segment segment(SireMol::SelectorMol {lvalue},QString [,SireBase::PropertyMap={}])

segment( (SelectorMol)arg1, (SegID)segid [, (PropertyMap)map={}]) -> Segment :

C++ signature :

SireMol::Segment segment(SireMol::SelectorMol {lvalue},SireMol::SegID [,SireBase::PropertyMap={}])

size()

__len__( (SelectorMol)arg1) -> int :

C++ signature :

unsigned long __len__(SireMol::SelectorMol {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( (SelectorMol)arg1) -> object :

C++ signature :

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

to_molecule_group()

toMoleculeGroup( (SelectorMol)arg1) -> MoleculeGroup :

C++ signature :

SireMol::MoleculeGroup toMoleculeGroup(SireMol::SelectorMol {lvalue})

to_molecules()

toMolecules( (SelectorMol)arg1) -> Molecules :

C++ signature :

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

to_select_result()

toSelectResult( (SelectorMol)arg1) -> SelectResult :

C++ signature :

SireMol::SelectResult toSelectResult(SireMol::SelectorMol {lvalue})

to_string()

toString( (SelectorMol)arg1) -> object :

C++ signature :

QString toString(SireMol::SelectorMol {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((SelectorMol)arg1, (MoleculeView)molview) → None :
C++ signature :

void update(SireMol::SelectorMol {lvalue},SireMol::MoleculeView)

update( (SelectorMol)arg1, (MoleculeView)moldata) -> None :

C++ signature :

void update(SireMol::SelectorMol {lvalue},SireMol::MoleculeData)

update( (SelectorMol)arg1, (Molecules)molecules) -> None :

C++ signature :

void update(SireMol::SelectorMol {lvalue},SireMol::Molecules)

update( (SelectorMol)arg1, (SelectorMol)molecules) -> None :

C++ signature :

void update(SireMol::SelectorMol {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.

what((SelectorMol)arg1) → str :
C++ signature :

char const* what(SireMol::SelectorMol {lvalue})

class sire.mol.Stereochemistry

This class represents a bonds stereochemistry

Author: Christopher Woods

assign((Stereochemistry)arg1, (Stereochemistry)other) → Stereochemistry :
C++ signature :

SireMol::Stereochemistry {lvalue} assign(SireMol::Stereochemistry {lvalue},SireMol::Stereochemistry)

clone((Stereochemistry)arg1) → Stereochemistry :
C++ signature :

SireMol::Stereochemistry clone(SireMol::Stereochemistry)

static down() → Stereochemistry :

Return a down Stereochemistry

C++ signature :

SireMol::Stereochemistry down()

from_rdkit()
fromRDKit( (object)value) -> Stereochemistry :

Construct from a string representation of a RDKit stereochemistry

C++ signature :

SireMol::Stereochemistry fromRDKit(QString)

from_s_d_f()
fromSDF( (int)val) -> Stereochemistry :

Construct from the the passed SDF number

C++ signature :

SireMol::Stereochemistry fromSDF(int)

is_defined()
isDefined( (Stereochemistry)arg1) -> bool :

Return whether or not the stereoscopy is defined

C++ signature :

bool isDefined(SireMol::Stereochemistry {lvalue})

is_down()
isDown( (Stereochemistry)arg1) -> bool :

Return whether or not this is a down bond

C++ signature :

bool isDown(SireMol::Stereochemistry {lvalue})

is_not_stereo()
isNotStereo( (Stereochemistry)arg1) -> bool :

Return whether or not this is a not stereo bond

C++ signature :

bool isNotStereo(SireMol::Stereochemistry {lvalue})

is_up()
isUp( (Stereochemistry)arg1) -> bool :

Return whether or not this is an up bond

C++ signature :

bool isUp(SireMol::Stereochemistry {lvalue})

not_stereo()
notStereo() -> Stereochemistry :

Return a not stereo Stereochemistry

C++ signature :

SireMol::Stereochemistry notStereo()

to_rdkit()
toRDKit( (Stereochemistry)arg1) -> object :

Return a string representation of the RDKit stereo value

C++ signature :

QString toRDKit(SireMol::Stereochemistry {lvalue})

to_s_d_f()
toSDF( (Stereochemistry)arg1) -> int :

Return the SDF-format value for this bond. This returns 0 if the stereoscopy is undefined

C++ signature :

int toSDF(SireMol::Stereochemistry {lvalue})

to_string()

toString( (Stereochemistry)arg1) -> object :

C++ signature :

QString toString(SireMol::Stereochemistry {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

static undefined() → Stereochemistry :

Return an undefined Stereochemistry

C++ signature :

SireMol::Stereochemistry undefined()

static up() → Stereochemistry :

Return an up Stereochemistry

C++ signature :

SireMol::Stereochemistry up()

value((Stereochemistry)arg1) → int :

Return the stereo type (uses SDF values, e.g. 0 is not stereo, 1 is up, 6 is down. We have added -1 to mean undefined)

C++ signature :

int value(SireMol::Stereochemistry {lvalue})

class sire.mol.TrajectoryIterator(view=None, align=None, smooth=None, wrap=None, mapping=None, frame=None, map=None)[source]

An iterator that can be used to control which frames of a trajectory are accessed or processed.

align(align, frame=None)[source]

Return a copy of this trajectory where each frame will be aligned against the atoms that match the search string ‘align’

apply(func, *args, **kwargs)[source]

Call the passed function on all frames of the trajectory, 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:

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

frame in the trajectory

Return type:

list

current()[source]

Return the current frame in the trajectory

first()[source]

Return the first frame in the trajectory

frame_indexes()[source]

Return the indexes of the frames in this trajectory that will be viewed

rmsd(reference=None, align: bool = None, frame: int = None, mapping=None, match_all: bool = True, map=None, to_pandas: bool = False)[source]

Calculate the RMSD across the frames of this trajectory, against either all atoms or, optionally, the passed view. You can specify whether to align the trajectory against the view (controlling which frame should be the source of alignment via frame)

reference: molecule container or search string or index or range

Anything that is valid to specify a sub-view of the trajectory, or that can be a molecular container itself. If this is a view, then the RMSD only to the atoms in the view is calculated. If the atoms aren’t in this trajectory, then you need to provide a mapping that shows how you can map from the atoms in the view to the atoms in the trajectory.

align: bool

Whether or not to align the frames of the trajectory against the reference. This defaults to True

frame: int

The frame number of the reference against which to align the trajectory

mapping: AtomMapping

The mapping from atoms in the reference to atoms in the trajectory. This is only needed if the reference atoms are not contained in the atoms in this trajectory.

match_all: bool

Whether or not to find and match all of the atoms in ‘reference’ to the atoms in this trajectory. Normally you do want to do this, so it defaults to True. If this is False, then the RMSD of only atoms in this trajectory that in ‘reference’ will be calculated, even if it just a single atom.

map: dict

Any parameters that will overwrite any of the map parameters that are already in this trajectory

to_pandas: bool

Whether or not to write the output to a Pandas DataFrame (default False)

smooth(smooth)[source]

Return a copy of this trajectory where each frame will be smoothed over the specified number of frames (or the recommended number if ‘smooth’ is set to ‘True’)

wrap(autowrap=True)[source]

Return a copy of this trajectory where each frame will be auto-wrapped into the current space

sire.mol.get_alignment()

getAlignment( (MoleculeView)view0, (MoleculeView)view1 [, (bool)fit=True]) -> Transform :

C++ signature :

SireMaths::Transform getAlignment(SireMol::MoleculeView,SireMol::MoleculeView [,bool=True])

getAlignment( (MoleculeView)view0, (MoleculeView)view1, (PropertyMap)map [, (bool)fit=True]) -> Transform :

C++ signature :

SireMaths::Transform getAlignment(SireMol::MoleculeView,SireMol::MoleculeView,SireBase::PropertyMap [,bool=True])

getAlignment( (MoleculeView)view0, (PropertyMap)map0, (MoleculeView)view1, (PropertyMap)map1 [, (bool)fit=True]) -> Transform :

C++ signature :

SireMaths::Transform getAlignment(SireMol::MoleculeView,SireBase::PropertyMap,SireMol::MoleculeView,SireBase::PropertyMap [,bool=True])

getAlignment( (MoleculeView)view0, (MoleculeView)view1, (AtomMatcher)matcher [, (bool)fit=True]) -> Transform :

C++ signature :

SireMaths::Transform getAlignment(SireMol::MoleculeView,SireMol::MoleculeView,SireMol::AtomMatcher [,bool=True])

getAlignment( (MoleculeView)view0, (MoleculeView)view1, (AtomMatcher)matcher, (PropertyMap)map [, (bool)fit=True]) -> Transform :

C++ signature :

SireMaths::Transform getAlignment(SireMol::MoleculeView,SireMol::MoleculeView,SireMol::AtomMatcher,SireBase::PropertyMap [,bool=True])

getAlignment( (MoleculeView)view0, (PropertyMap)map0, (MoleculeView)view1, (PropertyMap)map1, (AtomMatcher)matcher [, (bool)fit=True]) -> Transform :

C++ signature :

SireMaths::Transform getAlignment(SireMol::MoleculeView,SireBase::PropertyMap,SireMol::MoleculeView,SireBase::PropertyMap,SireMol::AtomMatcher [,bool=True])

sire.mol.is_water(mol, map=None)[source]

Return whether or not the passed molecule (or collection of molecules) are water. This returns a single True or False if a single molecule is passed, or a list of True/False values if a molecule collection is passed.

sire.mol.selection_to_atoms(mols, atoms)[source]

Convert the passed selection to a list of atoms.

Parameters:

  • mols (A molecule view or collection) – The molecule container from which to select the atoms.

  • atoms (str, int, list, molecule view/collection etc.) – Any valid search string, atom index, list of atom indicies, or molecule view/container that can be used to select atoms from mols

Returns:

atoms – of atoms.

Return type:

A SelectorM_Atoms_ or Selector_Atom_ containing the list

Examples

>>> import sire as sr
>>> mols = sr.load(sr.expand(sr.tutorial_url, "ala.top", "ala.crd"))
>>> sr.mol.selection_to_atoms(mols, "atomname CA")
Selector<SireMol::Atom>( size=1
0:  Atom( CA:9    [  16.54,    5.03,   15.81] )
)

>>> sr.mol.selection_to_atoms(mols, "resname ALA")
Selector<SireMol::Atom>( size=10
0:  Atom( N:7     [  17.22,    4.31,   14.71] )
1:  Atom( H:8     [  16.68,    3.62,   14.22] )
2:  Atom( CA:9    [  16.54,    5.03,   15.81] )
3:  Atom( HA:10   [  17.29,    5.15,   16.59] )
4:  Atom( CB:11   [  16.05,    6.39,   15.26] )
5:  Atom( HB1:12  [  15.63,    6.98,   16.07] )
6:  Atom( HB2:13  [  16.90,    6.89,   14.80] )
7:  Atom( HB3:14  [  15.24,    6.18,   14.55] )
8:  Atom( C:15    [  15.37,    4.19,   16.43] )
9:  Atom( O:16    [  14.94,    3.17,   15.88] )
)

>>> sr.mol.selection_to_atoms(mols, [0, 1, 2, 3])
SireMol::SelectorM<SireMol::Atom>( size=4
0: MolNum(641) Atom( HH31:1  [  18.45,    3.49,   12.44] )
1: MolNum(641) Atom( CH3:2   [  18.98,    3.45,   13.39] )
2: MolNum(641) Atom( HH32:3  [  20.05,    3.63,   13.29] )
3: MolNum(641) Atom( HH33:4  [  18.80,    2.43,   13.73] )
)

>>> sr.mol.selection_to_atoms(mols, mols[0])
Selector<SireMol::Atom>( size=22
0:  Atom( HH31:1  [  18.45,    3.49,   12.44] )
1:  Atom( CH3:2   [  18.98,    3.45,   13.39] )
2:  Atom( HH32:3  [  20.05,    3.63,   13.29] )
3:  Atom( HH33:4  [  18.80,    2.43,   13.73] )
4:  Atom( C:5     [  18.48,    4.55,   14.35] )
...
17:  Atom( H:18    [  15.34,    5.45,   17.96] )
18:  Atom( CH3:19  [  13.83,    3.94,   18.35] )
19:  Atom( HH31:20 [  14.35,    3.41,   19.15] )
20:  Atom( HH32:21 [  13.19,    4.59,   18.94] )
21:  Atom( HH33:22 [  13.21,    3.33,   17.69] )
)