Public API#

class sire.vol.Cartesian#

This class overloads SimVolume to provide an infinite Cartesian (3-dimensional, orthoganol dimensions) volume. This corresponds to a traditional gas-phase or no-boundary system.

Author: Christopher Woods

assign((Cartesian)arg1, (Cartesian)other) → Cartesian :#

C++ signature :: SireVol::Cartesian {lvalue} assign(SireVol::Cartesian {lvalue},SireVol::Cartesian)

beyond((Cartesian)arg1, (float)dist, (AABox)aabox0, (AABox)aabox1) → bool :#

Return whether or not two groups enclosed by the AABoxes aabox0

and aabox1 are definitely beyond the cutoff distance

C++ signature :: bool beyond(SireVol::Cartesian {lvalue},double,SireVol::AABox,SireVol::AABox)

beyond( (Cartesian)arg1, (float)dist, (CoordGroup)group0, (CoordGroup)group1) -> bool :

Return whether or not these two groups are definitely beyond the cutoff distance.

C++ signature :: bool beyond(SireVol::Cartesian {lvalue},double,SireVol::CoordGroup,SireVol::CoordGroup)

box_matrix()#

boxMatrix( (Space)arg1) -> Matrix :

Return the matrix that describes this box - these are the: three box vectors. This raises an exception if this is not a periodic space
C++ signature :: SireMaths::Matrix boxMatrix(SireVol::Space {lvalue})

calc_angle()#

calcAngle( (Cartesian)arg1, (Vector)point0, (Vector)point1, (Vector)point2) -> object :

Calculate the angle between the passed three points. This should return the acute angle between the points, which should lie between 0 and 180 degrees

C++ signature :: SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> calcAngle(SireVol::Cartesian {lvalue},SireMaths::Vector,SireMaths::Vector,SireMaths::Vector)

calc_dihedral()#

calcDihedral( (Cartesian)arg1, (Vector)point0, (Vector)point1, (Vector)point2, (Vector)point3) -> object :

Calculate the torsion angle between the passed four points. This should return the torsion angle measured clockwise when looking down the torsion from point0-point1-point2-point3. This will lie between 0 and 360 degrees

C++ signature :: SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> calcDihedral(SireVol::Cartesian {lvalue},SireMaths::Vector,SireMaths::Vector,SireMaths::Vector,SireMaths::Vector)

calc_dist()#

calcDist( (Cartesian)arg1, (Vector)point0, (Vector)point1) -> float :

Calculate the distance between two points

C++ signature :: double calcDist(SireVol::Cartesian {lvalue},SireMaths::Vector,SireMaths::Vector)

calcDist( (Cartesian)arg1, (CoordGroup)group, (object)mat) -> float :

Populate the matrix mat with the distances between all points in the group group. Return the shortest distance between points.

C++ signature :: double calcDist(SireVol::Cartesian {lvalue},SireVol::CoordGroup,SireBase::PairMatrix<double> {lvalue})

calcDist( (Cartesian)arg1, (CoordGroup)group1, (CoordGroup)group2, (object)mat) -> float :

Populate the matrix mat with the distances between all of the points of the two CoordGroups. Return the shortest distance between the two CoordGroups.

C++ signature :: double calcDist(SireVol::Cartesian {lvalue},SireVol::CoordGroup,SireVol::CoordGroup,SireBase::PairMatrix<double> {lvalue})

calcDist( (Cartesian)arg1, (CoordGroup)group, (Vector)point, (object)mat) -> float :

Populate the matrix mat with the distances between all of the points of the passed CoordGroup and point. Returns the shortest distance.

C++ signature :: double calcDist(SireVol::Cartesian {lvalue},SireVol::CoordGroup,SireMaths::Vector,SireBase::PairMatrix<double> {lvalue})

calc_dist2()#

calcDist2( (Cartesian)arg1, (Vector)point0, (Vector)point1) -> float :

Calculate the distance squared between two points

C++ signature :: double calcDist2(SireVol::Cartesian {lvalue},SireMaths::Vector,SireMaths::Vector)

calcDist2( (Cartesian)arg1, (CoordGroup)group, (object)mat) -> float :

Populate the matrix mat with the distances^2 between all points in the group group. Return the shortest distance between points.

C++ signature :: double calcDist2(SireVol::Cartesian {lvalue},SireVol::CoordGroup,SireBase::PairMatrix<double> {lvalue})

calcDist2( (Cartesian)arg1, (CoordGroup)group, (Vector)point, (object)mat) -> float :

Populate the matrix mat with the distances squared between all of the points of the passed CoordGroup and point. Returns the shortest distance.

C++ signature :: double calcDist2(SireVol::Cartesian {lvalue},SireVol::CoordGroup,SireMaths::Vector,SireBase::PairMatrix<double> {lvalue})

calcDist2( (Cartesian)arg1, (CoordGroup)group1, (CoordGroup)group2, (object)mat) -> float :

Populate the matrix mat with the distances^2 between all of the points of the two CoordGroups. Return the shortest distance between the two CoordGroups.

C++ signature :: double calcDist2(SireVol::Cartesian {lvalue},SireVol::CoordGroup,SireVol::CoordGroup,SireBase::PairMatrix<double> {lvalue})

calc_dist_vector()#

calcDistVector( (Cartesian)arg1, (Vector)point0, (Vector)point1) -> DistVector :

Calculate the distance vector between two points

C++ signature :: SireMaths::DistVector calcDistVector(SireVol::Cartesian {lvalue},SireMaths::Vector,SireMaths::Vector)

calc_dist_vectors()#

calcDistVectors( (Cartesian)arg1, (CoordGroup)group, (object)distmat) -> float :

Populate the matrix distmat with all of the interpoint distance vectors between all points within the CoordGroup. This is not a symmetrical matrix, as the direction from point A to point B is the negative of the direction from point B to point A. This returns the shortest distance between two points in the group (that is not the self-self distance)

C++ signature :: double calcDistVectors(SireVol::Cartesian {lvalue},SireVol::CoordGroup,SireBase::PairMatrix<SireMaths::DistVector> {lvalue})

calcDistVectors( (Cartesian)arg1, (CoordGroup)group1, (CoordGroup)group2, (object)distmat) -> float :

Populate the matrix distmat between all the points of the two CoordGroups group1 and group2 - the returned matrix has the vectors pointing from each point in group1 to each point in group2. This returns the shortest distance between two points in the group

C++ signature :: double calcDistVectors(SireVol::Cartesian {lvalue},SireVol::CoordGroup,SireVol::CoordGroup,SireBase::PairMatrix<SireMaths::DistVector> {lvalue})

calcDistVectors( (Cartesian)arg1, (CoordGroup)group, (Vector)point, (object)distmat) -> float :

Populate the matrix distmat between all the points of the passed CoordGroup with point - the returned matrix has the vectors pointing from the point, to each point in group. This returns the shortest distance.

C++ signature :: double calcDistVectors(SireVol::Cartesian {lvalue},SireVol::CoordGroup,SireMaths::Vector,SireBase::PairMatrix<SireMaths::DistVector> {lvalue})

calc_inv_dist()#

calcInvDist( (Cartesian)arg1, (CoordGroup)group, (object)mat) -> float :

Populate the matrix mat with the inverse distances between all points in the group group. Return the smallest distance between points.

C++ signature :: double calcInvDist(SireVol::Cartesian {lvalue},SireVol::CoordGroup,SireBase::PairMatrix<double> {lvalue})

calcInvDist( (Cartesian)arg1, (CoordGroup)group1, (CoordGroup)group2, (object)mat) -> float :

Populate the matrix mat with the inverse distances between all of the points of the two CoordGroups. Return the shortest distance between the two CoordGroups.

C++ signature :: double calcInvDist(SireVol::Cartesian {lvalue},SireVol::CoordGroup,SireVol::CoordGroup,SireBase::PairMatrix<double> {lvalue})

calc_inv_dist2()#

calcInvDist2( (Cartesian)arg1, (CoordGroup)group, (object)mat) -> float :

Populate the matrix mat with the inverse distances^2 between all points in the group group. Return the smallest distance between points.

C++ signature :: double calcInvDist2(SireVol::Cartesian {lvalue},SireVol::CoordGroup,SireBase::PairMatrix<double> {lvalue})

calcInvDist2( (Cartesian)arg1, (CoordGroup)group1, (CoordGroup)group2, (object)mat) -> float :

Populate the matrix mat with the inverse distances^2 between all of the points of the two CoordGroups. Return the shortest distance between the two CoordGroups.

C++ signature :: double calcInvDist2(SireVol::Cartesian {lvalue},SireVol::CoordGroup,SireVol::CoordGroup,SireBase::PairMatrix<double> {lvalue})

change_volume()#

changeVolume( (Space)arg1, (object)delta) -> object :

Change the volume of this space by delta

C++ signature :: SireBase::PropPtr<SireVol::Space> changeVolume(SireVol::Space {lvalue},SireUnits::Dimension::PhysUnit<0, 3, 0, 0, 0, 0, 0>)

clone((Cartesian)arg1) → Cartesian :#

C++ signature :: SireVol::Cartesian clone(SireVol::Cartesian)

get_box_center()#

getBoxCenter( (Cartesian)arg1, (Vector)p) -> Vector :

Return the center of the box that contains the point p assuming that the center for the central box is located at the origin

C++ signature :: SireMaths::Vector getBoxCenter(SireVol::Cartesian {lvalue},SireMaths::Vector)

getBoxCenter( (Cartesian)arg1, (Vector)p, (Vector)center) -> Vector :

Return the center of the box that contains the point p assuming that the center for the central box is located at center

C++ signature :: SireMaths::Vector getBoxCenter(SireVol::Cartesian {lvalue},SireMaths::Vector,SireMaths::Vector)

get_copies_within()#

getCopiesWithin( (Cartesian)arg1, (CoordGroup)group, (CoordGroup)center, (float)dist) -> object :

Return a list of copies of CoordGroup group that are within distance of the CoordGroup center, translating group so that it has the right coordinates to be around center. As this is not a periodic space, this will merely return a copy of group if it is within the specified distance.

C++ signature :: QList<boost::tuples::tuple<double, SireVol::CoordGroup, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type>> getCopiesWithin(SireVol::Cartesian {lvalue},SireVol::CoordGroup,SireVol::CoordGroup,double)

get_images_within()#

getImagesWithin( (Cartesian)arg1, (Vector)point, (Vector)center, (float)dist) -> object :

Return all periodic images of point with respect to center within dist distance of center

C++ signature :: QVector<SireMaths::Vector> getImagesWithin(SireVol::Cartesian {lvalue},SireMaths::Vector,SireMaths::Vector,double)

get_minimum_image()#

getMinimumImage( (Cartesian)arg1, (object)coords, (Vector)center) -> object :

Return the minimum image copy of group with respect to center. In this case, as this is not a periodic space, this just returns group

C++ signature :: QVector<SireMaths::Vector> getMinimumImage(SireVol::Cartesian {lvalue},QVector<SireMaths::Vector>,SireMaths::Vector)

getMinimumImage( (Cartesian)arg1, (CoordGroup)group, (Vector)center) -> CoordGroup :

Return the minimum image copy of group with respect to center. In this case, as this is not a periodic space, this just returns group

C++ signature :: SireVol::CoordGroup getMinimumImage(SireVol::Cartesian {lvalue},SireVol::CoordGroup,SireMaths::Vector)

getMinimumImage( (Cartesian)arg1, (CoordGroupArray)groups, (Vector)center [, (bool)translate_as_one=False]) -> CoordGroupArray :

Return the minimum image copy of groups with respect to center. In this case, as this is not a periodic space, this just returns groups

C++ signature :: SireVol::CoordGroupArray getMinimumImage(SireVol::Cartesian {lvalue},SireVol::CoordGroupArray,SireMaths::Vector [,bool=False])

getMinimumImage( (Cartesian)arg1, (AABox)aabox, (Vector)center) -> AABox :

A cartesian space is not periodic, so this just returns the input aabox

C++ signature :: SireVol::AABox getMinimumImage(SireVol::Cartesian {lvalue},SireVol::AABox,SireMaths::Vector)

getMinimumImage( (Cartesian)arg1, (Vector)point, (Vector)center) -> Vector :

A cartesian space is not periodic, so this just returns the input point

C++ signature :: SireMaths::Vector getMinimumImage(SireVol::Cartesian {lvalue},SireMaths::Vector,SireMaths::Vector)

get_random_point()#

getRandomPoint( (Cartesian)arg1, (Vector)center, (RanGenerator)generator) -> Vector :

Return a random point in this space - this can be truly anywhere (well, it is limited to within -10^20 and 10^20 angstroms)

C++ signature :: SireMaths::Vector getRandomPoint(SireVol::Cartesian {lvalue},SireMaths::Vector,SireMaths::RanGenerator)

is_cartesian()#

isCartesian( (Cartesian)arg1) -> bool :

A Cartesian space is cartesian

C++ signature :: bool isCartesian(SireVol::Cartesian {lvalue})

is_periodic()#

isPeriodic( (Cartesian)arg1) -> bool :

A Cartesian space is not periodic

C++ signature :: bool isPeriodic(SireVol::Cartesian {lvalue})

make_whole()#

makeWhole( (Space)arg1, (object)coords) -> object :

Make the passed group of coordinates whole. This will make sure: that they are all next to each other, and arent split across a periodic image boundary. The box that will be chosen will be the one that contains the center of the points, with the points mapped from the first to the last
C++ signature :: QVector<SireMaths::Vector> makeWhole(SireVol::Space {lvalue},QVector<SireMaths::Vector>)

makeWhole( (Space)arg1, (object)coords, (Vector)center) -> object :

Return the minimum image copy of coords with respect to center, where the coordinates are made whole. This means that they are translated as a single group, but the group as a whole will not be split across a periodic boundary. Use this function if you want to restore a molecule that has been split over a space into a single, coherent entity (all of the coordinates physically close to one another)

C++ signature :: QVector<SireMaths::Vector> makeWhole(SireVol::Space {lvalue},QVector<SireMaths::Vector>,SireMaths::Vector)

makeWhole( (Space)arg1, (object)coords) -> object :

Make the passed group of coordinates whole. This will make sure: that they are all next to each other, and arent split across a periodic image boundary. The box that will be chosen will be the one that contains the center of the points, with the points mapped from the first to the last. This treats all of the passed arrays of coordinates as a single unit that should not be split
C++ signature :: QVector<QVector<SireMaths::Vector>> makeWhole(SireVol::Space {lvalue},QVector<QVector<SireMaths::Vector>>)

makeWhole( (Space)arg1, (object)coords, (Vector)center) -> object :

C++ signature :: QVector<QVector<SireMaths::Vector>> makeWhole(SireVol::Space {lvalue},QVector<QVector<SireMaths::Vector>>,SireMaths::Vector)

maximum_cutoff()#

maximumCutoff( (Space)arg1) -> object :

Return the maximum cutoff that can be used in this space so that calculations obey the minimum image convention. This is the largest possible double for non-periodic spaces, and half the smallest box side for periodic spaces

C++ signature :: SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0> maximumCutoff(SireVol::Space {lvalue})

minimum_distance()#

minimumDistance( (Cartesian)arg1, (CoordGroup)group0, (CoordGroup)group1) -> float :

Return the minimum distance between the points in group0 and group1.

C++ signature :: double minimumDistance(SireVol::Cartesian {lvalue},SireVol::CoordGroup,SireVol::CoordGroup)

minimumDistance( (Cartesian)arg1, (Vector)point, (CoordGroup)group) -> float :

Return the minimum distance between point and all the points in group. If this is a periodic space then this uses the minimum image convention (i.e. the minimum distance between the closest periodic replicas are used)

C++ signature :: double minimumDistance(SireVol::Cartesian {lvalue},SireMaths::Vector,SireVol::CoordGroup)

minimumDistance( (Cartesian)arg1, (CoordGroup)group) -> float :

Return the minimum distance between points within the group group.

C++ signature :: double minimumDistance(SireVol::Cartesian {lvalue},SireVol::CoordGroup)

minimumDistance( (Cartesian)arg1, (AABox)box0, (AABox)box1) -> float :

Return the minimum distance between the two passed boxes

C++ signature :: double minimumDistance(SireVol::Cartesian {lvalue},SireVol::AABox,SireVol::AABox)

minimumDistance( (Cartesian)arg1, (Vector)p, (AABox)box) -> float :

Return the minimum distance between a point and a box

C++ signature :: double minimumDistance(SireVol::Cartesian {lvalue},SireMaths::Vector,SireVol::AABox)

set_volume()#

setVolume( (Cartesian)arg1, (object)volume) -> object :

Throw an exception as an infinite space doesnt have a volume

C++ signature :: SireBase::PropPtr<SireVol::Space> setVolume(SireVol::Cartesian {lvalue},SireUnits::Dimension::PhysUnit<0, 3, 0, 0, 0, 0, 0>)

to_string()#

toString( (Cartesian)arg1) -> object :

Return a string representation of this space

C++ signature :: QString toString(SireVol::Cartesian {lvalue})

typename()#

typeName() -> str :

C++ signature :
char const* typeName()

volume((Cartesian)arg1) → object :#

Throw an exception as an infinite space doesnt have a volume

C++ signature :: SireUnits::Dimension::PhysUnit<0, 3, 0, 0, 0, 0, 0> volume(SireVol::Cartesian {lvalue})

class sire.vol.CoordGroup#

This class holds a group of coordinates. This group forms the basis of the Molecular CutGroup, as defined in SireMol. A CoordGroup contains a list of coordinates, together with an AABox which provides information as to the center and extents of this group. SireVol is designed to calculate distances between points in different CoordGroups, or to calculate distances between points within a CoordGroup. A CoordGroup is implicitly shared and is designed to be fast to use, and fast to copy.

Author: Christopher Woods

aabox()#

aaBox( (CoordGroupBase)arg1) -> AABox :

Return the enclosing AABox

C++ signature :: SireVol::AABox aaBox(SireVol::CoordGroupBase {lvalue})

assert_same_size()#

assertSameSize( (CoordGroupBase)arg1, (object)coordinates) -> None :

Assert that the array of coordinates contains the same number of coordinates as are in this group Throw: SireError::incompatible_error

C++ signature :: void assertSameSize(SireVol::CoordGroupBase {lvalue},QVector<SireMaths::Vector>)

assertSameSize( (CoordGroupBase)arg1, (CoordGroupBase)other) -> None :

Assert that the CoordGroup other contains the same number of coordinates as are in this group Throw: SireError::incompatible_error

C++ signature :: void assertSameSize(SireVol::CoordGroupBase {lvalue},SireVol::CoordGroupBase)

assert_valid_index()#

assertValidIndex( (CoordGroupBase)arg1, (int)i) -> None :

Assert that i is a valid index in this group Throw: SireError::invalid_index

C++ signature :: void assertValidIndex(SireVol::CoordGroupBase {lvalue},unsigned int)

assign((CoordGroup)arg1, (CoordGroup)other) → CoordGroup :#

C++ signature :
SireVol::CoordGroup {lvalue} assign(SireVol::CoordGroup {lvalue},SireVol::CoordGroup)

assign( (CoordGroup)arg1, (CoordGroupEditor)other) -> CoordGroup :

C++ signature :
SireVol::CoordGroup {lvalue} assign(SireVol::CoordGroup {lvalue},SireVol::CoordGroupEditor {lvalue})

clone((CoordGroup)arg1) → CoordGroup :#

C++ signature :: SireVol::CoordGroup clone(SireVol::CoordGroup)

edit((CoordGroup)arg1) → CoordGroupEditor :#

Return an editor that can be used to edit the coordinates in this group

C++ signature :: SireVol::CoordGroupEditor edit(SireVol::CoordGroup {lvalue})

is_empty()#

isEmpty( (CoordGroupBase)arg1) -> bool :

Return whether this group is empty (has no coordinates)

C++ signature :: bool isEmpty(SireVol::CoordGroupBase {lvalue})

maybe_different()#

maybeDifferent( (CoordGroupBase)arg1, (CoordGroupBase)other) -> bool :

Return whether other may be different to this group - this uses a simple comparison of the memory addresses of the storage of these two groups to see if they are definitely the same, or maybe different

C++ signature :: bool maybeDifferent(SireVol::CoordGroupBase {lvalue},SireVol::CoordGroupBase)

to_string()#

toString( (CoordGroupBase)arg1) -> object :

Return a string representation of this CoordGroup

C++ signature :: QString toString(SireVol::CoordGroupBase {lvalue})

to_vector()#

toVector( (CoordGroupBase)arg1) -> object :

Return an array containing just the coordinates in this group

C++ signature :: QVector<SireMaths::Vector> toVector(SireVol::CoordGroupBase {lvalue})

typename()#

typeName() -> str :

C++ signature :
char const* typeName()

what((CoordGroup)arg1) → str :#

C++ signature :: char const* what(SireVol::CoordGroup {lvalue})

class sire.vol.PeriodicBox#

A PeriodicBox is a volume that represents standard periodic boundary conditions (a 3D box replicated to infinity along all three dimensions).

Author: Christopher Woods

assign((PeriodicBox)arg1, (PeriodicBox)other) → PeriodicBox :#

C++ signature :: SireVol::PeriodicBox {lvalue} assign(SireVol::PeriodicBox {lvalue},SireVol::PeriodicBox)

beyond((PeriodicBox)arg1, (float)dist, (AABox)aabox0, (AABox)aabox1) → bool :#

Return whether or not two groups enclosed by the AABoxes aabox0 and

aabox1 are definitely beyond the cutoff distance dist

C++ signature :: bool beyond(SireVol::PeriodicBox {lvalue},double,SireVol::AABox,SireVol::AABox)

beyond( (PeriodicBox)arg1, (float)dist, (CoordGroup)group0, (CoordGroup)group1) -> bool :

Return whether or not these two groups are definitely beyond the cutoff distance.

C++ signature :: bool beyond(SireVol::PeriodicBox {lvalue},double,SireVol::CoordGroup,SireVol::CoordGroup)

box_matrix()#

boxMatrix( (PeriodicBox)arg1) -> Matrix :

C++ signature :
SireMaths::Matrix boxMatrix(SireVol::PeriodicBox {lvalue})

calc_angle()#

calcAngle( (PeriodicBox)arg1, (Vector)point0, (Vector)point1, (Vector)point2) -> object :

Calculate the angle between the passed three points. This should return the acute angle between the points, which should lie between 0 and 180 degrees

C++ signature :: SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> calcAngle(SireVol::PeriodicBox {lvalue},SireMaths::Vector,SireMaths::Vector,SireMaths::Vector)

calc_dihedral()#

calcDihedral( (PeriodicBox)arg1, (Vector)point0, (Vector)point1, (Vector)point2, (Vector)point3) -> object :

C++ signature :: SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> calcDihedral(SireVol::PeriodicBox {lvalue},SireMaths::Vector,SireMaths::Vector,SireMaths::Vector,SireMaths::Vector)

calc_dist()#

calcDist( (PeriodicBox)arg1, (Vector)point0, (Vector)point1) -> float :

Calculate the distance between two points

C++ signature :: double calcDist(SireVol::PeriodicBox {lvalue},SireMaths::Vector,SireMaths::Vector)

calcDist( (PeriodicBox)arg1, (CoordGroup)group1, (CoordGroup)group2, (object)distmat) -> float :

Populate the matrix mat with the distances between all of the atoms of the two CoordGroups. Return the shortest distance^2 between the two CoordGroups.

C++ signature :: double calcDist(SireVol::PeriodicBox {lvalue},SireVol::CoordGroup,SireVol::CoordGroup,SireBase::PairMatrix<double> {lvalue})

calcDist( (PeriodicBox)arg1, (CoordGroup)group, (Vector)point, (object)mat) -> float :

Populate the matrix mat with the distances between all of the atoms of the passed CoordGroup to the passed point. Return the shortest distance.

C++ signature :: double calcDist(SireVol::PeriodicBox {lvalue},SireVol::CoordGroup,SireMaths::Vector,SireBase::PairMatrix<double> {lvalue})

calc_dist2()#

calcDist2( (PeriodicBox)arg1, (Vector)point0, (Vector)point1) -> float :

Calculate the distance squared between two points

C++ signature :: double calcDist2(SireVol::PeriodicBox {lvalue},SireMaths::Vector,SireMaths::Vector)

calcDist2( (PeriodicBox)arg1, (CoordGroup)group, (Vector)point, (object)mat) -> float :

Populate the matrix mat with the distances squared between all of the atoms of the passed CoordGroup to the passed point. Return the shortest distance.

C++ signature :: double calcDist2(SireVol::PeriodicBox {lvalue},SireVol::CoordGroup,SireMaths::Vector,SireBase::PairMatrix<double> {lvalue})

calcDist2( (PeriodicBox)arg1, (CoordGroup)group1, (CoordGroup)group2, (object)distmat) -> float :

Populate the matrix mat with the distances^2 between all of the atoms of the two CoordGroups. Return the shortest distance between the two CoordGroups.

C++ signature :: double calcDist2(SireVol::PeriodicBox {lvalue},SireVol::CoordGroup,SireVol::CoordGroup,SireBase::PairMatrix<double> {lvalue})

calc_dist_vector()#

calcDistVector( (PeriodicBox)arg1, (Vector)point0, (Vector)point1) -> DistVector :

Calculate the distance vector between two points

C++ signature :: SireMaths::DistVector calcDistVector(SireVol::PeriodicBox {lvalue},SireMaths::Vector,SireMaths::Vector)

calc_dist_vectors()#

calcDistVectors( (PeriodicBox)arg1, (CoordGroup)group1, (CoordGroup)group2, (object)distmat) -> float :

C++ signature :: double calcDistVectors(SireVol::PeriodicBox {lvalue},SireVol::CoordGroup,SireVol::CoordGroup,SireBase::PairMatrix<SireMaths::DistVector> {lvalue})

calcDistVectors( (PeriodicBox)arg1, (CoordGroup)group, (Vector)point, (object)distmat) -> float :

Populate the matrix distmat between all the points passed CoordGroup to the point point - the returned matrix has the vectors pointing from the point to each point in group. This returns the shortest distance.

C++ signature :: double calcDistVectors(SireVol::PeriodicBox {lvalue},SireVol::CoordGroup,SireMaths::Vector,SireBase::PairMatrix<SireMaths::DistVector> {lvalue})

calc_inv_dist()#

calcInvDist( (PeriodicBox)arg1, (CoordGroup)group1, (CoordGroup)group2, (object)distmat) -> float :

Populate the matrix mat with the inverse distances between all of the atoms of the two CoordGroups. Return the shortest distance between the two CoordGroups.

C++ signature :: double calcInvDist(SireVol::PeriodicBox {lvalue},SireVol::CoordGroup,SireVol::CoordGroup,SireBase::PairMatrix<double> {lvalue})

calc_inv_dist2()#

calcInvDist2( (PeriodicBox)arg1, (CoordGroup)group1, (CoordGroup)group2, (object)distmat) -> float :

Populate the matrix mat with the inverse distances^2 between all of the atoms of the two CoordGroups. Return the shortest distance between the two CoordGroups.

C++ signature :: double calcInvDist2(SireVol::PeriodicBox {lvalue},SireVol::CoordGroup,SireVol::CoordGroup,SireBase::PairMatrix<double> {lvalue})

change_volume()#

changeVolume( (Space)arg1, (object)delta) -> object :

Change the volume of this space by delta

C++ signature :: SireBase::PropPtr<SireVol::Space> changeVolume(SireVol::Space {lvalue},SireUnits::Dimension::PhysUnit<0, 3, 0, 0, 0, 0, 0>)

clone((PeriodicBox)arg1) → PeriodicBox :#

C++ signature :: SireVol::PeriodicBox clone(SireVol::PeriodicBox)

dimensions((PeriodicBox)arg1) → Vector :#

Return the dimensions of this box

C++ signature :: SireMaths::Vector dimensions(SireVol::PeriodicBox {lvalue})

get_box_center()#

getBoxCenter( (PeriodicBox)arg1, (Vector)p) -> Vector :

Return the center of the box that contains the point p assuming that the center for the central box is located at the origin

C++ signature :: SireMaths::Vector getBoxCenter(SireVol::PeriodicBox {lvalue},SireMaths::Vector)

getBoxCenter( (PeriodicBox)arg1, (Vector)p, (Vector)center) -> Vector :

Return the center of the box that contains the point p assuming that the center for the central box is located at center

C++ signature :: SireMaths::Vector getBoxCenter(SireVol::PeriodicBox {lvalue},SireMaths::Vector,SireMaths::Vector)

get_copies_within()#

getCopiesWithin( (PeriodicBox)arg1, (CoordGroup)group, (CoordGroup)center, (float)dist) -> object :

Return a list of copies of CoordGroup group that are within distance of the CoordGroup center, translating group so that it has the right coordinates to be around center. Note that multiple copies of group may be returned in this is a periodic space and there are multiple periodic replicas of group within dist of center. The copies of group are returned together with the minimum distance between that periodic replica and center. If there are no periodic replicas of group that are within dist of center, then an empty list is returned.

C++ signature :: QList<boost::tuples::tuple<double, SireVol::CoordGroup, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type>> getCopiesWithin(SireVol::PeriodicBox {lvalue},SireVol::CoordGroup,SireVol::CoordGroup,double)

get_images_within()#

getImagesWithin( (PeriodicBox)arg1, (Vector)point, (Vector)center, (float)dist) -> object :

Return all periodic images of point with respect to center within dist distance of center

C++ signature :: QVector<SireMaths::Vector> getImagesWithin(SireVol::PeriodicBox {lvalue},SireMaths::Vector,SireMaths::Vector,double)

get_minimum_image()#

getMinimumImage( (PeriodicBox)arg1, (object)coords, (Vector)center) -> object :

Return the copy of the point point which is the closest minimum image to center

C++ signature :: QVector<SireMaths::Vector> getMinimumImage(SireVol::PeriodicBox {lvalue},QVector<SireMaths::Vector>,SireMaths::Vector)

getMinimumImage( (PeriodicBox)arg1, (CoordGroup)group, (Vector)center) -> CoordGroup :

Return the closest periodic copy of group to the point point, according to the minimum image convention. The effect of this is to move group into the box which is now centered on point

C++ signature :: SireVol::CoordGroup getMinimumImage(SireVol::PeriodicBox {lvalue},SireVol::CoordGroup,SireMaths::Vector)

getMinimumImage( (PeriodicBox)arg1, (CoordGroupArray)groups, (Vector)center [, (bool)translate_as_one=False]) -> CoordGroupArray :

Return the closest periodic copy of each group in groups to the point point, according to the minimum image convention. The effect of this is to move each group into the box which is now centered on point. If translate_as_one is true, then this treats all groups as being part of one larger group, and so it translates it together. This is useful to get the minimum image of a molecule as a whole, rather than breaking the molecule across a box boundary

C++ signature :: SireVol::CoordGroupArray getMinimumImage(SireVol::PeriodicBox {lvalue},SireVol::CoordGroupArray,SireMaths::Vector [,bool=False])

getMinimumImage( (PeriodicBox)arg1, (AABox)aabox, (Vector)center) -> AABox :

Return the copy of the periodic box which is the closest minimum image to center

C++ signature :: SireVol::AABox getMinimumImage(SireVol::PeriodicBox {lvalue},SireVol::AABox,SireMaths::Vector)

getMinimumImage( (PeriodicBox)arg1, (Vector)point, (Vector)center) -> Vector :

Return the copy of the point point which is the closest minimum image to center

C++ signature :: SireMaths::Vector getMinimumImage(SireVol::PeriodicBox {lvalue},SireMaths::Vector,SireMaths::Vector)

get_random_point()#

getRandomPoint( (PeriodicBox)arg1, (Vector)center, (RanGenerator)generator) -> Vector :

Return a random point within the box (placing the center of the box is at the center center)

C++ signature :: SireMaths::Vector getRandomPoint(SireVol::PeriodicBox {lvalue},SireMaths::Vector,SireMaths::RanGenerator)

is_cartesian()#

isCartesian( (PeriodicBox)arg1) -> bool :

A Periodic box is cartesian

C++ signature :: bool isCartesian(SireVol::PeriodicBox {lvalue})

is_periodic()#

isPeriodic( (PeriodicBox)arg1) -> bool :

A Periodic box is periodic

C++ signature :: bool isPeriodic(SireVol::PeriodicBox {lvalue})

make_whole()#

makeWhole( (PeriodicBox)arg1, (object)coords) -> object :

Make the passed group of coordinates whole. This will make sure: that they are all next to each other, and arent split across a periodic image boundary. The box that will be chosen will be the one that contains the center of the points, with the points mapped from the first to the last
C++ signature :: QVector<SireMaths::Vector> makeWhole(SireVol::PeriodicBox {lvalue},QVector<SireMaths::Vector>)

makeWhole( (PeriodicBox)arg1, (object)coords, (Vector)center) -> object :

C++ signature :: QVector<SireMaths::Vector> makeWhole(SireVol::PeriodicBox {lvalue},QVector<SireMaths::Vector>,SireMaths::Vector)

max_coords()#

maxCoords( (PeriodicBox)arg1 [, (Vector)center=( 0 , 0 , 0 )]) -> Vector :

Return the maximum coordinates of the box that has its center at center

C++ signature :: SireMaths::Vector maxCoords(SireVol::PeriodicBox {lvalue} [,SireMaths::Vector=( 0 , 0 , 0 )])

maximum_cutoff()#

maximumCutoff( (PeriodicBox)arg1) -> object :

C++ signature :
SireUnits::Dimension::PhysUnit<0, 1, 0, 0, 0, 0, 0> maximumCutoff(SireVol::PeriodicBox {lvalue})

min_coords()#

minCoords( (PeriodicBox)arg1 [, (Vector)center=( 0 , 0 , 0 )]) -> Vector :

Return the minimum coordinates of the box that has its center at center

C++ signature :: SireMaths::Vector minCoords(SireVol::PeriodicBox {lvalue} [,SireMaths::Vector=( 0 , 0 , 0 )])

minimum_distance()#

minimumDistance( (PeriodicBox)arg1, (Vector)point, (CoordGroup)group) -> float :

C++ signature :: double minimumDistance(SireVol::PeriodicBox {lvalue},SireMaths::Vector,SireVol::CoordGroup)

minimumDistance( (PeriodicBox)arg1, (CoordGroup)group0, (CoordGroup)group1) -> float :

Return the minimum distance between the points in group0 and group1. If this is a periodic space then this uses the minimum image convention (i.e. the minimum distance between the closest periodic replicas are used)

C++ signature :: double minimumDistance(SireVol::PeriodicBox {lvalue},SireVol::CoordGroup,SireVol::CoordGroup)

minimumDistance( (PeriodicBox)arg1, (AABox)box0, (AABox)box1) -> float :

Return the minimum distance between the two boxes

C++ signature :: double minimumDistance(SireVol::PeriodicBox {lvalue},SireVol::AABox,SireVol::AABox)

set_dimensions()#

setDimensions( (PeriodicBox)arg1, (Vector)dimensions) -> None :

Set the dimensions of this box to dimensions (the lengths of the three sides of this box)

C++ signature :: void setDimensions(SireVol::PeriodicBox {lvalue},SireMaths::Vector)

setDimensions( (PeriodicBox)arg1, (Vector)mincoords, (Vector)maxcoords) -> None :

Set the dimensions of the box so that they span from mincoords to maxcoords

C++ signature :: void setDimensions(SireVol::PeriodicBox {lvalue},SireMaths::Vector,SireMaths::Vector)

set_volume()#

setVolume( (PeriodicBox)arg1, (object)volume) -> object :

Return a copy of this space with the volume of set to volume - this will scale the space uniformly, keeping the center at the same location, to achieve this volume

C++ signature :: SireBase::PropPtr<SireVol::Space> setVolume(SireVol::PeriodicBox {lvalue},SireUnits::Dimension::PhysUnit<0, 3, 0, 0, 0, 0, 0>)

to_string()#

toString( (PeriodicBox)arg1) -> object :

Return a string representation of this space

C++ signature :: QString toString(SireVol::PeriodicBox {lvalue})

typename()#

typeName() -> str :

C++ signature :
char const* typeName()

volume((PeriodicBox)arg1) → object :#

Return the volume of the central box of this space.

C++ signature :: SireUnits::Dimension::PhysUnit<0, 3, 0, 0, 0, 0, 0> volume(SireVol::PeriodicBox {lvalue})

class sire.vol.TriclinicBox#

A TriclinicBox is a volume that represents standard periodic boundary conditions (a 3D box replicated to infinity along all three dimensions).

To support triclinic boxes that work across a range of molecular simulation engines, e.g. AMBER, GROMACS, OpenMM, we represent the triclinic space in reduced form, using the approach documented in Appendix A of Chapter 3 from Molecular dynamics of sense and sensibility in processing and analysis of data by Tsjerk A. Wassenaar.

Author: Lester Hedges

alpha((TriclinicBox)arg1) → float :#

Return the angle between v1 and v2 in degrees.

C++ signature :: double alpha(SireVol::TriclinicBox {lvalue})

assign((TriclinicBox)arg1, (TriclinicBox)other) → TriclinicBox :#

C++ signature :: SireVol::TriclinicBox {lvalue} assign(SireVol::TriclinicBox {lvalue},SireVol::TriclinicBox)

beta((TriclinicBox)arg1) → float :#

Return the angle between v0 and v2 in degrees.

C++ signature :: double beta(SireVol::TriclinicBox {lvalue})

beyond((TriclinicBox)arg1, (float)dist, (AABox)aabox0, (AABox)aabox1) → bool :#

Return whether or not two groups enclosed by the AABoxes aabox0 and

aabox1 are definitely beyond the cutoff distance dist

C++ signature :: bool beyond(SireVol::TriclinicBox {lvalue},double,SireVol::AABox,SireVol::AABox)

beyond( (TriclinicBox)arg1, (float)dist, (CoordGroup)group0, (CoordGroup)group1) -> bool :

Return whether or not these two groups are definitely beyond the cutoff distance.

C++ signature :: bool beyond(SireVol::TriclinicBox {lvalue},double,SireVol::CoordGroup,SireVol::CoordGroup)

box_matrix()#

boxMatrix( (TriclinicBox)arg1) -> Matrix :

C++ signature :
SireMaths::Matrix boxMatrix(SireVol::TriclinicBox {lvalue})

calc_angle()#

calcAngle( (TriclinicBox)arg1, (Vector)point0, (Vector)point1, (Vector)point2) -> object :

Calculate the angle between the passed three points. This should return the acute angle between the points, which should lie between 0 and 180 degrees

C++ signature :: SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> calcAngle(SireVol::TriclinicBox {lvalue},SireMaths::Vector,SireMaths::Vector,SireMaths::Vector)

calc_dihedral()#

calcDihedral( (TriclinicBox)arg1, (Vector)point0, (Vector)point1, (Vector)point2, (Vector)point3) -> object :

C++ signature :: SireUnits::Dimension::PhysUnit<0, 0, 0, 0, 0, 0, 1> calcDihedral(SireVol::TriclinicBox {lvalue},SireMaths::Vector,SireMaths::Vector,SireMaths::Vector,SireMaths::Vector)

calc_dist()#

calcDist( (TriclinicBox)arg1, (Vector)point0, (Vector)point1) -> float :

Calculate the distance between two points

C++ signature :: double calcDist(SireVol::TriclinicBox {lvalue},SireMaths::Vector,SireMaths::Vector)

calcDist( (TriclinicBox)arg1, (CoordGroup)group1, (CoordGroup)group2, (object)distmat) -> float :

Populate the matrix mat with the distances between all of the atoms of the two CoordGroups. Return the shortest distance^2 between the two CoordGroups.

C++ signature :: double calcDist(SireVol::TriclinicBox {lvalue},SireVol::CoordGroup,SireVol::CoordGroup,SireBase::PairMatrix<double> {lvalue})

calcDist( (TriclinicBox)arg1, (CoordGroup)group, (Vector)point, (object)mat) -> float :

Populate the matrix mat with the distances between all of the atoms of the passed CoordGroup to the passed point. Return the shortest distance.

C++ signature :: double calcDist(SireVol::TriclinicBox {lvalue},SireVol::CoordGroup,SireMaths::Vector,SireBase::PairMatrix<double> {lvalue})

calc_dist2()#

calcDist2( (TriclinicBox)arg1, (Vector)point0, (Vector)point1) -> float :

Calculate the distance squared between two points

C++ signature :: double calcDist2(SireVol::TriclinicBox {lvalue},SireMaths::Vector,SireMaths::Vector)

calcDist2( (TriclinicBox)arg1, (CoordGroup)group, (Vector)point, (object)mat) -> float :

Populate the matrix mat with the distances squared between all of the atoms of the passed CoordGroup to the passed point. Return the shortest distance.

C++ signature :: double calcDist2(SireVol::TriclinicBox {lvalue},SireVol::CoordGroup,SireMaths::Vector,SireBase::PairMatrix<double> {lvalue})

calcDist2( (TriclinicBox)arg1, (CoordGroup)group1, (CoordGroup)group2, (object)distmat) -> float :

Populate the matrix mat with the distances^2 between all of the atoms of the two CoordGroups. Return the shortest distance between the two CoordGroups.

C++ signature :: double calcDist2(SireVol::TriclinicBox {lvalue},SireVol::CoordGroup,SireVol::CoordGroup,SireBase::PairMatrix<double> {lvalue})

calc_dist_vector()#

calcDistVector( (TriclinicBox)arg1, (Vector)point0, (Vector)point1) -> DistVector :

Calculate the distance vector between two points

C++ signature :: SireMaths::DistVector calcDistVector(SireVol::TriclinicBox {lvalue},SireMaths::Vector,SireMaths::Vector)

calc_dist_vectors()#

calcDistVectors( (TriclinicBox)arg1, (CoordGroup)group1, (CoordGroup)group2, (object)distmat) -> float :

C++ signature :: double calcDistVectors(SireVol::TriclinicBox {lvalue},SireVol::CoordGroup,SireVol::CoordGroup,SireBase::PairMatrix<SireMaths::DistVector> {lvalue})

calcDistVectors( (TriclinicBox)arg1, (CoordGroup)group, (Vector)point, (object)distmat) -> float :

C++ signature :: double calcDistVectors(SireVol::TriclinicBox {lvalue},SireVol::CoordGroup,SireMaths::Vector,SireBase::PairMatrix<SireMaths::DistVector> {lvalue})

calc_inv_dist()#

calcInvDist( (TriclinicBox)arg1, (CoordGroup)group1, (CoordGroup)group2, (object)distmat) -> float :

Populate the matrix mat with the inverse distances between all of the atoms of the two CoordGroups. Return the shortest distance between the two CoordGroups.

C++ signature :: double calcInvDist(SireVol::TriclinicBox {lvalue},SireVol::CoordGroup,SireVol::CoordGroup,SireBase::PairMatrix<double> {lvalue})

calc_inv_dist2()#

calcInvDist2( (TriclinicBox)arg1, (CoordGroup)group1, (CoordGroup)group2, (object)distmat) -> float :

Populate the matrix mat with the inverse distances^2 between all of the atoms of the two CoordGroups. Return the shortest distance between the two CoordGroups.

C++ signature :: double calcInvDist2(SireVol::TriclinicBox {lvalue},SireVol::CoordGroup,SireVol::CoordGroup,SireBase::PairMatrix<double> {lvalue})

cell_matrix()#

cellMatrix( (TriclinicBox)arg1) -> Matrix :

Return the cell matrix.

C++ signature :: SireMaths::Matrix cellMatrix(SireVol::TriclinicBox {lvalue})

clone((TriclinicBox)arg1) → TriclinicBox :#

C++ signature :: SireVol::TriclinicBox clone(SireVol::TriclinicBox)

static cubic((float)d) → TriclinicBox :#

Return a cubic TriclinicBox with image distance d.

C++ signature :: SireVol::TriclinicBox cubic(double)

gamma((TriclinicBox)arg1) → float :#

Return the angle between v1 and v0 in degrees.

C++ signature :: double gamma(SireVol::TriclinicBox {lvalue})

get_box_center()#

getBoxCenter( (TriclinicBox)arg1, (Vector)p) -> Vector :

Return the center of the box that contains the point p assuming that the center for the central box is located at the origin

C++ signature :: SireMaths::Vector getBoxCenter(SireVol::TriclinicBox {lvalue},SireMaths::Vector)

getBoxCenter( (TriclinicBox)arg1, (Vector)p, (Vector)center) -> Vector :

Return the center of the box that contains the point p assuming that the center for the central box is located at center

C++ signature :: SireMaths::Vector getBoxCenter(SireVol::TriclinicBox {lvalue},SireMaths::Vector,SireMaths::Vector)

get_copies_within()#

getCopiesWithin( (TriclinicBox)arg1, (CoordGroup)group, (CoordGroup)center, (float)dist) -> object :

C++ signature :: QList<boost::tuples::tuple<double, SireVol::CoordGroup, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type>> getCopiesWithin(SireVol::TriclinicBox {lvalue},SireVol::CoordGroup,SireVol::CoordGroup,double)

get_images_within()#

getImagesWithin( (TriclinicBox)arg1, (Vector)point, (Vector)center, (float)dist) -> object :

Return all periodic images of point with respect to center within dist distance of center

C++ signature :: QVector<SireMaths::Vector> getImagesWithin(SireVol::TriclinicBox {lvalue},SireMaths::Vector,SireMaths::Vector,double)

get_minimum_image()#

getMinimumImage( (TriclinicBox)arg1, (object)coords, (Vector)center) -> object :

Return the copy of the point point which is the closest minimum image to center

C++ signature :: QVector<SireMaths::Vector> getMinimumImage(SireVol::TriclinicBox {lvalue},QVector<SireMaths::Vector>,SireMaths::Vector)

getMinimumImage( (TriclinicBox)arg1, (Vector)point, (Vector)center) -> Vector :

Return the copy of the point point which is the closest minimum image to center

C++ signature :: SireMaths::Vector getMinimumImage(SireVol::TriclinicBox {lvalue},SireMaths::Vector,SireMaths::Vector)

getMinimumImage( (TriclinicBox)arg1, (CoordGroup)group, (Vector)center) -> CoordGroup :

Return the closest periodic copy of group to the point point, according to the minimum image convention. The effect of this is to move group into the box which is now centered on point

C++ signature :: SireVol::CoordGroup getMinimumImage(SireVol::TriclinicBox {lvalue},SireVol::CoordGroup,SireMaths::Vector)

getMinimumImage( (TriclinicBox)arg1, (CoordGroupArray)groups, (Vector)center [, (bool)translate_as_one=False]) -> CoordGroupArray :

C++ signature :: SireVol::CoordGroupArray getMinimumImage(SireVol::TriclinicBox {lvalue},SireVol::CoordGroupArray,SireMaths::Vector [,bool=False])

getMinimumImage( (TriclinicBox)arg1, (AABox)aabox, (Vector)center) -> AABox :

Return the copy of the triclinic box which is the closest minimum image to center

C++ signature :: SireVol::AABox getMinimumImage(SireVol::TriclinicBox {lvalue},SireVol::AABox,SireMaths::Vector)

get_random_point()#

getRandomPoint( (TriclinicBox)arg1, (Vector)center, (RanGenerator)generator) -> Vector :

Return a random point within the box (placing the center of the box is at the center center)

C++ signature :: SireMaths::Vector getRandomPoint(SireVol::TriclinicBox {lvalue},SireMaths::Vector,SireMaths::RanGenerator)

is_cartesian()#

isCartesian( (TriclinicBox)arg1) -> bool :

In general, a triclinic box isnt Cartesian.

C++ signature :: bool isCartesian(SireVol::TriclinicBox {lvalue})

is_periodic()#

isPeriodic( (TriclinicBox)arg1) -> bool :

A Triclinic box is periodic

C++ signature :: bool isPeriodic(SireVol::TriclinicBox {lvalue})

is_reduced()#

isReduced( (TriclinicBox)arg1) -> bool :

Whether an automatic lattice reduction has been performed.

C++ signature :: bool isReduced(SireVol::TriclinicBox {lvalue})

is_rotated()#

isRotated( (TriclinicBox)arg1) -> bool :

Whether the triclinic cell has been rotated to comply with the constraints of molecular dynamics engines, i.e. vector0 aligned with x axis, vector1 in x-y plane, and vector2 with positive z component.

C++ signature :: bool isRotated(SireVol::TriclinicBox {lvalue})

minimum_distance()#

minimumDistance( (TriclinicBox)arg1, (CoordGroup)group0, (CoordGroup)group1) -> float :

C++ signature :: double minimumDistance(SireVol::TriclinicBox {lvalue},SireVol::CoordGroup,SireVol::CoordGroup)

minimumDistance( (TriclinicBox)arg1, (AABox)box0, (AABox)box1) -> float :

Return the minimum distance between the two boxes

C++ signature :: double minimumDistance(SireVol::TriclinicBox {lvalue},SireVol::AABox,SireVol::AABox)

reduce((TriclinicBox)arg1[, (float)bias=0.0]) → None :#

Perform a lattice reduction on the triclinic cell.

Par:am bias The bias to use when rounding during the lattice reduction. Negative values biases towards left-tilting boxes, whereas positive values biases towards right-tilting boxes. This can be used to ensure that rounding is performed in a consistent direction, avoiding oscillation when the TriclinicBox is instantiated from box vectors, or dimensions and angles, that have been read from fixed-precision input files.

C++ signature :: void reduce(SireVol::TriclinicBox {lvalue} [,double=0.0])

rhombic_dodecahedron_hexagon()#

rhombicDodecahedronHexagon( (float)d [, (bool)auto_rotate=True [, (bool)auto_reduce=True]]) -> TriclinicBox :

Return a hexagonal rhombic dodecahedron TriclinicBox with image distance d.

C++ signature :: SireVol::TriclinicBox rhombicDodecahedronHexagon(double [,bool=True [,bool=True]])

rhombic_dodecahedron_square()#

rhombicDodecahedronSquare( (float)d [, (bool)auto_rotate=True [, (bool)auto_reduce=True]]) -> TriclinicBox :

Return a square rhombic dodecahedron TriclinicBox with image distance d.

C++ signature :: SireVol::TriclinicBox rhombicDodecahedronSquare(double [,bool=True [,bool=True]])

rotate((TriclinicBox)arg1[, (float)precision=0.0]) → None :#

Rotate the triclinic cell to comply with the constraints of certain molecular dynamics engines, i.e. such that vector0 is aligned with the x axis, vector1, lies in the x-y plane, and vector2 has a positive z component.

Par:am precision The precision to use when sorting the lattice vectors based on their magnitude. This can be used to prevent unwanted rotation when using input fixed-precision ascii molecular input files.

C++ signature :: void rotate(SireVol::TriclinicBox {lvalue} [,double=0.0])

rotation_matrix()#

rotationMatrix( (TriclinicBox)arg1) -> Matrix :

Return the rotation matrix.

C++ signature :: SireMaths::Matrix rotationMatrix(SireVol::TriclinicBox {lvalue})

set_volume()#

setVolume( (TriclinicBox)arg1, (object)volume) -> object :

Set the volume of the triclinic box.

C++ signature :: SireBase::PropPtr<SireVol::Space> setVolume(SireVol::TriclinicBox {lvalue},SireUnits::Dimension::PhysUnit<0, 3, 0, 0, 0, 0, 0>)

to_string()#

toString( (TriclinicBox)arg1) -> object :

Return a string representation of this space

C++ signature :: QString toString(SireVol::TriclinicBox {lvalue})

truncated_octahedron()#

truncatedOctahedron( (float)d [, (bool)auto_rotate=True [, (bool)auto_reduce=True]]) -> TriclinicBox :

Return a truncated octahedron with image distance d.

C++ signature :: SireVol::TriclinicBox truncatedOctahedron(double [,bool=True [,bool=True]])

typename()#

typeName() -> str :

C++ signature :
char const* typeName()

vector0((TriclinicBox)arg1) → Vector :#

Return the first box vector.

C++ signature :: SireMaths::Vector vector0(SireVol::TriclinicBox {lvalue})

vector1((TriclinicBox)arg1) → Vector :#

Return the second box vector.

C++ signature :: SireMaths::Vector vector1(SireVol::TriclinicBox {lvalue})

vector2((TriclinicBox)arg1) → Vector :#

Return the third box vector.

C++ signature :: SireMaths::Vector vector2(SireVol::TriclinicBox {lvalue})

volume((TriclinicBox)arg1) → object :#

Get the volume of the triclinic box.

C++ signature :: SireUnits::Dimension::PhysUnit<0, 3, 0, 0, 0, 0, 0> volume(SireVol::TriclinicBox {lvalue})