* $Author: egonw $

* $Date: 2005-11-10 09:52:44 -0600 (Thu, 10 Nov 2005) $

* $Revision: 4255 $

*

* Copyright (C) 2003-2005  Miguel, Jmol Development, www.jmol.org

*

* Contact: jmol-developers@lists.sf.net

*

*  This library is free software; you can redistribute it and/or

*  modify it under the terms of the GNU Lesser General Public

*  License as published by the Free Software Foundation; either

*  version 2.1 of the License, or (at your option) any later version.

*

*  This library is distributed in the hope that it will be useful,

*  but WITHOUT ANY WARRANTY; without even the implied warranty of

*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

*  Lesser General Public License for more details.

*

*  You should have received a copy of the GNU Lesser General Public

*  License along with this library; if not, write to the Free Software

*  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

*/

*

* A general class to deal with Hermann-Mauguin or Hall names

*

* Bob Hanson 9/2006

*

* references: International Tables for Crystallography Vol. A. (2002)

*

* http://www.iucr.org/iucr-top/cif/cifdic_html/1/cif_core.dic/Ispace_group_symop_operation_xyz.html

* http://www.iucr.org/iucr-top/cif/cifdic_html/1/cif_core.dic/Isymmetry_equiv_pos_as_xyz.html

*

* Hall symbols:

*

* http://cci.lbl.gov/sginfo/hall_symbols.html

*

* and

*

* http://cci.lbl.gov/cctbx/explore_symmetry.html

*

* (-)L   [N_A^T_1]   [N_A^T_2]   ...  [N_A^T_P]   V(Nx Ny Nz)

*

* lattice types S and T are not supported here

*

* data table is from Syd Hall, private email, 9/4/2006,

* amended using * ** to indicate nonstandard H-M symbols or full names 

*

* NEVER ACCESS THESE METHODS DIRECTLY! ONLY THROUGH CLASS Symmetry

*

*

*/

  int index;

  String hallSymbol;

  //String schoenfliesSymbol; //parsed but not read

  String hmSymbol;

  String hmSymbolFull;

  //String hmSymbolCompressed;

  String hmSymbolExt;

  String hmSymbolAbbr;

  String hmSymbolAlternative;

  String hmSymbolAbbrShort;

  char ambiguityType;

  char uniqueAxis;

  char axisChoice;

  //int cellChoice;

  //int originChoice;

  String intlTableNumber;

  String intlTableNumberFull;

  String intlTableNumberExt;

  HallInfo hallInfo;

  int latticeParameter;

  char latticeCode;

  SymmetryOperation[] operations;

  int operationCount;

  boolean doNormalize = true;

  SpaceGroup(boolean doNormalize) {

    this.doNormalize = doNormalize;

    addSymmetry("x,y,z", 0);

  }

 

  private SpaceGroup(String cifLine) {

    buildSpaceGroup(cifLine);

  }

  static SpaceGroup createSpaceGroup(int desiredSpaceGroupIndex,

                                                  String name,

                                                  float[] notionalUnitcell, boolean doNormalize) {

    SpaceGroup sg = null;

    if (desiredSpaceGroupIndex >= 0) {

      sg = spaceGroupDefinitions[desiredSpaceGroupIndex];

    } else {

      sg = determineSpaceGroup(name, notionalUnitcell);

      if (sg == null)

        sg = createSpaceGroup(name, doNormalize);

    }

    if (sg != null)

      sg.generateAllOperators(null);

    return sg;

  }

  int addSymmetry(String xyz, int opId) {

    xyz = xyz.toLowerCase();

    if (xyz.indexOf("[[") < 0 &&

        (xyz.indexOf("x") < 0 || xyz.indexOf("y") < 0 || xyz.indexOf("z") < 0))

      return -1;

    return addOperation(xyz, opId);

  }

  

  SymmetryOperation[] finalOperations;

 

  void setFinalOperations(Point3f[] atoms, int atomIndex,

                                                int count, boolean doNormalize) {

    //from AtomSetCollection.applySymmetry only

    if (hallInfo == null && latticeParameter != 0) {

      HallInfo h = new HallInfo(Translation

          .getHallLatticeEquivalent(latticeParameter));

      generateAllOperators(h);

      doNormalize = false;

    }

    finalOperations = new SymmetryOperation[operationCount];

    if (doNormalize && count > 0 && atoms != null) {

      // we must apply this first to (x,y,z) JUST IN CASE the

      // model center itself is out of bounds, because we want

      // NO operation for (x,y,z). This requires REDEFINING ATOM LOCATIONS

      finalOperations[0] = new SymmetryOperation(operations[0], atoms,

          atomIndex, count, true);

      Point3f atom = atoms[atomIndex];

      Point3f c = new Point3f(atom);

      finalOperations[0].transform(c);

      if (c.distance(atom) > 0.0001) // not cartesian, but this is OK here

        for (int i = 0; i < count; i++) {

          atom = atoms[atomIndex + i];

          c.set(atom);

          finalOperations[0].transform(c);

          atom.set(c);

        }

    }

    for (int i = 0; i < operationCount; i++) {

      finalOperations[i] = new SymmetryOperation(operations[i], atoms,

          atomIndex, count, doNormalize);

    }

  }

  int getOperationCount() {

    return finalOperations.length;

  }

  Matrix4f getOperation(int i) {

    return finalOperations[i];

  }

  String getXyz(int i, boolean doNormalize) {

    return finalOperations[i].getXyz(doNormalize);

  }

  void newPoint(int i, Point3f atom1, Point3f atom2,

                       int transX, int transY, int transZ) {

    finalOperations[i].newPoint(atom1, atom2, transX, transY, transZ);

  }

   

  Object rotateEllipsoid(int i, Point3f ptTemp, Vector3f[] axes,

                                UnitCell unitCell, Point3f ptTemp1,

                                Point3f ptTemp2) {

    return finalOperations[i].rotateEllipsoid(ptTemp, axes, unitCell, ptTemp1,

        ptTemp2);

  }

  static String getInfo(String spaceGroup, SymmetryInterface cellInfo) {

    SpaceGroup sg;

    if (cellInfo != null) {

      if (spaceGroup.indexOf("[") >= 0)

        spaceGroup = spaceGroup.substring(0, spaceGroup.indexOf("[")).trim();

      if (spaceGroup.equals("unspecified!"))

        return "no space group identified in file";

      sg = SpaceGroup.determineSpaceGroup(spaceGroup, cellInfo.getNotionalUnitCell());

    } else if (spaceGroup.equalsIgnoreCase("ALL")) {

      return SpaceGroup.dumpAll();

    } else if (spaceGroup.equalsIgnoreCase("ALLSEITZ")) {

      return SpaceGroup.dumpAllSeitz();

    } else {

      sg = SpaceGroup.determineSpaceGroup(spaceGroup);

      if (sg == null) {

        sg = SpaceGroup.createSpaceGroup(spaceGroup, false);

      } else {

        StringBuffer sb = new StringBuffer();

        while (sg != null) {

          sb.append(sg.dumpInfo(null));

          sg = SpaceGroup.determineSpaceGroup(spaceGroup, sg);

        }

        return sb.toString();

      }

    }

    return sg == null ? "?" : sg.dumpInfo(cellInfo);

  }

 

  String dumpInfo(SymmetryInterface cellInfo) {

    Object info  = dumpCanonicalSeitzList();

    if (info instanceof SpaceGroup)

      return ((SpaceGroup)info).dumpInfo(null);

    StringBuffer sb = new StringBuffer("\nHermann-Mauguin symbol: ");

    sb.append(hmSymbol).append(hmSymbolExt.length() > 0 ? ":" + hmSymbolExt : "")

        .append("\ninternational table number: ").append(intlTableNumber)

        .append(intlTableNumberExt.length() > 0 ? ":" + intlTableNumberExt : "")

        .append("\n\n").append(operationCount).append(" operators")

        .append(!hallInfo.hallSymbol.equals("--") ? " from Hall symbol "  + hallInfo.hallSymbol: "")

        .append(": ");

    for (int i = 0; i < operationCount; i++) {

      sb.append("\n").append(operations[i].xyz);

    }

    sb.append("\n\n").append(hallInfo == null ? "invalid Hall symbol" : hallInfo.dumpInfo());

    sb.append("\n\ncanonical Seitz: ").append((String) info)

        .append("\n----------------------------------------------------\n");

    return sb.toString();

  }

  String getName() {

    return hallSymbol + " ["+hmSymbolFull+"]"; 

  }

  int getLatticeParameter() {

    return latticeParameter;

  }

  char getLatticeCode() {

    return latticeCode;

  }

*/

  String getLatticeDesignation() {   

    return latticeCode + ": " + Translation.getLatticeDesignation(latticeParameter);

  } 

  void setLattice(int latticeParameter) {

    // implication here is that we do NOT have a Hall symbol.

    // so we generate one.

    // The idea here is that we can represent any LATT number

    // as a simple set of rotation/translation operations

    this.latticeParameter = latticeParameter;

    latticeCode = Translation.getLatticeCode(latticeParameter);

    if (latticeParameter > 10) { // use negative

      this.latticeParameter = -Translation.getLatticeIndex(latticeCode);

    }

  }

  ///// private methods /////

 

  private static String[] canonicalSeitzList;

 

  private Object dumpCanonicalSeitzList() {

    if (hallInfo == null)

      hallInfo = new HallInfo(hallSymbol);

    generateAllOperators(null);

    String[] list = new String[operationCount];

    for (int i = 0; i < operationCount; i++)

      list[i] = SymmetryOperation.dumpCanonicalSeitz(operations[i]);

    Arrays.sort(list, 0, operationCount);

    StringBuffer sb = new StringBuffer("\n[");

    for (int i = 0; i < operationCount; i++)

      sb.append(list[i].replace('\t',' ').replace('\n',' ')).append("; ");

    sb.append("]");

    if (index >= spaceGroupDefinitions.length) {

      if (canonicalSeitzList == null) {

      canonicalSeitzList = new String[spaceGroupDefinitions.length];

      for (int i = 0; i < spaceGroupDefinitions.length; i++)

        canonicalSeitzList[i] = (String) spaceGroupDefinitions[i].dumpCanonicalSeitzList();

      }

      String s = sb.toString();

      for (int i = 0; i < spaceGroupDefinitions.length; i++)

        if (canonicalSeitzList[i].indexOf(s) >= 0)

          return spaceGroupDefinitions[i];

    }

    return (index >= 0 && index < spaceGroupDefinitions.length

        ? hallSymbol + " = " : "") + sb.toString();

  }

 

  private final static String dumpAll() {

   StringBuffer sb = new StringBuffer();

   for (int i = 0; i < spaceGroupDefinitions.length; i++)

     sb.append("\n----------------------\n" + spaceGroupDefinitions[i].dumpInfo(null));

   return sb.toString();

  }

 

  private final static String dumpAllSeitz() {

    StringBuffer sb = new StringBuffer();

    for (int i = 0; i < spaceGroupDefinitions.length; i++)

      sb.append("\n").append(spaceGroupDefinitions[i].dumpCanonicalSeitzList());

    return sb.toString();

  }

  

  private void setLattice(char latticeCode, boolean isCentrosymmetric) {

    this.latticeCode = latticeCode;

    latticeParameter = Translation.getLatticeIndex(latticeCode);

    if (!isCentrosymmetric)

      latticeParameter = -latticeParameter;

  }

 

  private final static SpaceGroup createSpaceGroup(String name, boolean doNormalize) {

    name = name.trim();

    SpaceGroup sg = determineSpaceGroup(name);

    HallInfo hallInfo;

    if (sg == null) {

      // try unconventional Hall symbol

      hallInfo = new HallInfo(name);

      if (hallInfo.nRotations > 0) {

        sg = new SpaceGroup("0;--;--;" + name);

        sg.hallInfo = hallInfo;

      } else if (name.indexOf(",") >= 0) {

        sg = new SpaceGroup("0;--;--;--");

        sg.doNormalize = false;

        sg.generateOperatorsFromXyzInfo(name);

      } else {

        sg = null;

      }

    }

    if (sg != null)

      sg.generateAllOperators(null);

    return sg;

  }

 

  Hashtable xyzList = new Hashtable();

  private int addOperation(String xyz0, int opId) {

    if (xyz0 == null || xyz0.length() < 3) {

      xyzList = new Hashtable();

      return -1;

    }

    boolean isSpecial = (xyz0.charAt(0) == '=');

    if (isSpecial) xyz0 = xyz0.substring(1);

    if (xyzList.containsKey(xyz0))

      return ((Integer)xyzList.get(xyz0)).intValue();

    SymmetryOperation symmetryOperation = new SymmetryOperation(doNormalize, opId);

    if (!symmetryOperation.setMatrixFromXYZ(xyz0)) {

      Logger.error("couldn't interpret symmetry operation: " + xyz0);     

      return -1;

    }

    String xyz = symmetryOperation.xyz;

    if (!isSpecial) {

      // ! in character 0 indicates we are using the symop() function and want to be explicit

      if (xyzList.containsKey(xyz))

        return ((Integer)xyzList.get(xyz)).intValue();

      xyzList.put(xyz, new Integer(operationCount));

    }

    if (!xyz.equals(xyz0))

      xyzList.put(xyz0, new Integer(operationCount));

    if (operations == null) {

      operations = new SymmetryOperation[4];

      operationCount = 0;

    }

    if (operationCount == operations.length)

      operations = (SymmetryOperation[]) ArrayUtil.setLength(operations,

          operationCount * 2);

    operations[operationCount++] = symmetryOperation;

    if (Logger.debugging)

        Logger.debug("\naddOperation " + operationCount

        + symmetryOperation.dumpInfo());

    return operationCount - 1;

  }

  private void generateOperatorsFromXyzInfo(String xyzInfo) {

    addOperation(null, 0);

    addSymmetry("x,y,z", 0);

    String[] terms = TextFormat.split(xyzInfo.toLowerCase(), ";");

    for (int i = 0; i < terms.length; i++)

      addSymmetry(terms[i], 0);

  }

 

  /// operation based on Hall name and unit cell parameters only

  private void generateAllOperators(HallInfo h) {

    if (h == null) {

      h = hallInfo;

      if (operationCount > 0)

        return;

      operations = new SymmetryOperation[4];

      operationCount = 0;

      if (hallInfo == null || hallInfo.nRotations == 0)

        h = hallInfo = new HallInfo(hallSymbol);

      setLattice(hallInfo.latticeCode, hallInfo.isCentrosymmetric);

      addOperation(null, 0);

      addSymmetry("x,y,z", 0);

    }

    Matrix4f mat1 = new Matrix4f();

    Matrix4f operation = new Matrix4f();

    Matrix4f[] newOps = new Matrix4f[7];

    for (int i = 0; i < 7; i++)

      newOps[i] = new Matrix4f();

    // prior to Jmol 11.7.36/11.6.23 this was setting nOps within the loop

    // and setIdentity() outside the loop. That caused a multiplication of

    // operations, not a resetting of them each time.

    for (int i = 0; i < h.nRotations; i++) {

      mat1.set(h.rotationTerms[i].seitzMatrix12ths);

      int nRot = h.rotationTerms[i].order;

      // this would iterate int nOps = operationCount;

      newOps[0].setIdentity();

      int nOps = operationCount;

      for (int j = 1; j <= nRot; j++) {

        newOps[j].mul(mat1, newOps[0]);

        newOps[0].set(newOps[j]);

        for (int k = 0; k < nOps; k++) {

          operation.mul(newOps[j], operations[k]);

          SymmetryOperation.normalizeTranslation(operation);

          String xyz = SymmetryOperation.getXYZFromMatrix(operation, true, true, true);

          addSymmetry(xyz, operation);

        }

      }

    }

  }

  private void addSymmetry(String xyz, Matrix4f operation) {

    int iop = addOperation(xyz, 0);

    if (iop < 0)

      return;

    SymmetryOperation symmetryOperation = operations[iop];

    symmetryOperation.set(operation);

  }

  private final static SpaceGroup determineSpaceGroup(String name) {

    return determineSpaceGroup(name, 0f, 0f, 0f, 0f, 0f, 0f, -1);

  }

  private final static SpaceGroup determineSpaceGroup(String name, SpaceGroup sg) {

    return determineSpaceGroup(name, 0f, 0f, 0f, 0f, 0f, 0f, sg.index);

  }

  private final static SpaceGroup determineSpaceGroup(String name,

                                                     float[] notionalUnitcell) {

    if (notionalUnitcell == null)

      return determineSpaceGroup(name, 0f, 0f, 0f, 0f, 0f, 0f, -1);

    return determineSpaceGroup(name, notionalUnitcell[0], notionalUnitcell[1],

        notionalUnitcell[2], notionalUnitcell[3], notionalUnitcell[4],

        notionalUnitcell[5], -1);

  }

  private final static SpaceGroup determineSpaceGroup(String name, float a, float b,

                                                float c, float alpha,

                                                float beta, float gamma,

                                                int lastIndex) {

    int i = determineSpaceGroupIndex(name, a, b, c, alpha, beta, gamma,

        lastIndex);

    return (i >= 0 ? spaceGroupDefinitions[i] : null);

  }

  private final static int determineSpaceGroupIndex(String name, float a,

                                                    float b, float c,

                                                    float alpha, float beta,

                                                    float gamma, int lastIndex) {

     if (lastIndex < 0)

       lastIndex = spaceGroupDefinitions.length;

     name = name.trim().toLowerCase();

     String nameExt = name;

     int i;

     boolean haveExtension = false;

    

     // '_' --> ' '

     name = name.replace('_', ' ');

     // get lattice term to upper case and separated

     if (name.length() >= 2) {

       i = (name.indexOf("-") == 0 ? 2 : 1);

       if (i < name.length() && name.charAt(i) != ' ')

         name = name.substring(0, i) + " " + name.substring(i);

       name = name.substring(0, 2).toUpperCase() + name.substring(2);

     }

    

     // get extension

     String ext = "";

     if ((i = name.indexOf(":")) > 0) {

       ext = name.substring(i + 1);

       name = name.substring(0, i).trim();

       haveExtension = true;

     }

    

     if (!haveExtension && Parser.isOneOf(name, ambiguousNames)) {

       ext = "?";

       haveExtension = true;

     }

    

     // generate spaceless abbreviation "P m m m" --> "Pmmm"  "P 2(1)/c" --> "P21/c"

     String abbr = TextFormat.replaceAllCharacters(name, " ()", "");

     SpaceGroup s;

     // exact matches:

     // Hall symbol

     if (!haveExtension)

       for (i = lastIndex; --i >= 0;) {

         s = spaceGroupDefinitions[i];

         if (s.hallSymbol.equals(name))

           return i;

       }

     // Full intl table entry, including :xx

     for (i = lastIndex; --i >= 0;) {

       s = spaceGroupDefinitions[i];

       if (s.intlTableNumberFull.equals(nameExt))

         return i;

     }

     // Full H-M symbol, including :xx

     // BUT some on the list presume defaults. The way to finesse this is

     // to add ":?" to a space group name to force axis ambiguity check

     for (i = lastIndex; --i >= 0;) {

       s = spaceGroupDefinitions[i];

       if (s.hmSymbolFull.equals(nameExt))

         return i;

     }

     // alternative, but unique H-M symbol, specifically for F m 3 m/F m -3 m type

     for (i = lastIndex; --i >= 0;) {

       s = spaceGroupDefinitions[i];

       if (s.hmSymbolAlternative != null

           && s.hmSymbolAlternative.equals(nameExt))

         return i;

     }

     // Abbreviated H-M with intl table :xx

     if (haveExtension) // P2/m:a     

       for (i = lastIndex; --i >= 0;) {

         s = spaceGroupDefinitions[i];

         if (s.hmSymbolAbbr.equals(abbr) && s.intlTableNumberExt.equals(ext))

           return i;

       }

     // shortened -- not including " 1 " terms

     if (haveExtension) // P2/m:a     

       for (i = lastIndex; --i >= 0;) {

         s = spaceGroupDefinitions[i];

         if (s.hmSymbolAbbrShort.equals(abbr)

             && s.intlTableNumberExt.equals(ext))

           return i;

       }

     // unique axis, cell and origin options with H-M abbr

     char uniqueAxis = determineUniqueAxis(a, b, c, alpha, beta, gamma);

     if (!haveExtension || ext.charAt(0) == '?')

       // no extension or unknown extension, so we look for unique axis

       for (i = lastIndex; --i >= 0;) {

         s = spaceGroupDefinitions[i];

         if (s.hmSymbolAbbr.equals(abbr) || s.hmSymbolAbbrShort.equals(abbr)) {

           switch (s.ambiguityType) {

           case '\0':

             return i;

           case 'a':

             if (s.uniqueAxis == uniqueAxis || uniqueAxis == '\0')

               return i;

             break;

           case 'o':

             if (ext.length() == 0) {

               if (s.hmSymbolExt.equals("2"))

                 return i; // defaults to origin:2

             } else if (s.hmSymbolExt.equals(ext))

               return i;

             break;

           case 't':

             if (ext.length() == 0) {

               if (s.axisChoice == 'h')

                 return i; //defaults to hexagonal

             } else if ((s.axisChoice + "").equals(ext))

               return i;

             break;

           }

         }

       }

     // inexact just the number; no extension indicated

     if (ext.length() == 0)

       for (i = lastIndex; --i >= 0;) {

         s = spaceGroupDefinitions[i];

         if (s.intlTableNumber.equals(nameExt))

           return i;

       }

     return -1;

   }

  

   private final static char determineUniqueAxis(float a, float b, float c, float alpha, float beta, float gamma) {

     if (a == b)

       return (b == c ? '\0' : 'c');

     if (b == c)

       return 'a';

     if (c == a)

       return 'b';

     if (alpha == beta)

       return (beta == gamma ? '\0' : 'c');

     if (beta == gamma)

       return 'a';

     if (gamma == alpha)

       return 'b';

     return '\0';

   }

  ///  data  ///

  private static int sgIndex = -1;

 

  private static String ambiguousNames = "";

  private static String lastInfo = "";

 

  private void buildSpaceGroup(String cifLine) {

    index = ++sgIndex;

    String[] terms = TextFormat.split(cifLine.toLowerCase(), ";");

    String[] parts;

    intlTableNumberFull = terms[0].trim(); // International Table Number :

                                           // options

    parts = TextFormat.split(intlTableNumberFull, ":");

    intlTableNumber = parts[0];

    intlTableNumberExt = (parts.length == 1 ? "" : parts[1]);

    ambiguityType = '\0';

    if (intlTableNumberExt.length() > 0) {

      String term = intlTableNumberExt;

      if (term.startsWith("-"))

        term = term.substring(1);

      if (term.equals("h") || term.equals("r")) {

        ambiguityType = 't';

        axisChoice = intlTableNumberExt.charAt(0);

      } else if (intlTableNumberExt.startsWith("1")

          || intlTableNumberExt.startsWith("2")) {

        ambiguityType = 'o';

        // originChoice = intlTableNumberExt.charAt(0);

      } else if (intlTableNumberExt.length() <= 2) { // :a or :b3

        ambiguityType = 'a';

        uniqueAxis = intlTableNumberExt.charAt(0);

        // if (intlTableNumberExt.length() == 2)

        // cellChoice = intlTableNumberExt.charAt(1);

      }

    }

    /* schoenfliesSymbol = terms[1] */

    hmSymbolFull = Character.toUpperCase(terms[2].charAt(0))

        + terms[2].substring(1);

    parts = TextFormat.split(hmSymbolFull, ":");

    hmSymbol = parts[0];

    hmSymbolExt = (parts.length == 1 ? "" : parts[1]);

    int pt = hmSymbol.indexOf(" -3");

    if (pt >= 1)

      if ("admn".indexOf(hmSymbol.charAt(pt - 1)) >= 0) {

        hmSymbolAlternative = (hmSymbol.substring(0, pt) + " 3"

            + hmSymbol.substring(pt + 3)).toLowerCase();

      }

    hmSymbolAbbr = TextFormat.simpleReplace(hmSymbol, " ", "");

    hmSymbolAbbrShort = TextFormat.simpleReplace(hmSymbol, " 1", "");

    hmSymbolAbbrShort = TextFormat.simpleReplace(hmSymbolAbbrShort, " ", "");

    hallSymbol = terms[3];

    if (hallSymbol.length() > 1)

      hallSymbol = hallSymbol.substring(0, 2).toUpperCase() + hallSymbol.substring(2);

    String info = intlTableNumber + hallSymbol;

    if (intlTableNumber.charAt(0) != '0' && lastInfo.equals(info))

      ambiguousNames += hmSymbol + ";";

    lastInfo = info;

  //      + hmSymbol + "\t" + hmSymbolAbbr + "\t" + hmSymbolAbbrShort + "\t"

    //    + hallSymbol);

  }

 

  private final static SpaceGroup[] spaceGroupDefinitions = {

    new SpaceGroup("1;c1^1;p 1;p 1")

    , new SpaceGroup("2;ci^1;p -1;-p 1")

    , new SpaceGroup("3:b;c2^1;p 1 2 1;p 2y") //full name

    , new SpaceGroup("3:b;c2^1;p 2;p 2y")

    , new SpaceGroup("3:c;c2^1;p 1 1 2;p 2")

    , new SpaceGroup("3:a;c2^1;p 2 1 1;p 2x")

    , new SpaceGroup("4:b;c2^2;p 1 21 1;p 2yb") //full name

    , new SpaceGroup("4:b;c2^2;p 21;p 2yb")

    , new SpaceGroup("4:b*;c2^2;p 1 21 1*;p 2y1") //nonstandard

    , new SpaceGroup("4:c;c2^2;p 1 1 21;p 2c")

    , new SpaceGroup("4:c*;c2^2;p 1 1 21*;p 21") //nonstandard

    , new SpaceGroup("4:a;c2^2;p 21 1 1;p 2xa")

    , new SpaceGroup("4:a*;c2^2;p 21 1 1*;p 2x1") //nonstandard

    , new SpaceGroup("5:b1;c2^3;c 1 2 1;c 2y") //full name

    , new SpaceGroup("5:b1;c2^3;c 2;c 2y")

    , new SpaceGroup("5:b2;c2^3;a 1 2 1;a 2y")

    , new SpaceGroup("5:b3;c2^3;i 1 2 1;i 2y")

    , new SpaceGroup("5:c1;c2^3;a 1 1 2;a 2")

    , new SpaceGroup("5:c2;c2^3;b 1 1 2;b 2")

    , new SpaceGroup("5:c3;c2^3;i 1 1 2;i 2")

    , new SpaceGroup("5:a1;c2^3;b 2 1 1;b 2x")

    , new SpaceGroup("5:a2;c2^3;c 2 1 1;c 2x")

    , new SpaceGroup("5:a3;c2^3;i 2 1 1;i 2x")

    , new SpaceGroup("6:b;cs^1;p 1 m 1;p -2y") //full name

    , new SpaceGroup("6:b;cs^1;p m;p -2y")

    , new SpaceGroup("6:c;cs^1;p 1 1 m;p -2")

    , new SpaceGroup("6:a;cs^1;p m 1 1;p -2x")

    , new SpaceGroup("7:b1;cs^2;p 1 c 1;p -2yc") //full name

    , new SpaceGroup("7:b1;cs^2;p c;p -2yc")

    , new SpaceGroup("7:b2;cs^2;p 1 n 1;p -2yac") //full name

    , new SpaceGroup("7:b2;cs^2;p n;p -2yac")

    , new SpaceGroup("7:b3;cs^2;p 1 a 1;p -2ya") //full name

    , new SpaceGroup("7:b3;cs^2;p a;p -2ya")

    , new SpaceGroup("7:c1;cs^2;p 1 1 a;p -2a")

    , new SpaceGroup("7:c2;cs^2;p 1 1 n;p -2ab")

    , new SpaceGroup("7:c3;cs^2;p 1 1 b;p -2b")

    , new SpaceGroup("7:a1;cs^2;p b 1 1;p -2xb")

    , new SpaceGroup("7:a2;cs^2;p n 1 1;p -2xbc")

    , new SpaceGroup("7:a3;cs^2;p c 1 1;p -2xc")

    , new SpaceGroup("8:b1;cs^3;c 1 m 1;c -2y") //full name

    , new SpaceGroup("8:b1;cs^3;c m;c -2y")

    , new SpaceGroup("8:b2;cs^3;a 1 m 1;a -2y")

    , new SpaceGroup("8:b3;cs^3;i 1 m 1;i -2y") //full name

    , new SpaceGroup("8:b3;cs^3;i m;i -2y")

    , new SpaceGroup("8:c1;cs^3;a 1 1 m;a -2")

    , new SpaceGroup("8:c2;cs^3;b 1 1 m;b -2")

    , new SpaceGroup("8:c3;cs^3;i 1 1 m;i -2")

    , new SpaceGroup("8:a1;cs^3;b m 1 1;b -2x")

    , new SpaceGroup("8:a2;cs^3;c m 1 1;c -2x")

    , new SpaceGroup("8:a3;cs^3;i m 1 1;i -2x")

    , new SpaceGroup("9:b1;cs^4;c 1 c 1;c -2yc") //full name

    , new SpaceGroup("9:b1;cs^4;c c;c -2yc")

    , new SpaceGroup("9:b2;cs^4;a 1 n 1;a -2yab")

    , new SpaceGroup("9:b3;cs^4;i 1 a 1;i -2ya")

    , new SpaceGroup("9:-b1;cs^4;a 1 a 1;a -2ya")

    , new SpaceGroup("9:-b2;cs^4;c 1 n 1;c -2yac")

    , new SpaceGroup("9:-b3;cs^4;i 1 c 1;i -2yc")

    , new SpaceGroup("9:c1;cs^4;a 1 1 a;a -2a")

    , new SpaceGroup("9:c2;cs^4;b 1 1 n;b -2ab")

    , new SpaceGroup("9:c3;cs^4;i 1 1 b;i -2b")

    , new SpaceGroup("9:-c1;cs^4;b 1 1 b;b -2b")

    , new SpaceGroup("9:-c2;cs^4;a 1 1 n;a -2ab")

    , new SpaceGroup("9:-c3;cs^4;i 1 1 a;i -2a")

    , new SpaceGroup("9:a1;cs^4;b b 1 1;b -2xb")

    , new SpaceGroup("9:a2;cs^4;c n 1 1;c -2xac")

    , new SpaceGroup("9:a3;cs^4;i c 1 1;i -2xc")

    , new SpaceGroup("9:-a1;cs^4;c c 1 1;c -2xc")

    , new SpaceGroup("9:-a2;cs^4;b n 1 1;b -2xab")

    , new SpaceGroup("9:-a3;cs^4;i b 1 1;i -2xb")

    , new SpaceGroup("10:b;c2h^1;p 1 2/m 1;-p 2y") //full name

    , new SpaceGroup("10:b;c2h^1;p 2/m;-p 2y")

    , new SpaceGroup("10:c;c2h^1;p 1 1 2/m;-p 2")

    , new SpaceGroup("10:a;c2h^1;p 2/m 1 1;-p 2x")

    , new SpaceGroup("11:b;c2h^2;p 1 21/m 1;-p 2yb") //full name

    , new SpaceGroup("11:b;c2h^2;p 21/m;-p 2yb")

    , new SpaceGroup("11:b*;c2h^2;p 1 21/m 1*;-p 2y1") //nonstandard

    , new SpaceGroup("11:c;c2h^2;p 1 1 21/m;-p 2c")

    , new SpaceGroup("11:c*;c2h^2;p 1 1 21/m*;-p 21") //nonstandard

    , new SpaceGroup("11:a;c2h^2;p 21/m 1 1;-p 2xa")

    , new SpaceGroup("11:a*;c2h^2;p 21/m 1 1*;-p 2x1") //nonstandard

    , new SpaceGroup("12:b1;c2h^3;c 1 2/m 1;-c 2y") //full name

    , new SpaceGroup("12:b1;c2h^3;c 2/m;-c 2y")

    , new SpaceGroup("12:b2;c2h^3;a 1 2/m 1;-a 2y")

    , new SpaceGroup("12:b3;c2h^3;i 1 2/m 1;-i 2y") //full name

    , new SpaceGroup("12:b3;c2h^3;i 2/m;-i 2y")

    , new SpaceGroup("12:c1;c2h^3;a 1 1 2/m;-a 2")

    , new SpaceGroup("12:c2;c2h^3;b 1 1 2/m;-b 2")

    , new SpaceGroup("12:c3;c2h^3;i 1 1 2/m;-i 2")

    , new SpaceGroup("12:a1;c2h^3;b 2/m 1 1;-b 2x")

    , new SpaceGroup("12:a2;c2h^3;c 2/m 1 1;-c 2x")

    , new SpaceGroup("12:a3;c2h^3;i 2/m 1 1;-i 2x")

    , new SpaceGroup("13:b1;c2h^4;p 1 2/c 1;-p 2yc") //full name

    , new SpaceGroup("13:b1;c2h^4;p 2/c;-p 2yc")

    , new SpaceGroup("13:b2;c2h^4;p 1 2/n 1;-p 2yac") //full name

    , new SpaceGroup("13:b2;c2h^4;p 2/n;-p 2yac")

    , new SpaceGroup("13:b3;c2h^4;p 1 2/a 1;-p 2ya") //full name

    , new SpaceGroup("13:b3;c2h^4;p 2/a;-p 2ya")

    , new SpaceGroup("13:c1;c2h^4;p 1 1 2/a;-p 2a")

    , new SpaceGroup("13:c2;c2h^4;p 1 1 2/n;-p 2ab")

    , new SpaceGroup("13:c3;c2h^4;p 1 1 2/b;-p 2b")

    , new SpaceGroup("13:a1;c2h^4;p 2/b 1 1;-p 2xb")

    , new SpaceGroup("13:a2;c2h^4;p 2/n 1 1;-p 2xbc")

    , new SpaceGroup("13:a3;c2h^4;p 2/c 1 1;-p 2xc")

    , new SpaceGroup("14:b1;c2h^5;p 1 21/c 1;-p 2ybc") //full name

    , new SpaceGroup("14:b1;c2h^5;p 21/c;-p 2ybc")

    , new SpaceGroup("14:b2;c2h^5;p 1 21/n 1;-p 2yn") //full name

    , new SpaceGroup("14:b2;c2h^5;p 21/n;-p 2yn")

    , new SpaceGroup("14:b3;c2h^5;p 1 21/a 1;-p 2yab") //full name

    , new SpaceGroup("14:b3;c2h^5;p 21/a;-p 2yab")

    , new SpaceGroup("14:c1;c2h^5;p 1 1 21/a;-p 2ac")

    , new SpaceGroup("14:c2;c2h^5;p 1 1 21/n;-p 2n")

    , new SpaceGroup("14:c3;c2h^5;p 1 1 21/b;-p 2bc")

    , new SpaceGroup("14:a1;c2h^5;p 21/b 1 1;-p 2xab")

    , new SpaceGroup("14:a2;c2h^5;p 21/n 1 1;-p 2xn")

    , new SpaceGroup("14:a3;c2h^5;p 21/c 1 1;-p 2xac")

    , new SpaceGroup("15:b1;c2h^6;c 1 2/c 1;-c 2yc") //full name

    , new SpaceGroup("15:b1;c2h^6;c 2/c;-c 2yc")

    , new SpaceGroup("15:b2;c2h^6;a 1 2/n 1;-a 2yab")

    , new SpaceGroup("15:b3;c2h^6;i 1 2/a 1;-i 2ya") //full name

    , new SpaceGroup("15:b3;c2h^6;i 2/a;-i 2ya")

    , new SpaceGroup("15:-b1;c2h^6;a 1 2/a 1;-a 2ya")

    , new SpaceGroup("15:-b2;c2h^6;c 1 2/n 1;-c 2yac") //full name

    , new SpaceGroup("15:-b2;c2h^6;c 2/n;-c 2yac")

    , new SpaceGroup("15:-b3;c2h^6;i 1 2/c 1;-i 2yc") //full name

    , new SpaceGroup("15:-b3;c2h^6;i 2/c;-i 2yc")

    , new SpaceGroup("15:c1;c2h^6;a 1 1 2/a;-a 2a")

    , new SpaceGroup("15:c2;c2h^6;b 1 1 2/n;-b 2ab")

    , new SpaceGroup("15:c3;c2h^6;i 1 1 2/b;-i 2b")

    , new SpaceGroup("15:-c1;c2h^6;b 1 1 2/b;-b 2b")

    , new SpaceGroup("15:-c2;c2h^6;a 1 1 2/n;-a 2ab")

    , new SpaceGroup("15:-c3;c2h^6;i 1 1 2/a;-i 2a")

    , new SpaceGroup("15:a1;c2h^6;b 2/b 1 1;-b 2xb")

    , new SpaceGroup("15:a2;c2h^6;c 2/n 1 1;-c 2xac")

    , new SpaceGroup("15:a3;c2h^6;i 2/c 1 1;-i 2xc")