gims 1.4.0__py3-none-any.whl

gims/__init__.py

@@ -0,0 +1,231 @@
+import os
+import sys
+import json
+import tarfile
+import tempfile
+import webbrowser
+from io import BytesIO
+from pathlib import Path
+from threading import Timer
+
+from flask import Flask, request, Response, redirect, url_for, session, abort, send_from_directory, Blueprint
+
+from gims.prepare_input import generate_slab, terminate_slab
+
+
+# The main.py file sets up the Flask app and handles the client requests.
+# ----------------- Set up the internal paths --------------------------
+
+if getattr(sys, "frozen", False) and hasattr(sys, '_MEIPASS'):
+    # Offline version
+    # noinspection PyProtectedMember
+    static_folder = os.path.join(sys._MEIPASS, "static")
+    # noinspection PyProtectedMember
+    SPECIES_DIR = os.path.join(sys._MEIPASS, "static/data/species_defaults/")
+    # print(f'I am frozen!: {static_folder}')
+    app = Flask(__name__, static_folder=static_folder, static_url_path="/static")
+else:
+    # Server version
+    SPECIES_DIR = "static/data/species_defaults/"
+    app = Flask(__name__)
+
+if os.getenv("GIMS_BUILD_SISSO_WORKFLOW", 'False').lower() in ('true', '1', 't'):
+    from sisso_active_learning_workflow.app import create_sisso_activete_learning_workflow_app
+    import inspect
+    assets_folder = Path(inspect.getfile(create_sisso_activete_learning_workflow_app)).parent / "assets"
+    @app.route('/dash/assets/<path:filename>')
+    def custom_static(filename):
+        return send_from_directory(str(assets_folder), filename)
+    app_sisso_workflow = create_sisso_activete_learning_workflow_app(app, "/dash/")
+
+app.secret_key = os.urandom(16)
+app.config.update(
+    SESSION_COOKIE_SECURE=True,
+    SESSION_COOKIE_SAMESITE='Lax'
+)
+# ----------------- Client requests start here --------------------------
+
+
+@app.route("/")
+def index():
+    return redirect(url_for("static", filename="index.html"))
+
+
+@app.route("/parse-geometry-file", methods=["GET", "POST"])
+def parse_geometry_file():
+    """Captures client request to parse structure data.
+
+    Expects a text file either of unknown
+    format (then the ASE auto-detection is used) or of known format (then `ase.io.read`
+    for that particular format is used). If parsed successfully, returns the structure
+    data in json format. Otherwise, returns error message.
+    """
+    from gims.prepare_input import get_json_structure
+
+    if request.method == "POST":
+        json_structure = get_json_structure(request.files, session)
+        return Response(json_structure, mimetype="application/json")
+
+
+@app.route("/update-structure-info", methods=["GET", "POST"])
+def update_structure_info():
+    """Captures client request to update the supportive information (e.g. chemical
+    formula, number of atoms, symmetry information for periodic structures, etc.)
+
+    Expects structure data in json format. Returns a json structure data with updated
+    supportive information.
+    """
+    from gims.prepare_input import update_json_structure
+
+    if request.method == "POST":
+        struct_data = json.loads(request.data)
+        if "symThresh" in struct_data:
+            session["symThresh"] = float(struct_data.pop("symThresh"))
+        # update struct_data with unknown type
+        struct_data["positions"] = [dict(**d, species="X") if "species" not in d else d
+                                    for d in struct_data["positions"]]
+        json_structure = update_json_structure(struct_data, session)
+        return Response(json_structure, mimetype="application/json")
+
+
+@app.route("/generate-control-in", methods=["GET", "POST"])
+def generate_control_in():
+    """Captures client request to generate input file(s) with numerical parameters and
+    run-time choices (including basis set information).
+
+    Expects a json file with the specified numerical parameters. Returns a tar-ball
+    with the corresponding input file(s).
+    """
+    from gims.prepare_input import get_input_files
+    if request.method == "POST":
+        species_dir = os.path.join(app.root_path, SPECIES_DIR)
+        return get_input_files(request.data, species_dir, session)
+
+
+@app.route("/get-download-info", methods=["POST"])
+def get_download_info():
+    """Request download information before actual input files are downloaded.
+
+    Currently, this function is used to summarize the information about the
+    automatically generated band path. However, this function can be generalized
+    for any future workflow.
+    """
+    from gims.prepare_input import get_download_info
+
+    if request.method == "POST":
+        species_dir = os.path.join(app.root_path, SPECIES_DIR)
+        return get_download_info(request.data, species_dir, session)
+
+
+@app.route("/get-standard-cell", methods=["POST"])
+def get_standard_cell():
+    """Generate standardized structure (either primitive or conventional).
+
+    Captures client request to generate the primitive structure. Expects structure
+    data in json format and returns the primitive structure, if current structure is
+    not primitive. If the current structure is primitive, return message.
+    """
+    from gims.prepare_input import primitive_cell, conventional_cell
+
+    struct_data = json.loads(request.data)
+    if "symThresh" in struct_data:
+        session["symThresh"] = float(struct_data.pop("symThresh"))
+    is_primitive = struct_data.pop("is_primitive", True)
+    return primitive_cell(struct_data, session) if is_primitive else conventional_cell(struct_data, session)
+
+
+@app.route('/upload-workflow', methods=['POST'])
+def upload_workflow_output():
+    """ Unpacks and prepares the data for the post-processing on the client side
+
+    Returns: prepared data
+    """
+    files = []
+    f = tarfile.open(fileobj=BytesIO(request.data), mode='r:gz')
+    for f_name in f.getnames():
+        file_handle = f.extractfile(f_name)
+        if file_handle is not None:
+            try:
+                files.append({"name": f_name, "content": file_handle.read().decode('utf-8')})
+            except UnicodeDecodeError:
+                # a binary file is found in the archive, skip for now
+                pass
+    return json.dumps(files)
+
+
+@app.route("/get-slab", methods=["POST"])
+def get_slab():
+    """Generates a slab from a given data.
+    """
+    if request.method == "POST":
+        try:
+            return generate_slab(request.data, session)
+        except KeyError:  # no slab_data in request
+            return abort(400)
+
+
+@app.route("/terminate-slab", methods=["POST"])
+def term_slab():
+    """Terminates a slab from a given data.
+    """
+    if request.method == "POST":
+        return terminate_slab(request.data, session)
+
+
+@app.route("/generate-workflow", methods=["POST"])
+def generate_workflow():
+    from gims.workflow import Workflow
+    workflow = Workflow(json.loads(request.data))
+    with tempfile.TemporaryDirectory() as temp_dir:
+        tar_dir, tar_file, info = workflow.run(temp_dir)
+        if tar_file == "FileNotFoundError":
+            response = "FileNotFoundError"
+        else:
+            print("I am sending the tar", tar_dir, tar_file)
+            response = send_from_directory(tar_dir, tar_file, as_attachment=True)
+    return response
+
+
+@app.route("/get-bz-vertices", methods=["POST"])
+def get_bz_vertices():
+    """Captures client request to calculate Brillouin Zone for a periodic structure.
+
+    Expects the lattice vectors in json format (`[[lat_v1],[lat_v2],[lat_v3]]`).
+    Returns a dictionary of vertices and band paths needed for drawing the BZ and the
+    path along the high-symmetry points.
+    """
+    from gims.bz_utilities import calculate_bz_from_cell_json
+
+    if request.method == "POST":
+        return calculate_bz_from_cell_json(request.data)
+
+
+@app.route("/get-bases", methods=["GET"])
+def get_available_bases():
+    """Returns a JSON with available basis directories for a given code. Should accept code name in the request"""
+    code_name = request.args.get('code', None)
+    if code_name is None:
+        return "Code not found", 400
+    species_dir = Path(__file__).parent / SPECIES_DIR / code_name
+    if not species_dir.exists():
+        return "Basis directory not found", 400
+    return json.dumps(os.listdir(species_dir))
+
+
+HOST = '127.0.0.1'
+PORT = 5000
+
+
+def open_browser():
+    """Opens a browser with GIMS in it"""
+    webbrowser.open_new(f'http://{HOST}:{PORT}/')
+
+
+def main():
+    """Main flask application — runs the dev server on http://localhost:5000"""
+    Timer(1, open_browser).start()
+    app.run(host=HOST, port=PORT)
+
+
+if __name__ == "__main__":
+    main()

gims/__main__.py

@@ -0,0 +1,3 @@
+from gims import main
+
+main()

gims/bz_utilities.py

@@ -0,0 +1,49 @@
+import numpy as np
+from scipy.spatial import Voronoi
+import json
+import itertools
+from ase.cell import Cell
+from ase.dft.kpoints import resolve_kpt_path_string
+
+
+def calculate_bz_from_cell(cell):
+    """Calculates the Brillouin Zone vertices and path of high-symmetry points.
+
+    Parameters:
+
+    cell: numpy array
+        Three lattice vectors arranged as [[lat_v1],[lat_v2],[lat_v3]]
+    """
+    corners = np.array(list(itertools.product([-2, -1, 0, 1, 2], repeat=3)))
+    points = np.dot(corners, cell)
+    vor = Voronoi(points)
+    bz_vertices = []
+    for r in vor.ridge_dict:
+        # This is not the general solution. It might happen that for very skewed cells
+        # that next-next-nearest neighbors are building the faces of the BZ.
+        if r[0] == 62 or r[1] == 62:
+            bz_vertices.append([list(vor.vertices[i]) for i in vor.ridge_dict[r]])
+
+    cell_o = Cell(2 * np.pi * Cell(cell).reciprocal())
+    bp = cell_o.bandpath()
+    # print(cell.get_bravais_lattice())
+    r_kpts = resolve_kpt_path_string(bp.path, bp.special_points)
+    segments = []
+    for labels, coords in zip(*r_kpts):
+        segments.append([labels, coords.tolist()])
+    return {"vertices": bz_vertices, "path": segments}
+
+
+def calculate_bz_from_cell_json(cell_json):
+    """Convert lattice vectors (`cell`) in json format to numpy array and return
+    Brillouin zone results in json format.
+
+    Parameters:
+
+    cell: json array
+        Three lattice vectors arranged as [[lat_v1],[lat_v2],[lat_v3]]
+    """
+    cell = np.array(json.loads(cell_json))
+    bz_vertices = calculate_bz_from_cell(cell)
+    # print(bz_vertices)
+    return json.dumps(bz_vertices)

gims/cif.py

@@ -0,0 +1,160 @@
+""" The CIF reader and preprocessor (uses gemmi package)
+"""
+import re
+from io import TextIOWrapper, BufferedReader
+
+import numpy as np
+from ase.data import chemical_symbols
+from gemmi.cif import read_string, as_number, as_string
+from werkzeug.datastructures import FileStorage
+
+from gims.data import hm_groups
+
+
+__all__ = ['CifPreprocessor', ]
+
+
+class CifPreprocessor:
+    def __init__(self, cif_file):
+        """ A class that reads and preprocesses cif files
+        Args:
+            cif_file: a file name or object
+        """
+
+        self._block = None
+        self.lines = None
+        self.symbols = None
+        self.coords = None
+        self.cell_pars = None
+        self.space_group = None
+
+        if isinstance(cif_file, TextIOWrapper):  # file object got with open
+            self.lines = cif_file.read()
+        elif isinstance(cif_file, (BufferedReader, FileStorage)):  # 1 - file object got with open(rb0
+            self.lines = cif_file.read().decode('utf-8')
+        else:
+            with open(cif_file) as f:
+                self.lines = f.read()
+
+        cif = read_string(self.lines)
+        try:
+            # stands almost for every case
+            self._block = cif.sole_block()
+        except RuntimeError:
+            # Springer Materials
+            for block in cif:
+                if 'standardized_unitcell' in block.name:
+                    self._block = block
+                    break
+        except IndexError:
+            raise ValueError('Did not find block with data in the given CIF file')
+        if self._block is None:
+            raise ValueError('Did not find block with data in the given CIF file')
+
+    def save(self, save_name):
+        """ Checks cif file for errors and saves it to a file
+        Args:
+            save_name: a name of the file to save cif to
+        """
+        self._parse()
+        # if everything is fine, then go ahead with saving
+        hm_re = re.compile(r"_symmetry_space_group_name_H-M +'?(.*)\b")
+        hm_match = hm_re.search(self.lines)
+        if hm_match is not None:
+            given_hm = hm_match.group(1)
+            hm = re.sub(r"[()_ ]", r"", given_hm)
+            if hm in hm_groups:
+                print(given_hm, hm_groups[hm])
+                self.lines = self.lines.replace(given_hm, hm_groups[hm])
+        with open(save_name, 'w') as f:
+            f.write(self.lines)
+
+    def _parse(self):
+        """ Checks CIF block for errors, and parses it
+        """
+        # trying to parse the file and return meaningful error in case of failure
+        # cell key-value pairs
+        cell_kwds = ['length_a', 'length_b', 'length_c', 'angle_alpha', 'angle_beta', 'angle_gamma']
+        # symmetry key-value pairs
+        symm_kwds = ['space_group_name_h-m', 'int_tables_number']
+        sg_kwds = ['group_name_h-m_alt', 'it_number']
+        # given in a loop
+        atom_site_kwds = ['label', 'type_symbol', '?wyckoff_symbol', '?symmetry_multiplicity', '?wyckoff_label',
+                          '?fract_x', '?cartn_x', '?fract_y', '?cartn_y', '?fract_z', '?cartn_z']
+
+        try:
+            self.cell_pars = [as_number(self._block.find_value(f'_cell_{kwd}')) for kwd in cell_kwds]
+        except TypeError as e:
+            raise ValueError('Some cell parameters are missing in the given CIF file') from e
+
+        symm_pars = [self._block.find_value(f'_symmetry_{kwd}') for kwd in symm_kwds]
+        sg_pars = [self._block.find_value(f'_space_group_{kwd}') for kwd in sg_kwds]
+
+        if all([x is None for x in symm_pars + sg_pars]):
+            raise ValueError('Symmetry information is missing from the given CIF file')
+
+        atoms_table = self._block.find('_atom_site_', atom_site_kwds)
+        existing_site_kwds = [kwd[1:] if kwd.startswith('?') else kwd for i, kwd in enumerate(atom_site_kwds)
+                              if atoms_table.has_column(i)]
+
+        is_fractional = sum(['fract' in x for x in existing_site_kwds]) == 3
+        is_cartesian = sum(['cartn' in x for x in existing_site_kwds]) == 3
+
+        if is_fractional == is_cartesian:
+            raise ValueError('A mix of fractional and cartesian coordinates in CIF file is not implemented')
+        if is_cartesian:
+            raise ValueError('Cartesian coordinates in CIF files are not yet implemented')
+
+        try:
+            labels_idx = existing_site_kwds.index('label')
+            symbols_idx = existing_site_kwds.index('type_symbol')
+        except ValueError as e:
+            raise ValueError('No atomic labels or types found in the given CIF file') from e
+
+        atoms_table = self._block.find('_atom_site_', existing_site_kwds)
+
+        self.symbols = _parse_atom_symbols([as_string(x) for x in atoms_table.column(labels_idx)],
+                                      [as_string(x) for x in atoms_table.column(symbols_idx)])
+        self.space_group = _parse_symmetries(symm_pars, sg_pars)
+        # change setting! (maybe employ the code from ASE?)
+        coords = [[as_number(x) for x in atoms_table.column(i)]
+                  for i, kwd in enumerate(existing_site_kwds) if 'fract' in kwd or 'cartn' in kwd
+                  ]
+        self.coords = np.array(coords).T
+
+
+def _parse_atom_symbols(labels, types):
+    # find atomic symbols (won't work for something like 'boron', which is valid, but I have not met
+    # such a type)
+    types_symbols = [re.findall('[A-Z][a-z]?', t) for t in types]
+    # check for partial occupancies
+    if any([len(s) > 1 for s in types_symbols]):
+        raise ValueError('Partial occupancies met in the given CIF file')
+    # check for atomic types to be present in the Periodic table
+    if any([len(s) < 1 for s in types_symbols]) or any([any([s_i not in chemical_symbols for s_i in s])
+                                                        for s in types_symbols]):
+        raise ValueError('Unknown atomic types met in the given CIF file')
+    # check for labels to be consistent with types (should give a warning though)
+    types_symbols = [s_i for s in types_symbols for s_i in s]
+    if len(labels) != len(types_symbols):
+        raise ValueError('The number of labels differs with the number of types in the given CIF file')
+    return types_symbols
+
+
+def _parse_symmetries(symmetry_params, sg_params):
+    # returns the space group number if it's given
+    sg, sg_alt = symmetry_params[1], sg_params[1]
+    if sg is not None and sg_alt is not None and sg != sg_alt:
+        raise ValueError('Inconsistent space group numbers given in a CIF file')
+    sg = sg if sg is not None else sg_alt
+    if sg is not None:
+        return as_number(sg)
+    # if space group is not given, then check the H-M notation
+    hm, hm_alt = symmetry_params[0], sg_params[0]
+    if hm is not None and hm_alt is not None and hm != hm_alt:
+        raise ValueError('Inconsistent Hermann-Mauguin groups given in a CIF file')
+    hm = as_string(hm) if hm is not None else as_string(hm_alt)
+    # check the H-M notation
+    if hm.replace(" ", "") in hm_groups:
+        return hm_groups[hm.replace(" ", "")]
+    return hm

gims/constants.py

@@ -0,0 +1 @@
+sym_thresh = 0.00001