Public API#
- class sire.mol.Atom#
This is a single-atom view into a molecule.
Author: Christopher Woods
- 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)
- 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_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})
- 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_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, (PropertyMap)map) -> None :
- C++ signature :
void loadFrame(SireMol::MoleculeView {lvalue},int,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.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_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_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})
- 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_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, (PropertyMap)map) -> None :
- C++ signature :
void loadFrame(SireMol::MoleculeView {lvalue},int,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.
- 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
- 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, 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.
- 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’
- 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
- 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, 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.
- 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’
- 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
- 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, 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.
- 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’
- class sire.mol.Dynamics(mols=None, map=None, cutoff=None, cutoff_type=None, timestep=None, save_frequency=None, constraint=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
- constraint()[source]#
Return the constraint used for the dynamics (e.g. constraining bonds involving hydrogens etc.)
- 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.
- step_speed(time_unit=None)[source]#
Return the speed of this simulation in number of steps per second
- 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 first couple of rows (proton number < 18) and is not a noble gas.
- 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>)
- 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})
- 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)[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
- 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)
- 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_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})
- 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_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})
- 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, (PropertyMap)map) -> None :
- C++ signature :
void loadFrame(SireMol::MoleculeView {lvalue},int,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})
- 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
- 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_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_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)
- atom((SelectorMol)arg1, (int)i[, (PropertyMap)map={}]) Atom : #
- C++ signature :
SireMol::Atom atom(SireMol::SelectorMol {lvalue},int [,SireBase::PropertyMap={}])
atom( (SelectorMol)arg1, (object)name [, (PropertyMap)map={}]) -> Atom :
- C++ signature :
SireMol::Atom atom(SireMol::SelectorMol {lvalue},QString [,SireBase::PropertyMap={}])
atom( (SelectorMol)arg1, (AtomID)atomid [, (PropertyMap)map={}]) -> Atom :
- C++ signature :
SireMol::Atom atom(SireMol::SelectorMol {lvalue},SireMol::AtomID [,SireBase::PropertyMap={}])
- 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_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(map=None, cutoff=None, cutoff_type=None, timestep=None, save_frequency=None, constraint=None)#
Return a Dynamics object that can be used to perform dynamics of the molecule(s) in this view
- 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, (PropertyMap)map) -> None :
- C++ signature :
void loadFrame(SireMol::SelectorMol {lvalue},int,SireBase::PropertyMap)
- minimisation(map=None)#
Return a Minimisation object that can be used to minimise the energy of the molecule(s) in this view.
- 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})
- smiles(include_hydrogens: bool = False, map=None)#
Return the molecule views in this container as smiles strings. Include hydrogens in ‘include_hydrogens’ is True. This returns a list of smiles strings, in the same order as the views in the container
- 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})
- 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(no_default: bool = False, orthographic: bool = True, protein: str | None = None, water: str | None = None, ions: str | None = None, rest: str | None = None, all: str | None = None, ball_and_stick: str | None = None, cartoon: str | None = None, licorice: str | None = None, line: str | None = None, point: str | None = None, ribbon: str | None = None, rocket: str | None = None, rope: str | None = None, spacefill: str | None = None, surface: str | None = None, trace: str | None = None, tube: str | None = None, stage_parameters: str | None = 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.
See the NGLView documentation for more information on how to configure the viewer.
https://nglviewer.org/#nglview
- 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, map=None)[source]#
An iterator that can be used to control which frames of a trajectory are accessed or processed.
- 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