Symmetry
Date: 2019-10-22

org.jmol.symmetry

## Class Symmetry

- java.lang.Object
- - org.jmol.symmetry.Symmetry

- All Implemented Interfaces:
    SymmetryInterface

      public class Symmetry
      extends java.lang.Object
      implements SymmetryInterface

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `(package private) CIPChirality` | `cip`
    `private SymmetryDesc` | `desc`
    `private boolean` | `isBio`
    `private PointGroup` | `pointGroup`
    `(package private) SpaceGroup` | `spaceGroup`
    `private SymmetryInfo` | `symmetryInfo`
    `private UnitCell` | `unitCell`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Symmetry()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `int` | `addBioMoleculeOperation(javajs.util.M4 mat, boolean isReverse)`
    `boolean` | `addLatticeVectors(javajs.util.Lst<float[]> lattvecs)`
    `java.lang.String` | `addOp(java.lang.String code, javajs.util.Matrix rs, javajs.util.Matrix vs, javajs.util.Matrix sigma)`
    `int` | `addSpaceGroupOperation(java.lang.String xyz, int opId)`
    `void` | `calculateCIPChiralityForAtoms(Viewer vwr, javajs.util.BS bsAtoms)`
    `java.lang.String[]` | `calculateCIPChiralityForSmiles(Viewer vwr, java.lang.String smiles)`
    `boolean` | `checkDistance(javajs.util.P3 f1, javajs.util.P3 f2, float distance, float dx, int iRange, int jRange, int kRange, javajs.util.P3 ptOffset)`
    `boolean` | `checkUnitCell(SymmetryInterface uc, javajs.util.P3 cell, javajs.util.P3 ptTemp, boolean isAbsolute)`
    `boolean` | `createSpaceGroup(int desiredSpaceGroupIndex, java.lang.String name, java.lang.Object data, int modDim)`
    `java.lang.String` | `fcoord(javajs.util.T3 p)`
    `javajs.util.Lst<javajs.util.P3>` | `generateCrystalClass(javajs.util.P3 pt0)`
    `javajs.util.P3[]` | `getCanonicalCopy(float scale, boolean withOffset)`
    `javajs.util.P3` | `getCartesianOffset()`
    `int[]` | `getCellRange()`
    `private CIPChirality` | `getCIPChirality(Viewer vwr)`
    `javajs.util.T3[]` | `getConventionalUnitCell(java.lang.String latticeType, javajs.util.M3 primitiveToCrystal)` return a conventional lattice from a primitive
    `boolean` | `getCoordinatesAreFractional()`
    `private SymmetryDesc` | `getDesc(ModelSet modelSet)`
    `javajs.util.P3` | `getFractionalOffset()`
    `javajs.util.T3` | `getFractionalOrigin()`
    `java.lang.String` | `getIntTableNumber()`
    `AtomIndexIterator` | `getIterator(Viewer vwr, Atom atom, Atom[] atoms, javajs.util.BS bsAtoms, float radius)`
    `java.lang.Object` | `getLatticeDesignation()`
    `int` | `getLatticeOp()`
    `java.lang.String` | `getLatticeType()`
    `java.lang.String` | `getMatrixFromString(java.lang.String xyz, float[] rotTransMatrix, boolean allowScaling, int modDim)`
    `javajs.util.Lst<java.lang.String>` | `getMoreInfo()`
    `javajs.util.Matrix` | `getOperationRsVs(int iop)`
    `java.lang.Object` | `getPointGroupInfo(int modelIndex, java.lang.String drawID, boolean asInfo, java.lang.String type, int index, float scale)`
    `java.lang.String` | `getPointGroupName()`
    `javajs.util.Quat` | `getQuaternionRotation(java.lang.String abc)`
    `int` | `getSiteMultiplicity(javajs.util.P3 pt)`
    `java.lang.Object` | `getSpaceGroup()`
    `java.util.Map<java.lang.String,java.lang.Object>` | `getSpaceGroupInfo(ModelSet modelSet, java.lang.String sgName, int modelIndex, boolean isFull, float[] cellParams)`
    `java.lang.Object` | `getSpaceGroupInfoObj(java.lang.String name, SymmetryInterface cellInfo, boolean isFull)`
    `java.lang.String` | `getSpaceGroupName()`
    `javajs.util.M4` | `getSpaceGroupOperation(int i)`
    `java.lang.String` | `getSpaceGroupOperationCode(int iOp)`
    `int` | `getSpaceGroupOperationCount()`
    `java.lang.String` | `getSpaceGroupXyz(int i, boolean doNormalize)`
    `float` | `getSpinOp(int op)`
    `boolean` | `getState(javajs.util.SB commands)`
    `java.lang.Object` | `getSymmetryInfoAtom(ModelSet modelSet, int iatom, java.lang.String xyz, int op, javajs.util.P3 pt, javajs.util.P3 pt2, java.lang.String id, int type, float scaleFactor, int nth, int options)`
    `java.lang.String` | `getSymmetryInfoStr()`
    `javajs.util.M4[]` | `getSymmetryOperations()`
    `Tensor` | `getTensor(Viewer vwr, float[] parBorU)`
    `SymmetryInterface` | `getUnitCell(javajs.util.T3[] oabc, boolean setRelative, java.lang.String name)`
    `float[]` | `getUnitCellAsArray(boolean vectorsOnly)`
    `java.lang.String` | `getUnitCellInfo()`
    `java.util.Map<java.lang.String,java.lang.Object>` | `getUnitCellInfoMap()`
    `float` | `getUnitCellInfoType(int infoType)`
    `javajs.util.T3` | `getUnitCellMultiplier()`
    `float[]` | `getUnitCellParams()`
    `java.lang.String` | `getUnitCellState()`
    `javajs.util.P3[]` | `getUnitCellVectors()`
    `javajs.util.P3[]` | `getUnitCellVerticesNoOffset()`
    `java.lang.String` | `getUnitsymmetryInfo()`
    `javajs.util.T3[]` | `getV0abc(java.lang.Object def)`
    `boolean` | `haveUnitCell()`
    `void` | `initializeOrientation(javajs.util.M3 mat)`
    `boolean` | `isBio()`
    `private boolean` | `isNotCentroid(javajs.util.P3 center, int n, int[] minmax, boolean centroidPacked)`
    `boolean` | `isPolymer()`
    `boolean` | `isSimple()`
    `boolean` | `isSlab()`
    `boolean` | `isSupercell()`
    `void` | `newSpaceGroupPoint(int i, javajs.util.P3 atom1, javajs.util.P3 atom2, int transX, int transY, int transZ, javajs.util.M4 o)`
    `javajs.util.BS` | `notInCentroid(ModelSet modelSet, javajs.util.BS bsAtoms, int[] minmax)`
    `javajs.util.V3[]` | `rotateAxes(int iop, javajs.util.V3[] axes, javajs.util.P3 ptTemp, javajs.util.M3 mTemp)`
    `void` | `setFinalOperations(java.lang.String name, javajs.util.P3[] atoms, int iAtomFirst, int noSymmetryCount, boolean doNormalize, java.lang.String filterSymop)`
    `void` | `setLattice(int latt)` set symmetry lattice type using Hall rotations
    `void` | `setLatticeType(java.lang.String type)`
    `void` | `setOffset(int nnn)`
    `void` | `setOffsetPt(javajs.util.T3 pt)`
    `SymmetryInterface` | `setPointGroup(SymmetryInterface siLast, javajs.util.T3 center, javajs.util.T3[] atomset, javajs.util.BS bsAtoms, boolean haveVibration, float distanceTolerance, float linearTolerance, boolean localEnvOnly)`
    `void` | `setSpaceGroup(boolean doNormalize)`
    `void` | `setSpaceGroupFrom(SymmetryInterface symmetry)`
    `void` | `setSpaceGroupName(java.lang.String name)`
    `SymmetryInterface` | `setSymmetryInfo(int modelIndex, java.util.Map<java.lang.String,java.lang.Object> modelAuxiliaryInfo, float[] unitCellParams)` Set space group and unit cell from the auxiliary info generated by the model adapter.
    `void` | `setTimeReversal(int op, int val)`
    `void` | `setUnitCell(float[] unitCellParams, boolean setRelative)`
    `void` | `setUnitCell(Symmetry uc)`
    `void` | `toCartesian(javajs.util.T3 fpt, boolean ignoreOffset)`
    `void` | `toFractional(javajs.util.T3 pt, boolean ignoreOffset)`
    `void` | `toFractionalM(javajs.util.M4 m)`
    `boolean` | `toFromPrimitive(boolean toPrimitive, char type, javajs.util.T3[] oabc, javajs.util.M3 primitiveToCrystal)`
    `javajs.util.P3` | `toSupercell(javajs.util.P3 fpt)`
    `void` | `toUnitCell(javajs.util.T3 pt, javajs.util.T3 offset)`
    `boolean` | `unitCellEquals(SymmetryInterface uc2)`
    `void` | `unitize(javajs.util.T3 ptFrac)`

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

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### pointGroup

          private PointGroup pointGroup

    - #### spaceGroup

          SpaceGroup spaceGroup

    - #### symmetryInfo

          private SymmetryInfo symmetryInfo

    - #### unitCell

          private UnitCell unitCell

    - #### isBio

          private boolean isBio

    - #### desc

          private SymmetryDesc desc

    - #### cip

          CIPChirality cip

  - ### Constructor Detail

    - #### Symmetry

          public Symmetry()

  - ### Method Detail

    - #### isBio

          public boolean isBio()

      Specified by:
        `isBio` in interface `SymmetryInterface`

    - #### setPointGroup

          public SymmetryInterface setPointGroup(SymmetryInterface siLast,
                                                 javajs.util.T3 center,
                                                 javajs.util.T3[] atomset,
                                                 javajs.util.BS bsAtoms,
                                                 boolean haveVibration,
                                                 float distanceTolerance,
                                                 float linearTolerance,
                                                 boolean localEnvOnly)

      Specified by:
        `setPointGroup` in interface `SymmetryInterface`

    - #### getPointGroupName

          public java.lang.String getPointGroupName()

      Specified by:
        `getPointGroupName` in interface `SymmetryInterface`

    - #### getPointGroupInfo

          public java.lang.Object getPointGroupInfo(int modelIndex,
                                                    java.lang.String drawID,
                                                    boolean asInfo,
                                                    java.lang.String type,
                                                    int index,
                                                    float scale)

      Specified by:
        `getPointGroupInfo` in interface `SymmetryInterface`

    - #### setSpaceGroup

          public void setSpaceGroup(boolean doNormalize)

      Specified by:
        `setSpaceGroup` in interface `SymmetryInterface`

    - #### addSpaceGroupOperation

          public int addSpaceGroupOperation(java.lang.String xyz,
                                            int opId)

      Specified by:
        `addSpaceGroupOperation` in interface `SymmetryInterface`

    - #### addBioMoleculeOperation

          public int addBioMoleculeOperation(javajs.util.M4 mat,
                                             boolean isReverse)

      Specified by:
        `addBioMoleculeOperation` in interface `SymmetryInterface`

    - #### setLattice

          public void setLattice(int latt)

      Description copied from interface: `SymmetryInterface`
      set symmetry lattice type using Hall rotations
      Specified by:
        `setLattice` in interface `SymmetryInterface`
      Parameters:
        `latt` - SHELX index or character lattice character P I R F A B C S T or \0

    - #### getSpaceGroup

          public java.lang.Object getSpaceGroup()

      Specified by:
        `getSpaceGroup` in interface `SymmetryInterface`

    - #### setSpaceGroupFrom

          public void setSpaceGroupFrom(SymmetryInterface symmetry)

      Specified by:
        `setSpaceGroupFrom` in interface `SymmetryInterface`

    - #### createSpaceGroup

          public boolean createSpaceGroup(int desiredSpaceGroupIndex,
                                          java.lang.String name,
                                          java.lang.Object data,
                                          int modDim)

      Specified by:
        `createSpaceGroup` in interface `SymmetryInterface`
      Parameters:
        `desiredSpaceGroupIndex` -
        `name` -
        `data` - a Lst or Lst
        `d` - in [3+d] modulation dimension
      Returns:
        true if a known space group

    - #### getSpaceGroupInfoObj

          public java.lang.Object getSpaceGroupInfoObj(java.lang.String name,
                                                       SymmetryInterface cellInfo,
                                                       boolean isFull)

      Specified by:
        `getSpaceGroupInfoObj` in interface `SymmetryInterface`

    - #### getLatticeDesignation

          public java.lang.Object getLatticeDesignation()

      Specified by:
        `getLatticeDesignation` in interface `SymmetryInterface`

    - #### setFinalOperations

          public void setFinalOperations(java.lang.String name,
                                         javajs.util.P3[] atoms,
                                         int iAtomFirst,
                                         int noSymmetryCount,
                                         boolean doNormalize,
                                         java.lang.String filterSymop)

      Specified by:
        `setFinalOperations` in interface `SymmetryInterface`

    - #### getSpaceGroupOperation

          public javajs.util.M4 getSpaceGroupOperation(int i)

      Specified by:
        `getSpaceGroupOperation` in interface `SymmetryInterface`

    - #### getSpaceGroupXyz

          public java.lang.String getSpaceGroupXyz(int i,
                                                   boolean doNormalize)

      Specified by:
        `getSpaceGroupXyz` in interface `SymmetryInterface`

    - #### newSpaceGroupPoint

          public void newSpaceGroupPoint(int i,
                                         javajs.util.P3 atom1,
                                         javajs.util.P3 atom2,
                                         int transX,
                                         int transY,
                                         int transZ,
                                         javajs.util.M4 o)

      Specified by:
        `newSpaceGroupPoint` in interface `SymmetryInterface`

    - #### rotateAxes

          public javajs.util.V3[] rotateAxes(int iop,
                                             javajs.util.V3[] axes,
                                             javajs.util.P3 ptTemp,
                                             javajs.util.M3 mTemp)

      Specified by:
        `rotateAxes` in interface `SymmetryInterface`

    - #### getSpaceGroupOperationCode

          public java.lang.String getSpaceGroupOperationCode(int iOp)

      Specified by:
        `getSpaceGroupOperationCode` in interface `SymmetryInterface`

    - #### setTimeReversal

          public void setTimeReversal(int op,
                                      int val)

      Specified by:
        `setTimeReversal` in interface `SymmetryInterface`

    - #### getSpinOp

          public float getSpinOp(int op)

      Specified by:
        `getSpinOp` in interface `SymmetryInterface`

    - #### addLatticeVectors

          public boolean addLatticeVectors(javajs.util.Lst<float[]> lattvecs)

      Specified by:
        `addLatticeVectors` in interface `SymmetryInterface`

    - #### getLatticeOp

          public int getLatticeOp()

      Specified by:
        `getLatticeOp` in interface `SymmetryInterface`

    - #### getOperationRsVs

          public javajs.util.Matrix getOperationRsVs(int iop)

      Specified by:
        `getOperationRsVs` in interface `SymmetryInterface`

    - #### getSiteMultiplicity

          public int getSiteMultiplicity(javajs.util.P3 pt)

      Specified by:
        `getSiteMultiplicity` in interface `SymmetryInterface`

    - #### addOp

          public java.lang.String addOp(java.lang.String code,
                                        javajs.util.Matrix rs,
                                        javajs.util.Matrix vs,
                                        javajs.util.Matrix sigma)

      Specified by:
        `addOp` in interface `SymmetryInterface`

    - #### getMatrixFromString

          public java.lang.String getMatrixFromString(java.lang.String xyz,
                                                      float[] rotTransMatrix,
                                                      boolean allowScaling,
                                                      int modDim)

      Specified by:
        `getMatrixFromString` in interface `SymmetryInterface`

    - #### getSpaceGroupName

          public java.lang.String getSpaceGroupName()

      Specified by:
        `getSpaceGroupName` in interface `SymmetryInterface`

    - #### setSpaceGroupName

          public void setSpaceGroupName(java.lang.String name)

      Specified by:
        `setSpaceGroupName` in interface `SymmetryInterface`

    - #### getSpaceGroupOperationCount

          public int getSpaceGroupOperationCount()

      Specified by:
        `getSpaceGroupOperationCount` in interface `SymmetryInterface`

    - #### getLatticeType

          public java.lang.String getLatticeType()

      Specified by:
        `getLatticeType` in interface `SymmetryInterface`

    - #### setLatticeType

          public void setLatticeType(java.lang.String type)

      Specified by:
        `setLatticeType` in interface `SymmetryInterface`

    - #### getIntTableNumber

          public java.lang.String getIntTableNumber()

      Specified by:
        `getIntTableNumber` in interface `SymmetryInterface`

    - #### getCoordinatesAreFractional

          public boolean getCoordinatesAreFractional()

      Specified by:
        `getCoordinatesAreFractional` in interface `SymmetryInterface`

    - #### getCellRange

          public int[] getCellRange()

      Specified by:
        `getCellRange` in interface `SymmetryInterface`

    - #### getSymmetryInfoStr

          public java.lang.String getSymmetryInfoStr()

      Specified by:
        `getSymmetryInfoStr` in interface `SymmetryInterface`

    - #### getSymmetryOperations

          public javajs.util.M4[] getSymmetryOperations()

      Specified by:
        `getSymmetryOperations` in interface `SymmetryInterface`

    - #### isSimple

          public boolean isSimple()

      Specified by:
        `isSimple` in interface `SymmetryInterface`

    - #### setSymmetryInfo

          public SymmetryInterface setSymmetryInfo(int modelIndex,
                                                   java.util.Map<java.lang.String,java.lang.Object> modelAuxiliaryInfo,
                                                   float[] unitCellParams)

      Set space group and unit cell from the auxiliary info generated by the model adapter.
      Specified by:
        `setSymmetryInfo` in interface `SymmetryInterface`

    - #### haveUnitCell

          public boolean haveUnitCell()

      Specified by:
        `haveUnitCell` in interface `SymmetryInterface`

    - #### checkUnitCell

          public boolean checkUnitCell(SymmetryInterface uc,
                                       javajs.util.P3 cell,
                                       javajs.util.P3 ptTemp,
                                       boolean isAbsolute)

      Specified by:
        `checkUnitCell` in interface `SymmetryInterface`

    - #### setUnitCell

          public void setUnitCell(float[] unitCellParams,
                                  boolean setRelative)

      Specified by:
        `setUnitCell` in interface `SymmetryInterface`

    - #### unitCellEquals

          public boolean unitCellEquals(SymmetryInterface uc2)

      Specified by:
        `unitCellEquals` in interface `SymmetryInterface`

    - #### getUnitCellState

          public java.lang.String getUnitCellState()

      Specified by:
        `getUnitCellState` in interface `SymmetryInterface`

    - #### getMoreInfo

          public javajs.util.Lst<java.lang.String> getMoreInfo()

      Specified by:
        `getMoreInfo` in interface `SymmetryInterface`

    - #### getUnitsymmetryInfo

          public java.lang.String getUnitsymmetryInfo()

    - #### initializeOrientation

          public void initializeOrientation(javajs.util.M3 mat)

      Specified by:
        `initializeOrientation` in interface `SymmetryInterface`

    - #### unitize

          public void unitize(javajs.util.T3 ptFrac)

      Specified by:
        `unitize` in interface `SymmetryInterface`

    - #### toUnitCell

          public void toUnitCell(javajs.util.T3 pt,
                                 javajs.util.T3 offset)

      Specified by:
        `toUnitCell` in interface `SymmetryInterface`

    - #### toSupercell

          public javajs.util.P3 toSupercell(javajs.util.P3 fpt)

      Specified by:
        `toSupercell` in interface `SymmetryInterface`

    - #### toFractional

          public void toFractional(javajs.util.T3 pt,
                                   boolean ignoreOffset)

      Specified by:
        `toFractional` in interface `SymmetryInterface`

    - #### toFractionalM

          public void toFractionalM(javajs.util.M4 m)

      Specified by:
        `toFractionalM` in interface `SymmetryInterface`

    - #### toCartesian

          public void toCartesian(javajs.util.T3 fpt,
                                  boolean ignoreOffset)

      Specified by:
        `toCartesian` in interface `SymmetryInterface`

    - #### getUnitCellParams

          public float[] getUnitCellParams()

      Specified by:
        `getUnitCellParams` in interface `SymmetryInterface`

    - #### getUnitCellAsArray

          public float[] getUnitCellAsArray(boolean vectorsOnly)

      Specified by:
        `getUnitCellAsArray` in interface `SymmetryInterface`

    - #### getTensor

          public Tensor getTensor(Viewer vwr,
                                  float[] parBorU)

      Specified by:
        `getTensor` in interface `SymmetryInterface`

    - #### getUnitCellVerticesNoOffset

          public javajs.util.P3[] getUnitCellVerticesNoOffset()

      Specified by:
        `getUnitCellVerticesNoOffset` in interface `SymmetryInterface`

    - #### getCartesianOffset

          public javajs.util.P3 getCartesianOffset()

      Specified by:
        `getCartesianOffset` in interface `SymmetryInterface`

    - #### getFractionalOffset

          public javajs.util.P3 getFractionalOffset()

      Specified by:
        `getFractionalOffset` in interface `SymmetryInterface`

    - #### setOffsetPt

          public void setOffsetPt(javajs.util.T3 pt)

      Specified by:
        `setOffsetPt` in interface `SymmetryInterface`

    - #### setOffset

          public void setOffset(int nnn)

      Specified by:
        `setOffset` in interface `SymmetryInterface`

    - #### getUnitCellMultiplier

          public javajs.util.T3 getUnitCellMultiplier()

      Specified by:
        `getUnitCellMultiplier` in interface `SymmetryInterface`

    - #### getCanonicalCopy

          public javajs.util.P3[] getCanonicalCopy(float scale,
                                                   boolean withOffset)

      Specified by:
        `getCanonicalCopy` in interface `SymmetryInterface`

    - #### getUnitCellInfoType

          public float getUnitCellInfoType(int infoType)

      Specified by:
        `getUnitCellInfoType` in interface `SymmetryInterface`

    - #### getUnitCellInfo

          public java.lang.String getUnitCellInfo()

      Specified by:
        `getUnitCellInfo` in interface `SymmetryInterface`

    - #### isSlab

          public boolean isSlab()

      Specified by:
        `isSlab` in interface `SymmetryInterface`

    - #### isPolymer

          public boolean isPolymer()

      Specified by:
        `isPolymer` in interface `SymmetryInterface`

    - #### checkDistance

          public boolean checkDistance(javajs.util.P3 f1,
                                       javajs.util.P3 f2,
                                       float distance,
                                       float dx,
                                       int iRange,
                                       int jRange,
                                       int kRange,
                                       javajs.util.P3 ptOffset)

      Specified by:
        `checkDistance` in interface `SymmetryInterface`

    - #### getUnitCellVectors

          public javajs.util.P3[] getUnitCellVectors()

      Specified by:
        `getUnitCellVectors` in interface `SymmetryInterface`

    - #### getUnitCell

          public SymmetryInterface getUnitCell(javajs.util.T3[] oabc,
                                               boolean setRelative,
                                               java.lang.String name)

      Specified by:
        `getUnitCell` in interface `SymmetryInterface`
      Parameters:
        `oabc` - [ptorigin, va, vb, vc]
        `setRelative` - a flag only set true for IsosurfaceMesh
        `name` -
      Returns:
        this SymmetryInterface

    - #### isSupercell

          public boolean isSupercell()

      Specified by:
        `isSupercell` in interface `SymmetryInterface`

    - #### notInCentroid

          public javajs.util.BS notInCentroid(ModelSet modelSet,
                                              javajs.util.BS bsAtoms,
                                              int[] minmax)

      Specified by:
        `notInCentroid` in interface `SymmetryInterface`

    - #### isNotCentroid

          private boolean isNotCentroid(javajs.util.P3 center,
                                        int n,
                                        int[] minmax,
                                        boolean centroidPacked)

    - #### getDesc

          private SymmetryDesc getDesc(ModelSet modelSet)

    - #### getSymmetryInfoAtom

          public java.lang.Object getSymmetryInfoAtom(ModelSet modelSet,
                                                      int iatom,
                                                      java.lang.String xyz,
                                                      int op,
                                                      javajs.util.P3 pt,
                                                      javajs.util.P3 pt2,
                                                      java.lang.String id,
                                                      int type,
                                                      float scaleFactor,
                                                      int nth,
                                                      int options)

      Specified by:
        `getSymmetryInfoAtom` in interface `SymmetryInterface`
        `pt2` - a second point or an offset
        `type` - T.point, T.lattice, or T.draw, T.matrix4f, T.label, T.list, T.info, T.translation, T.axis, T.plane, T.angle, T.center
        `nth` - TODO
        `options` - could be T.offset
      Returns:
        a variety of object types

    - #### getSpaceGroupInfo

          public java.util.Map<java.lang.String,java.lang.Object> getSpaceGroupInfo(ModelSet modelSet,
                                                                                    java.lang.String sgName,
                                                                                    int modelIndex,
                                                                                    boolean isFull,
                                                                                    float[] cellParams)

      Specified by:
        `getSpaceGroupInfo` in interface `SymmetryInterface`

    - #### fcoord

          public java.lang.String fcoord(javajs.util.T3 p)

      Specified by:
        `fcoord` in interface `SymmetryInterface`

    - #### getV0abc

          public javajs.util.T3[] getV0abc(java.lang.Object def)

      Specified by:
        `getV0abc` in interface `SymmetryInterface`

    - #### getQuaternionRotation

          public javajs.util.Quat getQuaternionRotation(java.lang.String abc)

      Specified by:
        `getQuaternionRotation` in interface `SymmetryInterface`

    - #### getFractionalOrigin

          public javajs.util.T3 getFractionalOrigin()

      Specified by:
        `getFractionalOrigin` in interface `SymmetryInterface`

    - #### getState

          public boolean getState(javajs.util.SB commands)

      Specified by:
        `getState` in interface `SymmetryInterface`

    - #### getIterator

          public AtomIndexIterator getIterator(Viewer vwr,
                                               Atom atom,
                                               Atom[] atoms,
                                               javajs.util.BS bsAtoms,
                                               float radius)

      Specified by:
        `getIterator` in interface `SymmetryInterface`

    - #### toFromPrimitive

          public boolean toFromPrimitive(boolean toPrimitive,
                                         char type,
                                         javajs.util.T3[] oabc,
                                         javajs.util.M3 primitiveToCrystal)

      Specified by:
        `toFromPrimitive` in interface `SymmetryInterface`

    - #### generateCrystalClass

          public javajs.util.Lst<javajs.util.P3> generateCrystalClass(javajs.util.P3 pt0)

      Specified by:
        `generateCrystalClass` in interface `SymmetryInterface`

    - #### calculateCIPChiralityForAtoms

          public void calculateCIPChiralityForAtoms(Viewer vwr,
                                                    javajs.util.BS bsAtoms)

      Specified by:
        `calculateCIPChiralityForAtoms` in interface `SymmetryInterface`

    - #### calculateCIPChiralityForSmiles

          public java.lang.String[] calculateCIPChiralityForSmiles(Viewer vwr,
                                                                   java.lang.String smiles)
                                                            throws java.lang.Exception

      Specified by:
        `calculateCIPChiralityForSmiles` in interface `SymmetryInterface`
      Throws:
        `java.lang.Exception`

    - #### getCIPChirality

          private CIPChirality getCIPChirality(Viewer vwr)

    - #### getConventionalUnitCell

          public javajs.util.T3[] getConventionalUnitCell(java.lang.String latticeType,
                                                          javajs.util.M3 primitiveToCrystal)

      return a conventional lattice from a primitive
      Specified by:
        `getConventionalUnitCell` in interface `SymmetryInterface`
      Parameters:
        `latticeType` - "A" "B" "C" "R" etc.
      Returns:
        [origin va vb vc]

    - #### getUnitCellInfoMap

          public java.util.Map<java.lang.String,java.lang.Object> getUnitCellInfoMap()

      Specified by:
        `getUnitCellInfoMap` in interface `SymmetryInterface`

    - #### setUnitCell

          public void setUnitCell(Symmetry uc)

      Specified by:
        `setUnitCell` in interface `SymmetryInterface`