Public API

View Module Index

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_all_frames()

deleteAllFrames( (MoleculeView)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue})

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

C++ signature :

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

delete_frame()

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

C++ signature :

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

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

C++ signature :

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

edit((Atom)arg1) → AtomEditor :

Return an editor that can be used to edit this atom

C++ signature :

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

energy(other=None, map=None)

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

other: (view or views, optional)

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

map: (dictionary, optional)

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

Returns:

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

Return type:

sire.units.GeneralUnit (energy per quantity)

evaluate((Atom)arg1) → Evaluator :

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

C++ signature :

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

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.AtomMatch

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

assert_contains()

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

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

C++ signature :

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

assert_has_metadata()

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

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

C++ signature :

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

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

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

C++ signature :

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

assert_has_property()

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

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

C++ signature :

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

assert_same_molecule()

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

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

C++ signature :

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

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

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

C++ signature :

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

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

C++ signature :

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

clone((AtomMatch)arg1) → AtomMatch :

C++ signature :

SireMol::AtomMatch clone(SireMol::AtomMatch)

const_data()

constData( (MoleculeView)arg1) -> object :

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

C++ signature :

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

cutgroup()

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

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

C++ signature :

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

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

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

C++ signature :

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

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

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

C++ signature :

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

cutGroup( (MoleculeView)arg1) -> CutGroup :

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

C++ signature :

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

cutgroups()

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

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

C++ signature :

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

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

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

C++ signature :

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

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

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

C++ signature :

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

cutGroups( (MoleculeView)arg1) -> Selector_CutGroup_ :

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

C++ signature :

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

delete_all_frames()

deleteAllFrames( (MoleculeView)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue})

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

C++ signature :

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

delete_frame()

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

C++ signature :

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

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

C++ signature :

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

group((AtomMatch)arg1, (int)i) → Selector_Atom_ :

C++ signature :

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

groups((AtomMatch)arg1) → object :

C++ signature :

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

has_metadata()

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

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

C++ signature :

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

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

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

C++ signature :

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

has_property()

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

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

C++ signature :

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

is_empty()

isEmpty( (PartialMolecule)arg1) -> bool :

Return whether or not this is empty

C++ signature :

bool isEmpty(SireMol::PartialMolecule {lvalue})

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

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

C++ signature :

QStringList metadataKeys(SireMol::PartialMolecule {lvalue})

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

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

C++ signature :

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

metadata_type()

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

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

C++ signature :

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

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

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

C++ signature :

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

num_atoms()

nAtoms( (PartialMolecule)arg1) -> int :

Return the number of atoms in this view

C++ signature :

int nAtoms(SireMol::PartialMolecule {lvalue})

num_chains()

nChains( (PartialMolecule)arg1) -> int :

Return the number of chains in this view

C++ signature :

int nChains(SireMol::PartialMolecule {lvalue})

num_cutgroups()

nCutGroups( (PartialMolecule)arg1) -> int :

Return the number of CutGroups in this view

C++ signature :

int nCutGroups(SireMol::PartialMolecule {lvalue})

num_frames()

nFrames( (MoleculeView)arg1) -> int :

C++ signature :

int nFrames(SireMol::MoleculeView {lvalue})

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

C++ signature :

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

num_groups()

nGroups( (AtomMatch)arg1) -> int :

C++ signature :

int nGroups(SireMol::AtomMatch {lvalue})

num_residues()

nResidues( (PartialMolecule)arg1) -> int :

Return the number of residues in this view

C++ signature :

int nResidues(SireMol::PartialMolecule {lvalue})

num_segments()

nSegments( (PartialMolecule)arg1) -> int :

Return the number of segments in this view

C++ signature :

int nSegments(SireMol::PartialMolecule {lvalue})

num_views()

nViews( (MoleculeView)arg1) -> int :

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

C++ signature :

int nViews(SireMol::MoleculeView {lvalue})

property_keys()

propertyKeys( (PartialMolecule)arg1) -> object :

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

C++ signature :

QStringList propertyKeys(SireMol::PartialMolecule {lvalue})

property_type()

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

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

C++ signature :

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

save_frame()

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

select_all()

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

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

C++ signature :

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

selectAll( (MoleculeView)arg1) -> Selector_Atom_ :

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

C++ signature :

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

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

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

C++ signature :

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

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

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

C++ signature :

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

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

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

C++ signature :

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

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

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

C++ signature :

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

select_all_atoms()

selectAllAtoms( (MoleculeView)arg1) -> Selector_Atom_ :

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

C++ signature :

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

select_all_chains()

selectAllChains( (MoleculeView)arg1) -> Selector_Chain_ :

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

C++ signature :

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

select_all_cutgroups()

selectAllCutGroups( (MoleculeView)arg1) -> Selector_CutGroup_ :

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

C++ signature :

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

select_all_residues()

selectAllResidues( (MoleculeView)arg1) -> Selector_Residue_ :

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

C++ signature :

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

select_all_segments()

selectAllSegments( (MoleculeView)arg1) -> Selector_Segment_ :

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

C++ signature :

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

selected_all()

selectedAll( (PartialMolecule)arg1) -> bool :

Return whether or not this contains the entire molecule

C++ signature :

bool selectedAll(SireMol::PartialMolecule {lvalue})

to_list()

toList( (MoleculeView)arg1) -> object :

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

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

C++ signature :

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

to_molecules()

toMolecules( (MoleculeView)arg1) -> Molecules :

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

C++ signature :

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

to_selector()

toSelector( (PartialMolecule)arg1) -> object :

C++ signature :

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

to_string()

toString( (AtomMatch)arg1) -> object :

C++ signature :

QString toString(SireMol::AtomMatch {lvalue})

to_unit()

toUnit( (PartialMolecule)arg1) -> object :

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

C++ signature :

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

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((AtomMatch)arg1) → str :

C++ signature :

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

class sire.mol.AtomMatchM

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

atoms((AtomMatchM)arg1) → SelectorM_Atom_ :

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

chains((AtomMatchM)arg1) → SelectorM_Chain_ :

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

clone((AtomMatchM)arg1) → AtomMatchM :

C++ signature :

SireMol::AtomMatchM clone(SireMol::AtomMatchM)

contains((AtomMatchM)arg1, (SelectorM_Atom_)other) → bool :

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

count((AtomMatchM)arg1) → int :

C++ signature :

int count(SireMol::AtomMatchM {lvalue})

cutgroup()

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

cutgroups()

cutGroups( (AtomMatchM)arg1) -> SelectorM_CutGroup_ :

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

delete_all_frames()

deleteAllFrames( (AtomMatchM)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMol::AtomMatchM {lvalue})

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

C++ signature :

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

delete_frame()

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

C++ signature :

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

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

C++ signature :

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

evaluate((AtomMatchM)arg1) → EvaluatorM :

C++ signature :

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

extract((AtomMatchM)arg1) → SelectorMol :

C++ signature :

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

find((AtomMatchM)arg1, (Atom)view) → object :

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

group((AtomMatchM)arg1, (int)i) → Selector_Atom_ :

C++ signature :

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

groups((AtomMatchM)arg1) → object :

C++ signature :

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

has_metadata()

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

C++ signature :

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

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

C++ signature :

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

has_property()

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

C++ signature :

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

ids()

IDs( (AtomMatchM)arg1) -> object :

C++ signature :

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

indexes((AtomMatchM)arg1) → object :

C++ signature :

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

intersection((AtomMatchM)arg1, (SelectorM_Atom_)other) → SelectorM_Atom_ :

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

intersects((AtomMatchM)arg1, (SelectorM_Atom_)other) → bool :

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

invert((AtomMatchM)arg1) → SelectorM_Atom_ :

C++ signature :

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

is_empty()

isEmpty( (AtomMatchM)arg1) -> bool :

C++ signature :

bool isEmpty(SireMol::AtomMatchM {lvalue})

is_selector()

isSelector( (AtomMatchM)arg1) -> bool :

C++ signature :

bool isSelector(SireMol::AtomMatchM {lvalue})

load_frame()

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

C++ signature :

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

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

C++ signature :

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

metadata_keys()

metadataKeys( (AtomMatchM)arg1) -> object :

C++ signature :

QStringList metadataKeys(SireMol::AtomMatchM {lvalue})

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

molecules((AtomMatchM)arg1) → SelectorMol :

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

names((AtomMatchM)arg1) → object :

C++ signature :

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

num_atoms()

nAtoms( (AtomMatchM)arg1) -> int :

C++ signature :

int nAtoms(SireMol::AtomMatchM {lvalue})

num_chains()

nChains( (AtomMatchM)arg1) -> int :

C++ signature :

int nChains(SireMol::AtomMatchM {lvalue})

num_cutgroups()

nCutGroups( (AtomMatchM)arg1) -> int :

C++ signature :

int nCutGroups(SireMol::AtomMatchM {lvalue})

num_frames()

nFrames( (AtomMatchM)arg1) -> int :

C++ signature :

int nFrames(SireMol::AtomMatchM {lvalue})

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

C++ signature :

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

num_groups()

nGroups( (AtomMatchM)arg1) -> int :

C++ signature :

int nGroups(SireMol::AtomMatchM {lvalue})

num_molecules()

nMolecules( (AtomMatchM)arg1) -> int :

C++ signature :

int nMolecules(SireMol::AtomMatchM {lvalue})

num_residues()

nResidues( (AtomMatchM)arg1) -> int :

C++ signature :

int nResidues(SireMol::AtomMatchM {lvalue})

num_segments()

nSegments( (AtomMatchM)arg1) -> int :

C++ signature :

int nSegments(SireMol::AtomMatchM {lvalue})

numbers((AtomMatchM)arg1) → object :

C++ signature :

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

property_keys()

propertyKeys( (AtomMatchM)arg1) -> object :

C++ signature :

QStringList propertyKeys(SireMol::AtomMatchM {lvalue})

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

residues((AtomMatchM)arg1) → SelectorM_Residue_ :

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

save_frame()

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

search((AtomMatchM)arg1, (object)search_string) → SelectResult :

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

segments((AtomMatchM)arg1) → SelectorM_Segment_ :

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

size((AtomMatchM)arg1) → int :

C++ signature :

int size(SireMol::AtomMatchM {lvalue})

to_list()

toList( (AtomMatchM)arg1) -> object :

C++ signature :

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

to_molecule_group()

toMoleculeGroup( (AtomMatchM)arg1) -> MoleculeGroup :

C++ signature :

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

to_molecules()

toMolecules( (AtomMatchM)arg1) -> Molecules :

C++ signature :

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

to_select_result()

toSelectResult( (AtomMatchM)arg1) -> SelectResult :

C++ signature :

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

to_string()

toString( (AtomMatchM)arg1) -> object :

C++ signature :

QString toString(SireMol::AtomMatchM {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

update((AtomMatchM)arg1, (MoleculeView)molview) → None :

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

what((AtomMatchM)arg1) → str :

C++ signature :

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

class sire.mol.AtomName

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

Author: Christopher Woods

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

C++ signature :

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

clone((AtomName)arg1) → AtomName :

C++ signature :

SireMol::AtomName clone(SireMol::AtomName)

hash((AtomName)arg1) → int :

C++ signature :

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

is_null()

isNull( (AtomName)arg1) -> bool :

C++ signature :

bool isNull(SireMol::AtomName {lvalue})

map((AtomName)arg1, (MolInfo)molinfo) → object :

C++ signature :

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

to_string()

toString( (AtomName)arg1) -> object :

C++ signature :

QString toString(SireMol::AtomName {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((AtomName)arg1) → str :

C++ signature :

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

class sire.mol.AtomNum

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

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

Author: Christopher Woods

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

C++ signature :

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

clone((AtomNum)arg1) → AtomNum :

C++ signature :

SireMol::AtomNum clone(SireMol::AtomNum)

hash((AtomNum)arg1) → int :

C++ signature :

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

is_null()

isNull( (AtomNum)arg1) -> bool :

C++ signature :

bool isNull(SireMol::AtomNum {lvalue})

map((AtomNum)arg1, (MolInfo)molinfo) → object :

C++ signature :

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

to_string()

toString( (AtomNum)arg1) -> object :

C++ signature :

QString toString(SireMol::AtomNum {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((AtomNum)arg1) → str :

C++ signature :

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

class sire.mol.BondOrder

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

Author: Christopher Woods

aromatic_bond()

aromaticBond() -> BondOrder :

Return an aromatic bond

C++ signature :

SireMol::BondOrder aromaticBond()

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

C++ signature :

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

clone((BondOrder)arg1) → BondOrder :

C++ signature :

SireMol::BondOrder clone(SireMol::BondOrder)

double_bond()

doubleBond() -> BondOrder :

Return a double bond

C++ signature :

SireMol::BondOrder doubleBond()

from_rdkit()

fromRDKit( (object)value) -> BondOrder :

Construct from a string representation of the RDKit type

C++ signature :

SireMol::BondOrder fromRDKit(QString)

from_s_d_f()

fromSDF( (int)value) -> BondOrder :

Construct from the the passed SDF number

C++ signature :

SireMol::BondOrder fromSDF(int)

is_defined()

isDefined( (BondOrder)arg1) -> bool :

Return whether or not the bond type is defined

C++ signature :

bool isDefined(SireMol::BondOrder {lvalue})

is_double()

isDouble( (BondOrder)arg1) -> bool :

Return whether or not this is a double bond

C++ signature :

bool isDouble(SireMol::BondOrder {lvalue})

is_single()

isSingle( (BondOrder)arg1) -> bool :

Return whether or not this is a single bond

C++ signature :

bool isSingle(SireMol::BondOrder {lvalue})

is_triple()

isTriple( (BondOrder)arg1) -> bool :

Return whether or not this is a triple bond

C++ signature :

bool isTriple(SireMol::BondOrder {lvalue})

isromatic()

isAromatic( (BondOrder)arg1) -> bool :

Return whether or not this is an aromatic bond

C++ signature :

bool isAromatic(SireMol::BondOrder {lvalue})

single_bond()

singleBond() -> BondOrder :

Return a single bond

C++ signature :

SireMol::BondOrder singleBond()

to_rdkit()

toRDKit( (BondOrder)arg1) -> object :

Return as a string representation of a RDKit bond order

C++ signature :

QString toRDKit(SireMol::BondOrder {lvalue})

to_s_d_f()

toSDF( (BondOrder)arg1) -> int :

Return the SDF-format value for this bond

C++ signature :

int toSDF(SireMol::BondOrder {lvalue})

to_string()

toString( (BondOrder)arg1) -> object :

C++ signature :

QString toString(SireMol::BondOrder {lvalue})

triple_bond()

tripleBond() -> BondOrder :

Return a triple bond

C++ signature :

SireMol::BondOrder tripleBond()

typename()

typeName() -> str :

C++ signature :

char const* typeName()

undefined_bond()

undefinedBond() -> BondOrder :

Return an undefined bond

C++ signature :

SireMol::BondOrder undefinedBond()

value((BondOrder)arg1) → int :

Return the bond type (0 to number of bonds)

C++ signature :

int value(SireMol::BondOrder {lvalue})

value_as_double()

valueAsDouble( (BondOrder)arg1) -> float :

Return the bond order as a double precision number. This matches

the value that would be returned by RDKit

C++ signature :

double valueAsDouble(SireMol::BondOrder {lvalue})

class sire.mol.Chain

This class represents a Chain in a Molecule.

Author: Christopher Woods

assert_contains()

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

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

C++ signature :

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

assert_contains_metadata()

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

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

C++ signature :

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

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

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

C++ signature :

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

assert_contains_property()

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

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

C++ signature :

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

assert_has_metadata()

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

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

C++ signature :

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

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

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

C++ signature :

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

assert_has_property()

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

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

C++ signature :

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

assert_same_molecule()

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

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

C++ signature :

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

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

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

C++ signature :

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

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

C++ signature :

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

atom_idxs()

atomIdxs( (Chain)arg1) -> object :

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

C++ signature :

QList<SireMol::AtomIdx> atomIdxs(SireMol::Chain {lvalue})

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

Return the atoms from this view that match the ID atomid

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

C++ signature :

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

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

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

C++ signature :

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

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

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

C++ signature :

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

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

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

C++ signature :

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

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

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

C++ signature :

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

atoms( (MoleculeView)arg1) -> Selector_Atom_ :

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

C++ signature :

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

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

Return the chains that are involved with this view that match

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

C++ signature :

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

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

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

C++ signature :

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

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

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

C++ signature :

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

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

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

C++ signature :

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

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

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

C++ signature :

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

chains( (MoleculeView)arg1) -> Selector_Chain_ :

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

C++ signature :

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

clone((Chain)arg1) → Chain :

C++ signature :

SireMol::Chain clone(SireMol::Chain)

const_data()

constData( (MoleculeView)arg1) -> object :

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

C++ signature :

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

contains((Chain)arg1, (AtomIdx)atomidx) → bool :

Return whether or not this chain contains the atom

at index atomidx

C++ signature :

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

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

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

C++ signature :

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

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

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

C++ signature :

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

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

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

C++ signature :

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

count()

nResidues( (Chain)arg1) -> int :

Return the number of residues in this chain

C++ signature :

int nResidues(SireMol::Chain {lvalue})

cursor(map=None)

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

cutgroup()

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

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

C++ signature :

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

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

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

C++ signature :

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

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

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

C++ signature :

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

cutGroup( (MoleculeView)arg1) -> CutGroup :

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

C++ signature :

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

cutgroups()

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

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

C++ signature :

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

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

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

C++ signature :

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

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

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

C++ signature :

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

cutGroups( (MoleculeView)arg1) -> Selector_CutGroup_ :

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

C++ signature :

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

delete_all_frames()

deleteAllFrames( (MoleculeView)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue})

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

C++ signature :

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

delete_frame()

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

C++ signature :

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

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

C++ signature :

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

edit((Chain)arg1) → ChainEditor :

Return an editor that can edit this chain

C++ signature :

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

energy(other=None, map=None)

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

other: (view or views, optional)

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

map: (dictionary, optional)

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

Returns:

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

Return type:

sire.units.GeneralUnit (energy per quantity)

evaluate((Chain)arg1) → Evaluator :

Return an evaluator that can evaluate properties of this chain

C++ signature :

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

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)

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

angle(*args, **kwargs)

Return the Cursor for the specified angle.

angles(*args, **kwargs)

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)

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

The function can be either;

1. a string containing the name of the function to call, or

2. an actual function (either a normal function or a lambda expression)

You can optionally pass in positional and keyword arguments here that will be passed to the function.

Parameters:

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

Returns:

This cursor

Return type:

Cursor

atom(i)

Return the atom in the molecule that matches the passed ID

atoms(id=None)

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

bond(*args, **kwargs)

Return the Cursor for the specified bond.

bonds(*args, **kwargs)

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)

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)

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

commit()

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

delete(key)

Remove the property associated with the key ‘key’

delete_frame(*args, **kwargs)

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

dihedral(*args, **kwargs)

Return the Cursor for the specified dihedral.

dihedrals(*args, **kwargs)

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

evaluate(*args, **kwargs)

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

get(key)

Return the property associated with key ‘key’

get_index()

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

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

get_number()

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

id()

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

improper(*args, **kwargs)

Return the Cursor for the specified improper.

impropers(*args, **kwargs)

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

property index

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

is_angle()

Return whether this is pointing to an Angle

is_atom()

Return whether this is pointing to an Atom

is_bond()

Return whether this is pointing to a Bond

is_chain()

Return whether this is pointing to a Chain

is_dihedral()

Return whether this is pointing to a Dihedral

is_improper()

Return whether this is pointing to an Improper

is_internal()

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

is_molecule()

Return whether this is pointing to a Molecule

is_residue()

Return whether this is pointing to a Residue

is_same_editor(other)

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

is_segment()

Return whether this is pointing to a Segment

load_frame(*args, **kwargs)

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

make_whole(center=None, map=None)

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

molecule()

Return the molecule

property name

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

num_frames()

Return the number of trajectory frames contained by the molecule

property number

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

parent()

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

properties()

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

renumber()

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

residue(i=None)

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)

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)

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)

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

segment(i=None)

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)

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

set(key, value)

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

set_name(name)

Set the name of the object in the current view

set_number(number)

Set the number of the object in the current view

transform(transform, map=None)

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

translate(*args, map=None)

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

type()

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

view()

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

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

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

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

angle(*args, **kwargs)

Return the Cursor for the specified angle.

angles(*args, **kwargs)

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)

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

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

The function can be either;

1. a string containing the name of the function to call, or

2. an actual function (either a normal function or a lambda expression)

You can optionally pass in positional and keyword arguments here that will be passed to the function.

Parameters:

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

Returns:

This list of cursors

Return type:

Cursors

atom(i)

Return the atom in the molecule that matches the passed ID

atoms(id=None)

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

bond(*args, **kwargs)

Return the Cursor for the specified bond.

bonds(*args, **kwargs)

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)

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)

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

commit()

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

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

will commit and return the updated molecule (mol).

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

delete(key)

Remove the property associated with the key ‘key’

delete_frame(*args, **kwargs)

Call ‘delete_frame’ with these arguments on all contained cursors

dihedral(*args, **kwargs)

Return the Cursor for the specified dihedral.

dihedrals(*args, **kwargs)

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

get(key)

Return the property associated with key ‘key’

improper(*args, **kwargs)

Return the Cursor for the specified improper.

impropers(*args, **kwargs)

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

invert()

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

is_same_editor(other)

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)

Call load_frame with these arguments on all contained cursors

make_whole(*args, map=None)

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

molecule()

Return the molecule

num_frames()

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

parent()

Return the parent cursor

residue(i=None)

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)

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)

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)

Call ‘save_frame’ with these arguments on all contained cursors

segment(i=None)

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)

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

set(key, value)

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

transform(transform, map=None)

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

translate(*args, map=None)

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

view()

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

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

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

angle(*args, **kwargs)

Return the Cursor for the specified angle.

angles(*args, **kwargs)

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)

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

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

The function can be either;

1. a string containing the name of the function to call, or

2. an actual function (either a normal function or a lambda expression)

You can optionally pass in positional and keyword arguments here that will be passed to the function.

Parameters:

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

Returns:

This list of cursors

Return type:

Cursors

atom(i)

Return the atom in the molecule that matches the passed ID

atoms(id=None)

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

bond(*args, **kwargs)

Return the Cursor for the specified bond.

bonds(*args, **kwargs)

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)

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)

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

commit()

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

delete(key)

Remove the property associated with the key ‘key’

delete_frame(*args, **kwargs)

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

dihedral(*args, **kwargs)

Return the Cursor for the specified dihedral.

dihedrals(*args, **kwargs)

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

get(key)

Return the property associated with key ‘key’

improper(*args, **kwargs)

Return the Cursor for the specified improper.

impropers(*args, **kwargs)

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

invert()

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

load_frame(*args, **kwargs)

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

make_whole(*args, map=None)

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

molecule(i=None)

Return the molecule

molecules(id=None)

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

num_frames()

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

residue(i=None)

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)

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)

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)

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

segment(i=None)

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)

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

set(key, value)

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

transform(transform, map=None)

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

translate(*args, map=None)

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

view()

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

class sire.mol.Dynamics(mols=None, map=None, cutoff=None, cutoff_type=None, timestep=None, save_frequency=None, constraint=None)

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

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

current_energy()

Return the current total energy

current_kinetic_energy()

Return the current kinetic energy

current_potential_energy()

Return the current potential energy

current_space()

Return the current space in which the simulation is being performed

current_step()

Return the current number of completed steps of dynamics

current_time()

Return the current amount of completed time of dynamics

elapsed_time()

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.

ensemble()

Return the ensemble in which the simulation is being performed

info()

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

platform()

Return the name of the OpenMM platform being used for dynamics

run(time, save_frequency=None)

Perform dynamics on the molecules

step_speed(time_unit=None)

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

time_speed(elapsed_unit=None, time_unit=None)

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

timestep()

Return the timestep used for this simulation

walltime()

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

class sire.mol.Element

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

Author: Christopher Woods

actinide((Element)arg1) → bool :

Return whether or not this is an actinide

C++ signature :

bool actinide(SireMol::Element {lvalue})

alkali_earth_metal()

alkaliEarthMetal( (Element)arg1) -> bool :

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

C++ signature :

bool alkaliEarthMetal(SireMol::Element {lvalue})

alkali_metal()

alkaliMetal( (Element)arg1) -> bool :

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

C++ signature :

bool alkaliMetal(SireMol::Element {lvalue})

assign((Element)arg1, (Element)element) → Element :

C++ signature :

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

biological((Element)arg1) → bool :

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

C++ signature :

bool biological(SireMol::Element {lvalue})

biological_element()

biologicalElement( (object)name) -> Element :

Return a biological element that has been guessed from the passed name. Note that if no biological element was guessed, then the nearest non-biological element match is used. A biological element is one that is in the 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)

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

run(max_iterations: int = 1000)

Perform minimisation on the molecules, running a maximum of max_iterations iterations.

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_all_frames()

deleteAllFrames( (MoleculeView)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMol::MoleculeView {lvalue})

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

C++ signature :

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

delete_frame()

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

C++ signature :

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

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

C++ signature :

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

edit((Molecule)arg1) → MolEditor :

Return an Editor that can edit any part of this molecule

C++ signature :

SireMol::MolEditor edit(SireMol::Molecule {lvalue})

energy(other=None, map=None)

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

other: (view or views, optional)

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

map: (dictionary, optional)

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

Returns:

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

Return type:

sire.units.GeneralUnit (energy per quantity)

evaluate((Molecule)arg1) → Evaluator :

Return an Evaluator that evaluates values using all of the atoms in this molecule

C++ signature :

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

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;

1. a string containing the name of the function to call, or

2. an actual function (either a normal function or a lambda expression)

You can optionally pass in positional and keyword arguments here that will be passed to the function.

Parameters:

• objs (self) – The container itself (this is self)

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

Returns:

A list of the results, with one result per view in the container.

Return type:

list

apply_reduce(func, reduction_func=None, *args, **kwargs)

Call the passed function on all views in the container, reducing the result into a single value via the ‘reduce’ function.

This is equivalent to calling

``` reduce(reduction_func, objs.apply(func, *args, **kwargs))

The function can be either;

1. a string containing the name of the function to call, or

2. an actual function (either a normal function or a lambda expression)

The reduction function should be a function that can be passed to reduce. If this isn’t passed, then it is assumed to be operator.add.

You can optionally pass in positional and keyword arguments here that will be passed to the applied function.

Parameters:

• objs (self) – The container itself (this is self)

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

• reduction_func – The function used to reduce the result. This is operator.add by default.

Returns:

The reduced result

Return type:

result

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

C++ signature :

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

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_all_frames()

deleteAllFrames( (SelectorMol)arg1) -> None :

C++ signature :

void deleteAllFrames(SireMol::SelectorMol {lvalue})

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

C++ signature :

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

delete_frame()

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

C++ signature :

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

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

C++ signature :

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

dynamics(map=None, cutoff=None, cutoff_type=None, timestep=None, save_frequency=None, constraint=None, **kwargs)

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

smarts(as_search: bool = False, include_hydrogens: bool = False, map=None)

Return the molecule views in this container as smarts strings. Include hydrogens if ‘include_hydrogens’ is True. This returns a list of smarts strings, in the same order as the views in the container.

If ‘as_search’ is True then the smarts string is returned as a sire search string.

smiles(as_search: bool = True, include_hydrogens: bool = False, map=None)

Return the molecule views in this container as smiles strings. Include hydrogens if ‘include_hydrogens’ is True. This returns a list of smiles strings, in the same order as the views in the container.

If ‘as_search’ is True, then this returns the sire search smiles string

to_list()

toList( (SelectorMol)arg1) -> object :

C++ signature :

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

to_molecule_group()

toMoleculeGroup( (SelectorMol)arg1) -> MoleculeGroup :

C++ signature :

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

to_molecules()

toMolecules( (SelectorMol)arg1) -> Molecules :

C++ signature :

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

to_select_result()

toSelectResult( (SelectorMol)arg1) -> SelectResult :

C++ signature :

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

to_string()

toString( (SelectorMol)arg1) -> object :

C++ signature :

QString toString(SireMol::SelectorMol {lvalue})

trajectory(align=None, smooth=None, wrap=None, map=None)

Return an iterator over the trajectory of frames of this view.

align:

Pass in a selection string to select atoms against which every frame will be aligned. These atoms will be moved to the center of the periodic box (if a periodic box is used). If ‘True’ is passed then this will align against all of the atoms in the view.

smooth:

Pass in the number of frames to smooth (average) the view over. If ‘True’ is passed, then the recommended number of frames will be averaged over

wrap: bool

Whether or not to wrap the coordinates into the periodic box

typename()

typeName() -> str :

C++ signature :

char const* typeName()

update((SelectorMol)arg1, (MoleculeView)molview) → None :

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

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

C++ signature :

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

view(default: bool = True, no_default: bool = False, orthographic: bool = True, protein: str = '', water: str = '', ions: str = '', rest: str = '', all: str = '', ball_and_stick: str = '', base: str = '', cartoon: str = '', hyperball: str = '', licorice: str = '', line: str = '', point: str = '', ribbon: str = '', rocket: str = '', rope: str = '', spacefill: str = '', surface: str = '', trace: str = '', tube: str = '', center: str | None = None, align: str | None = None, smooth=False, wrap=True, 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.

Full instructions on how to use this view are in the cheatsheet (https://sire.openbiosim.org/cheatsheet/view)

center:

Pass in a selection string to select the atoms to center in the view. By default no atoms are centered

align:

Pass in a selection string to select atoms against which every frame will be aligned. These atoms will be moved to the center of the periodic box (if a periodic box is used). If “True” is passed, then this will attempt to align ALL of the coordinates in the view.

smooth:

Pass in the number of frames to smooth (average) the view over. If ‘True’ is passed, then the recommended number of frames will be averaged over

wrap: bool

Whether or not to wrap the coordinates into the periodic box.

orthographic:

Set to False to use a perspective view, or accept the default (True) for an orthographic view

default:

The default representation / color for the view. If this is set to False or None or “none” then default views are disabled.

no_default:

Set to False to disable all default views

protein, water, ions:

Set the default views for protein, water and ion molecules. Set to False, None or “none” to disable these default views.

rest:

Synonym for “default”, but does not disable all default views if set to None, False or “none”

all:

Set the representation for all atoms. Set to None, False or “none” to disable all views.

ball_and_stick, base, cartoon etc.

Set the selection strings for atoms that should be represented with these views.

stage_parameters: dict

An optional dictionary that will be passed directly to the NGLView object to set the stage parameters.

map: dict or sire.base.PropertyMap

An optional property map that can be used to control which properties are used to get the molecular data to be viewed.

what((SelectorMol)arg1) → str :

C++ signature :

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

class sire.mol.Stereochemistry

This class represents a bonds stereochemistry

Author: Christopher Woods

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

C++ signature :

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

clone((Stereochemistry)arg1) → Stereochemistry :

C++ signature :

SireMol::Stereochemistry clone(SireMol::Stereochemistry)

static down() → Stereochemistry :

Return a down Stereochemistry

C++ signature :

SireMol::Stereochemistry down()

from_rdkit()

fromRDKit( (object)value) -> Stereochemistry :

Construct from a string representation of a RDKit stereochemistry

C++ signature :

SireMol::Stereochemistry fromRDKit(QString)

from_s_d_f()

fromSDF( (int)val) -> Stereochemistry :

Construct from the the passed SDF number

C++ signature :

SireMol::Stereochemistry fromSDF(int)

is_defined()

isDefined( (Stereochemistry)arg1) -> bool :

Return whether or not the stereoscopy is defined

C++ signature :

bool isDefined(SireMol::Stereochemistry {lvalue})

is_down()

isDown( (Stereochemistry)arg1) -> bool :

Return whether or not this is a down bond

C++ signature :

bool isDown(SireMol::Stereochemistry {lvalue})

is_not_stereo()

isNotStereo( (Stereochemistry)arg1) -> bool :

Return whether or not this is a not stereo bond

C++ signature :

bool isNotStereo(SireMol::Stereochemistry {lvalue})

is_up()

isUp( (Stereochemistry)arg1) -> bool :

Return whether or not this is an up bond

C++ signature :

bool isUp(SireMol::Stereochemistry {lvalue})

not_stereo()

notStereo() -> Stereochemistry :

Return a not stereo Stereochemistry

C++ signature :

SireMol::Stereochemistry notStereo()

to_rdkit()

toRDKit( (Stereochemistry)arg1) -> object :

Return a string representation of the RDKit stereo value

C++ signature :

QString toRDKit(SireMol::Stereochemistry {lvalue})

to_s_d_f()

toSDF( (Stereochemistry)arg1) -> int :

Return the SDF-format value for this bond. This returns 0 if the stereoscopy is undefined

C++ signature :

int toSDF(SireMol::Stereochemistry {lvalue})

to_string()

toString( (Stereochemistry)arg1) -> object :

C++ signature :

QString toString(SireMol::Stereochemistry {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

static undefined() → Stereochemistry :

Return an undefined Stereochemistry

C++ signature :

SireMol::Stereochemistry undefined()

static up() → Stereochemistry :

Return an up Stereochemistry

C++ signature :

SireMol::Stereochemistry up()

value((Stereochemistry)arg1) → int :

Return the stereo type (uses SDF values, e.g. 0 is not stereo, 1 is up, 6 is down. We have added -1 to mean undefined)

C++ signature :

int value(SireMol::Stereochemistry {lvalue})

class sire.mol.TrajectoryIterator(view=None, align=None, smooth=None, wrap=None, map=None)

An iterator that can be used to control which frames of a trajectory are accessed or processed.

align(align)

Return a copy of this trajectory where each frame will be aligned against the atoms that match the search string ‘align’

apply(func, *args, **kwargs)

Call the passed function on all frames of the trajectory, appending the result to a list of results, which is returned.

The function can be either;

1. a string containing the name of the function to call, or

2. an actual function (either a normal function or a lambda expression)

You can optionally pass in positional and keyword arguments here that will be passed to the function.

Parameters:

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

Returns:

A list of the results, with one result per

frame in the trajectory

Return type:

list

current()

Return the current frame in the trajectory

first()

Return the first frame in the trajectory

frame_indexes()

Return the indexes of the frames in this trajectory that will be viewed

smooth(smooth)

Return a copy of this trajectory where each frame will be smoothed over the specified number of frames (or the recommended number if ‘smooth’ is set to ‘True’)

wrap(autowrap=True)

Return a copy of this trajectory where each frame will be auto-wrapped into the current space

sire.mol.get_alignment()

getAlignment( (MoleculeView)view0, (MoleculeView)view1 [, (bool)fit=True]) -> Transform :

C++ signature :

SireMaths::Transform getAlignment(SireMol::MoleculeView,SireMol::MoleculeView [,bool=True])

getAlignment( (MoleculeView)view0, (MoleculeView)view1, (PropertyMap)map [, (bool)fit=True]) -> Transform :

C++ signature :

SireMaths::Transform getAlignment(SireMol::MoleculeView,SireMol::MoleculeView,SireBase::PropertyMap [,bool=True])

getAlignment( (MoleculeView)view0, (PropertyMap)map0, (MoleculeView)view1, (PropertyMap)map1 [, (bool)fit=True]) -> Transform :

C++ signature :

SireMaths::Transform getAlignment(SireMol::MoleculeView,SireBase::PropertyMap,SireMol::MoleculeView,SireBase::PropertyMap [,bool=True])

getAlignment( (MoleculeView)view0, (MoleculeView)view1, (AtomMatcher)matcher [, (bool)fit=True]) -> Transform :

C++ signature :

SireMaths::Transform getAlignment(SireMol::MoleculeView,SireMol::MoleculeView,SireMol::AtomMatcher [,bool=True])

getAlignment( (MoleculeView)view0, (MoleculeView)view1, (AtomMatcher)matcher, (PropertyMap)map [, (bool)fit=True]) -> Transform :

C++ signature :

SireMaths::Transform getAlignment(SireMol::MoleculeView,SireMol::MoleculeView,SireMol::AtomMatcher,SireBase::PropertyMap [,bool=True])

getAlignment( (MoleculeView)view0, (PropertyMap)map0, (MoleculeView)view1, (PropertyMap)map1, (AtomMatcher)matcher [, (bool)fit=True]) -> Transform :

C++ signature :

SireMaths::Transform getAlignment(SireMol::MoleculeView,SireBase::PropertyMap,SireMol::MoleculeView,SireBase::PropertyMap,SireMol::AtomMatcher [,bool=True])

sire.mol.is_water(mol, map=None)

Return whether or not the passed molecule (or collection of molecules) are water. This returns a single True or False if a single molecule is passed, or a list of True/False values if a molecule collection is passed.