Package ffx.crystal

# Class SymOp

java.lang.Object
ffx.crystal.SymOp

public class SymOp extends Object
The SymOp class defines the rotation and translation of a single symmetry operator.
Since:
1.0
Author:
Michael J. Schnieders
• ## Field Summary

Fields
Modifier and Type
Field
Description
`final int[]`
`replicatesVector`
Replicates position for the given symmetry operator (LxMxN).
`final double[][]`
`rot`
The rotation matrix in fractional coordinates.
`final double[]`
`tr`
The translation vector in fractional coordinates.
`static final double[]`
`Tr_0_0_0`
Constant `Tr_0_0_0={ZERO, ZERO, ZERO}`
`static final double[][]`
`ZERO_ROTATION`
Constant `ZERO_ROTATION = {{1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {0.0, 0.0, 1.0}}`
• ## Constructor Summary

Constructors
Constructor
Description
`SymOp(double[][] m)`
The SymOp constructor using a 4x4 matrix.
```SymOp(double[][] rot, double[] tr)```
The SymOp constructor using a rotation matrix and translation vector.
```SymOp(double[][] rot, double[] tr, int[] replicatesVector)```
The SymOp constructor using a rotation matrix and translation vector.
• ## Method Summary

Modifier and Type
Method
Description
`SymOp`
`append(SymOp symOp)`
Return the combined SymOp that is equivalent to first applying `this` SymOp and then the argument.
`static void`
```applyCartesianSymOp(double[] xyz, double[] mate, SymOp symOp)```
Apply a cartesian symmetry operator to an array of coordinates.
`static void`
```applyCartesianSymOp(double[] xyz, double[] mate, SymOp symOp, boolean[] mask)```
Apply a cartesian symmetry operator to an array of coordinates.
`static void`
```applyCartesianSymRot(double[] xyz, double[] mate, SymOp symOp)```
Apply a Cartesian symmetry rotation to an array of Cartesian coordinates.
`static void`
```applyCartesianSymRot(double[] xyz, double[] mate, SymOp symOp, boolean[] mask)```
Apply a Cartesian symmetry rotation to an array of Cartesian coordinates.
`static void`
```applyCartSymOp(int n, double[] x, double[] y, double[] z, double[] mateX, double[] mateY, double[] mateZ, SymOp symOp)```
Apply a Cartesian symmetry operator to an array of Cartesian coordinates.
`static void`
```applyFracSymOp(double[] xyz, double[] mate, SymOp symOp)```
Apply a fractional symmetry operator to one set of coordinates.
`static void`
```applySymOp(int h, int k, int l, int[] mate, SymOp symOp, int nx, int ny, int nz)```
Apply a symmetry operator to one set of coordinates.
`static void`
```applySymRot(HKL hkl, HKL mate, SymOp symOp)```
Apply a symmetry operator to one HKL.
`static void`
```applyTransSymRot(HKL hkl, HKL mate, SymOp symOp)```
Apply a transpose rotation symmetry operator to one HKL.
`double[][]`
`asMatrix()`
Return the SymOp as a 4x4 matrix.
`static String`
`asMatrixString(SymOp symOp)`
Print a Sym Op matrix as a continued line string.
`static SymOp`
```combineSymOps(SymOp symOp1, SymOp symOp2)```
Return the combined SymOp that is equivalent to first applying symOp1 and then SymOp2.
`static SymOp`
`invertSymOp(SymOp symOp)`
Invert a symmetry operator.
`static SymOp`
`parse(String s)`
Create a SymOp from an input String.
`SymOp`
`prepend(SymOp symOp)`
Return the combined SymOp that is equivalent to first applying the argument and then `this` SymOp.
`static SymOp`
`randomSymOpFactory(double scalar)`
Generate a random Cartesian Symmetry Operator.
`static SymOp`
`randomSymOpFactory(double[] tr)`
Generate a random Cartesian Symmetry Operator.
`double`
`symPhaseShift(double[] hkl)`
symPhaseShift
`double`
`symPhaseShift(HKL hkl)`
symPhaseShift
`String`
`toString()`
`String`
`toStringPrecise()`
Print the symmetry operator with double precision.
`String`
`toXYZString()`
toXYZString

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`
• ## Field Details

• ### ZERO_ROTATION

public static final double[][] ZERO_ROTATION
Constant `ZERO_ROTATION = {{1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {0.0, 0.0, 1.0}}`
• ### Tr_0_0_0

public static final double[] Tr_0_0_0
Constant `Tr_0_0_0={ZERO, ZERO, ZERO}`
• ### rot

public final double[][] rot
The rotation matrix in fractional coordinates.
• ### tr

public final double[] tr
The translation vector in fractional coordinates.
• ### replicatesVector

public final int[] replicatesVector
Replicates position for the given symmetry operator (LxMxN).
• ## Constructor Details

• ### SymOp

public SymOp(double[][] rot, double[] tr)
The SymOp constructor using a rotation matrix and translation vector.
Parameters:
`rot` - The rotation matrix.
`tr` - The translation vector.
• ### SymOp

public SymOp(double[][] rot, double[] tr, int[] replicatesVector)
The SymOp constructor using a rotation matrix and translation vector.
Parameters:
`rot` - The rotation matrix.
`tr` - The translation vector.
`replicatesVector` - Describes symmetry operators location within replicates crystal.
• ### SymOp

public SymOp(double[][] m)
The SymOp constructor using a 4x4 matrix.
Parameters:
`m` - The rotation matrix and translation vector as a 4x4 matrix.
• ## Method Details

• ### symPhaseShift

public double symPhaseShift(double[] hkl)
symPhaseShift
Parameters:
`hkl` - an array of double.
Returns:
a double.
• ### symPhaseShift

public double symPhaseShift(HKL hkl)
symPhaseShift
Parameters:
`hkl` - a `HKL` object.
Returns:
a double.
• ### asMatrix

public double[][] asMatrix()
Return the SymOp as a 4x4 matrix.
Returns:
A 4x4 matrix representation of the SymOp.
• ### append

public SymOp append(SymOp symOp)
Return the combined SymOp that is equivalent to first applying `this` SymOp and then the argument. Note: Applied as rotation then translation. `X' = S_arg(S_this(X))` `X' = S_combined(X)`
Parameters:
`symOp` - The SymOp to append to `this` SymOp.
Returns:
The combined SymOp.
• ### prepend

public SymOp prepend(SymOp symOp)
Return the combined SymOp that is equivalent to first applying the argument and then `this` SymOp. Note: Applied as rotation then translation. `X' = S_this(S_arg(X))` `X' = S_combined(X)`
Parameters:
`symOp` - The SymOp to prepend to `this` SymOp.
Returns:
The combined SymOp.
• ### combineSymOps

public static SymOp combineSymOps(SymOp symOp1, SymOp symOp2)
Return the combined SymOp that is equivalent to first applying symOp1 and then SymOp2. Note: Applied as rotation then translation.

`X' = S_2(S_1(X))` `X' = S_combined(X)`

Parameters:
`symOp1` - The fist SymOp.
`symOp2` - The second SymOp.
Returns:
The combined SymOp.
• ### applyCartSymOp

public static void applyCartSymOp(int n, double[] x, double[] y, double[] z, double[] mateX, double[] mateY, double[] mateZ, SymOp symOp)
Apply a Cartesian symmetry operator to an array of Cartesian coordinates. If the arrays x, y or z are null or not of length n, the method returns immediately. If mateX, mateY or mateZ are null or not of length n, the method returns immediately.
Parameters:
`n` - Number of atoms.
`x` - Input cartesian x-coordinates.
`y` - Input cartesian y-coordinates.
`z` - Input cartesian z-coordinates.
`mateX` - Output cartesian x-coordinates.
`mateY` - Output cartesian y-coordinates.
`mateZ` - Output cartesian z-coordinates.
`symOp` - The cartesian symmetry operator.
• ### applyCartesianSymOp

public static void applyCartesianSymOp(double[] xyz, double[] mate, SymOp symOp)
Apply a cartesian symmetry operator to an array of coordinates.
Parameters:
`xyz` - Input cartesian coordinates.
`mate` - Symmetry mate cartesian coordinates.
`symOp` - The cartesian symmetry operator.
• ### applyCartesianSymOp

public static void applyCartesianSymOp(double[] xyz, double[] mate, SymOp symOp, boolean[] mask)
Apply a cartesian symmetry operator to an array of coordinates.
Parameters:
`xyz` - Input cartesian coordinates.
`mate` - Symmetry mate cartesian coordinates.
`symOp` - The cartesian symmetry operator.
`mask` - Only apply the SymOp if the per atom mask is true.
• ### applyFracSymOp

public static void applyFracSymOp(double[] xyz, double[] mate, SymOp symOp)
Apply a fractional symmetry operator to one set of coordinates.
Parameters:
`xyz` - Input fractional coordinates.
`mate` - Symmetry mate fractional coordinates.
`symOp` - The fractional symmetry operator.
• ### applySymOp

public static void applySymOp(int h, int k, int l, int[] mate, SymOp symOp, int nx, int ny, int nz)
Apply a symmetry operator to one set of coordinates.
Parameters:
`h` - Input coordinates.
`k` - Input coordinates.
`l` - Input coordinates.
`mate` - Symmetry mate coordinates.
`symOp` - The symmetry operator.
`nx` - number of unit cell translations
`ny` - number of unit cell translations
`nz` - number of unit cell translations
• ### applySymRot

public static void applySymRot(HKL hkl, HKL mate, SymOp symOp)
Apply a symmetry operator to one HKL.
Parameters:
`hkl` - Input HKL.
`mate` - Symmetry mate HKL.
`symOp` - The symmetry operator.
• ### applyCartesianSymRot

public static void applyCartesianSymRot(double[] xyz, double[] mate, SymOp symOp)
Apply a Cartesian symmetry rotation to an array of Cartesian coordinates. The length of xyz must be divisible by 3 and mate must have the same length.
Parameters:
`xyz` - Input cartesian x, y, z-coordinates.
`mate` - Output cartesian x, y, z-coordinates.
`symOp` - The fractional symmetry operator.
• ### applyCartesianSymRot

public static void applyCartesianSymRot(double[] xyz, double[] mate, SymOp symOp, boolean[] mask)
Apply a Cartesian symmetry rotation to an array of Cartesian coordinates. The length of xyz must be divisible by 3 and mate must have the same length.
Parameters:
`xyz` - Input cartesian x, y, z-coordinates.
`mate` - Output cartesian x, y, z-coordinates.
`symOp` - The fractional symmetry operator.
`mask` - Only apply the SymOp if the per atom mask is true.
• ### applyTransSymRot

public static void applyTransSymRot(HKL hkl, HKL mate, SymOp symOp)
Apply a transpose rotation symmetry operator to one HKL.
Parameters:
`hkl` - Input HKL.
`mate` - Symmetry mate HKL.
`symOp` - The symmetry operator.
• ### asMatrixString

public static String asMatrixString(SymOp symOp)
Print a Sym Op matrix as a continued line string.
Parameters:
`symOp` - Symmetry operation to print.
Returns:
Continued line string.
• ### invertSymOp

public static SymOp invertSymOp(SymOp symOp)
Invert a symmetry operator.
Parameters:
`symOp` - Original symmetry operator of which the inverse is desired.
Returns:
SymOp The inverse symmetry operator of the one supplied.
• ### parse

public static SymOp parse(String s)
Create a SymOp from an input String.
Parameters:
`s` - Input `String` containing 12 white-space delimited double values.
Returns:
The SymOp.
• ### randomSymOpFactory

public static SymOp randomSymOpFactory(double scalar)
Generate a random Cartesian Symmetry Operator.
Parameters:
`scalar` - The range of translations will be from -scalar/2 .. scalar/2.
Returns:
A Cartesian SymOp with a random rotation and translation.
• ### randomSymOpFactory

public static SymOp randomSymOpFactory(double[] tr)
Generate a random Cartesian Symmetry Operator.

The random rotation matrix is derived from: Arvo, James (1992), "Fast random rotation matrices", in David Kirk, Graphics Gems III, San Diego: Academic Press Professional, pp. 117–120, ISBN 978-0-12-409671-4

Parameters:
`tr` - The translations to apply.
Returns:
A Cartesian SymOp with a random rotation and translation.
• ### toString

public String toString()
Overrides:
`toString` in class `Object`
• ### toStringPrecise

public String toStringPrecise()
Print the symmetry operator with double precision.
Returns:
String of rotation/translation with double precision.
• ### toXYZString

public String toXYZString()
toXYZString
Returns:
a `String` object.