Public API¶
- 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})
- get_link()¶
getLink( (MoleculeView)arg1, (PropertyName)key) -> object :
Return the link for the given property name. This will throw an exception if there is no link for the given property name.
- C++ signature :
QString getLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)
- get_links()¶
getLinks( (MoleculeView)arg1) -> object :
Return the property links for this molecule. This returns an empty dictionary if there are no links.
- C++ signature :
QHash<QString, QString> getLinks(SireMol::MoleculeView {lvalue})
- has_links()¶
hasLinks( (MoleculeView)arg1) -> bool :
Return whether or not this molecule has any property links
- C++ signature :
bool hasLinks(SireMol::MoleculeView {lvalue})
- has_metadata()¶
- hasMetadata( (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})
- is_link()¶
isLink( (MoleculeView)arg1, (PropertyName)key) -> bool :
Return whether or not this molecule has a link for the given property name
- C++ signature :
bool isLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)
- is_null()¶
- isNull( (MoleculeView)arg1) -> bool :
Return whether or not this molecule view is null
- C++ signature :
bool isNull(SireMol::MoleculeView {lvalue})
- is_same_molecule()¶
- isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :
Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)
- C++ signature :
bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeView)
- isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :
Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)
- C++ signature :
bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeData)
- is_selector()¶
- isSelector( (MoleculeView)arg1) -> bool :
- Return whether or not this is a Selector<T> object. This
helps code distinguish between views of single objects, e.g. Atom, Residue etc., and views of multiple objects, e.g. Selector<Atom>, Selector<Residue> etc.
- C++ signature :
bool isSelector(SireMol::MoleculeView {lvalue})
- 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:
- 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:
- 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)
- get_link()¶
getLink( (MoleculeView)arg1, (PropertyName)key) -> object :
Return the link for the given property name. This will throw an exception if there is no link for the given property name.
- C++ signature :
QString getLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)
- get_links()¶
getLinks( (MoleculeView)arg1) -> object :
Return the property links for this molecule. This returns an empty dictionary if there are no links.
- C++ signature :
QHash<QString, QString> getLinks(SireMol::MoleculeView {lvalue})
- 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})
- has_links()¶
hasLinks( (MoleculeView)arg1) -> bool :
Return whether or not this molecule has any property links
- C++ signature :
bool hasLinks(SireMol::MoleculeView {lvalue})
- has_metadata()¶
- hasMetadata( (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})
- is_link()¶
isLink( (MoleculeView)arg1, (PropertyName)key) -> bool :
Return whether or not this molecule has a link for the given property name
- C++ signature :
bool isLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)
- is_null()¶
- isNull( (MoleculeView)arg1) -> bool :
Return whether or not this molecule view is null
- C++ signature :
bool isNull(SireMol::MoleculeView {lvalue})
- is_same_molecule()¶
- isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :
Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)
- C++ signature :
bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeView)
- isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :
Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)
- C++ signature :
bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeData)
- is_selector()¶
- isSelector( (MoleculeView)arg1) -> bool :
- Return whether or not this is a Selector<T> object. This
helps code distinguish between views of single objects, e.g. Atom, Residue etc., and views of multiple objects, e.g. Selector<Atom>, Selector<Residue> etc.
- C++ signature :
bool isSelector(SireMol::MoleculeView {lvalue})
- load_frame()¶
loadFrame( (MoleculeView)arg1, (int)frame) -> None :
- C++ signature :
void loadFrame(SireMol::MoleculeView {lvalue},int)
loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator) -> None :
- C++ signature :
void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator)
loadFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :
- C++ signature :
void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)
loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator, (PropertyMap)map) -> None :
- C++ signature :
void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator,SireBase::PropertyMap)
- 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})
- get_link()¶
getLink( (MoleculeView)arg1, (PropertyName)key) -> object :
Return the link for the given property name. This will throw an exception if there is no link for the given property name.
- C++ signature :
QString getLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)
- get_links()¶
getLinks( (MoleculeView)arg1) -> object :
Return the property links for this molecule. This returns an empty dictionary if there are no links.
- C++ signature :
QHash<QString, QString> getLinks(SireMol::MoleculeView {lvalue})
- has_links()¶
hasLinks( (MoleculeView)arg1) -> bool :
Return whether or not this molecule has any property links
- C++ signature :
bool hasLinks(SireMol::MoleculeView {lvalue})
- has_metadata()¶
- hasMetadata( (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})
- is_link()¶
isLink( (MoleculeView)arg1, (PropertyName)key) -> bool :
Return whether or not this molecule has a link for the given property name
- C++ signature :
bool isLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)
- is_null()¶
- isNull( (MoleculeView)arg1) -> bool :
Return whether or not this molecule view is null
- C++ signature :
bool isNull(SireMol::MoleculeView {lvalue})
- is_same_molecule()¶
- isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :
Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)
- C++ signature :
bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeView)
- isSameMolecule( (MoleculeView)arg1, (MoleculeView)other) -> bool :
Return whether or not this view is of the same molecule as other (albeit perhaps a different version of the molecule)
- C++ signature :
bool isSameMolecule(SireMol::MoleculeView {lvalue},SireMol::MoleculeData)
- is_selector()¶
- isSelector( (MoleculeView)arg1) -> bool :
- Return whether or not this is a Selector<T> object. This
helps code distinguish between views of single objects, e.g. Atom, Residue etc., and views of multiple objects, e.g. Selector<Atom>, Selector<Residue> etc.
- C++ signature :
bool isSelector(SireMol::MoleculeView {lvalue})
- load_frame()¶
loadFrame( (MoleculeView)arg1, (int)frame) -> None :
- C++ signature :
void loadFrame(SireMol::MoleculeView {lvalue},int)
loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator) -> None :
- C++ signature :
void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator)
loadFrame( (MoleculeView)arg1, (int)frame, (PropertyMap)map) -> None :
- C++ signature :
void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::PropertyMap)
loadFrame( (MoleculeView)arg1, (int)frame, (LazyEvaluator)evaluator, (PropertyMap)map) -> None :
- C++ signature :
void loadFrame(SireMol::MoleculeView {lvalue},int,SireBase::LazyEvaluator,SireBase::PropertyMap)
- 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.
- 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;
a string containing the name of the function to call, or
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:
- 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’
- 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’
- delete_frame(*args, **kwargs)[source]¶
Call the
delete_frame
function on the contained view, passing the arguments directly. This is equivalent to callingdelete_frame
directly on the contained view.
- 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_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)
- 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_internal()[source]¶
Return whether or not this is a view of an internal (i.e. bond, angle, dihedral or improper)
- 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.
- load_frame(*args, **kwargs)[source]¶
Call the
load_frame
function on the contained view, passing the arguments directly. This is equivalent to callingload_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.
- 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)
- 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
- 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 callingsave_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’
- 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
- 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
- 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;
a string containing the name of the function to call, or
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:
- 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’
- 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_frame(*args, **kwargs)[source]¶
Call ‘delete_frame’ with these arguments on all contained cursors
- 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’
- 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.
- 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’
- 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.
- 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.
- 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;
a string containing the name of the function to call, or
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:
- 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’
- 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’
- delete_frame(*args, **kwargs)[source]¶
Call the ‘delete_frame’ function with these arguments on all contained cursors
- 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’
- 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.
- 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’
- 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’
- 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.
- 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)[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.)
- 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
- 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
- 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.
- 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.)
- 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)
- 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]
- 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)[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
- 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})
- get_link()¶
getLink( (MoleculeView)arg1, (PropertyName)key) -> object :
Return the link for the given property name. This will throw an exception if there is no link for the given property name.
- C++ signature :
QString getLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)
- get_links()¶
getLinks( (MoleculeView)arg1) -> object :
Return the property links for this molecule. This returns an empty dictionary if there are no links.
- C++ signature :
QHash<QString, QString> getLinks(SireMol::MoleculeView {lvalue})
- has_links()¶
hasLinks( (MoleculeView)arg1) -> bool :
Return whether or not this molecule has any property links
- C++ signature :
bool hasLinks(SireMol::MoleculeView {lvalue})
- has_metadata()¶
- hasMetadata( (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})
- is_link()¶
isLink( (MoleculeView)arg1, (PropertyName)key) -> bool :
Return whether or not this molecule has a link for the given property name
- C++ signature :
bool isLink(SireMol::MoleculeView {lvalue},SireBase::PropertyName)
- is_null()¶
- isNull( (MoleculeView)arg1) -> bool :
Return whether or not this molecule view is null
- C++ signature :
bool isNull(SireMol::MoleculeView {lvalue})
- is_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;
a string containing the name of the function to call, or
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;
a string containing the name of the function to call, or
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, 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 ofconstraint
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.
- 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 ofconstraint
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;
a string containing the name of the function to call, or
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
- 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)
- 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] ) )