Field Detail

• xyzOriginal

  java.lang.String xyzOriginal

• xyz

  java.lang.String xyz

• doNormalize

  private boolean doNormalize

  "normalization" is the process of adjusting symmetry operator definitions such that the center of geometry of a molecule is within the 555 unit cell for each operation. It is carried out when "packed" is NOT issued and the lattice is given as {i j k} or when the lattice is given as {nnn mmm 1}

• isFinalized

  boolean isFinalized

• opId

  private int opId

• centering

  private javajs.util.V3 centering

• atomTest

  private static javajs.util.P3 atomTest

• myLabels

  private java.lang.String[] myLabels

• modDim

  int modDim

• linearRotTrans

  float[] linearRotTrans

• rsvs

  javajs.util.Matrix rsvs

• isBio

  boolean isBio

• sigma

  private javajs.util.Matrix sigma

• index

  int index

• subsystemCode

  java.lang.String subsystemCode

• timeReversal

  int timeReversal

• twelfths

  private static final java.lang.String[] twelfths

• labelsXYZ

  static final java.lang.String[] labelsXYZ

• labelsXn

  static final java.lang.String[] labelsXn

• labelsXnSub

  static final java.lang.String[] labelsXnSub

• unCentered

  private boolean unCentered

• isCenteringOp

  boolean isCenteringOp

• magOp

  private float magOp

Constructor Detail

• SymmetryOperation

  SymmetryOperation​(SymmetryOperation op,
                    javajs.util.P3[] atoms,
                    int atomIndex,
                    int countOrId,
                    boolean doNormalize)

  Parameters:

  op -

  atoms -

  atomIndex -

  countOrId -

  doNormalize -

Method Detail

• setSigma

  void setSigma​(java.lang.String subsystemCode,
                javajs.util.Matrix sigma)

• setGamma

  private void setGamma​(boolean isReverse)

  rsvs is the superspace group rotation-translation matrix. It is a (3 + modDim + 1) x (3 + modDim + 1) matrix from which we can extract all necessary parts;

  Parameters:

  isReverse -

• doFinalize

  void doFinalize()

• getXyz

  java.lang.String getXyz​(boolean normalized)

• newPoint

  static void newPoint​(javajs.util.M4 m,
                       javajs.util.P3 atom1,
                       javajs.util.P3 atom2,
                       int x,
                       int y,
                       int z)

• dumpInfo

  java.lang.String dumpInfo()

• dumpSeitz

  static final java.lang.String dumpSeitz​(javajs.util.M4 s,
                                          boolean isCanonical)

• setMatrixFromXYZ

  boolean setMatrixFromXYZ​(java.lang.String xyz,
                           int modDim,
                           boolean allowScaling)

• setModDim

  private void setModDim​(int dim)

• setMatrix

  private void setMatrix​(boolean isReverse)

• setFromMatrix

  boolean setFromMatrix​(float[] offset,
                        boolean isReverse)

• getMatrixFromString

  static java.lang.String getMatrixFromString​(SymmetryOperation op,
                                              java.lang.String xyz,
                                              float[] linearRotTrans,
                                              boolean allowScaling)

  Convert the Jones-Faithful notation "x, -z+1/2, y" or "x1, x3-1/2, x2, x5+1/2, -x6+1/2, x7..." to a linear array Also allows a-b,-5a-5b,-c;0,0,0 format

  Parameters:

  op -

  xyz -

  linearRotTrans -

  allowScaling -

  Returns:

  canonized Jones-Faithful string

• replaceXn

  static java.lang.String replaceXn​(java.lang.String xyz,
                                    int n)

• xyzFraction

  private static final java.lang.String xyzFraction​(float n12ths,
                                                    boolean allPositive,
                                                    boolean halfOrLess)

• twelfthsOf

  static final java.lang.String twelfthsOf​(float n12ths)

• plusMinus

  private static java.lang.String plusMinus​(java.lang.String strT,
                                            float x,
                                            java.lang.String sx)

• normalizeTwelfths

  private static float normalizeTwelfths​(float iValue,
                                         boolean doNormalize)

• getXYZFromMatrix

  static final java.lang.String getXYZFromMatrix​(javajs.util.M4 mat,
                                                 boolean is12ths,
                                                 boolean allPositive,
                                                 boolean halfOrLess)

• setOffset

  public static void setOffset​(javajs.util.M4 m,
                               javajs.util.P3[] atoms,
                               int atomIndex,
                               int count)

• rotateAxes

  javajs.util.V3[] rotateAxes​(javajs.util.V3[] vectors,
                              UnitCell unitcell,
                              javajs.util.P3 ptTemp,
                              javajs.util.M3 mTemp)

• fcoord

  static java.lang.String fcoord​(javajs.util.T3 p)

• fc

  private static java.lang.String fc​(float x)

• approxF

  static float approxF​(float f)

• getXYZFromRsVs

  static java.lang.String getXYZFromRsVs​(javajs.util.Matrix rs,
                                         javajs.util.Matrix vs,
                                         boolean is12ths)

• toString

  public java.lang.String toString()

  Description copied from class: javajs.util.M4
  Returns a string that contains the values of this Matrix4f.

  Overrides:

  toString in class javajs.util.M4

  Returns:

  the String representation

• getMagneticOp

  float getMagneticOp()

  Magnetic spin is a pseudo (or "axial") vector. This means that it acts as a rotation, not a vector. When a rotation about x is passed through the mirror plane xz, it is reversed; when it is passed through the mirror plane yz, it is not reversed -- exactly opposite what you would imagine from a standard "polar" vector. For example, a vector perpendicular to a plane of symmetry (det=-1) will be flipped (m=1), while a vector parallel to that plane will not be flipped (m=-1) In addition, magnetic spin operations have a flag m=1 or m=-1 (m or -m) that indicates how the vector quantity changes with symmetry. This is called "time reversal" and stored here as timeReversal. To apply, timeReversal must be multiplied by the 3x3 determinant, which is always 1 (standard rotation) or -1 (rotation-inversion). This we store as magOp. See https://en.wikipedia.org/wiki/Pseudovector

  Returns:

  +1, -1, or 0

• setTimeReversal

  void setTimeReversal​(int magRev)

  set the time reversal, and indicate internally in xyz as appended ",m" or ",-m"

  Parameters:

  magRev -

• getCentering

  javajs.util.V3 getCentering()

  assumption here is that these are in order of sets, as in ITA

  Returns:

  centering

• fixMagneticXYZ

  java.lang.String fixMagneticXYZ​(javajs.util.M4 m,
                                  java.lang.String xyz,
                                  boolean addMag)