NANOLABO/python/nanolabo.py

# -*- coding: utf-8 -*-

import os, threading, time, sys
if os.name == "nt":
    import win32pipe, win32file
if sys.version_info[0] < 3:
    import codecs

_pipe_out = None
_pipe_out_result = None
_nanolabo_dir = None
_debug = False
_echo = False

def write_pipe_in(input):
    """Write input string to pipe nanolaboIn"""
    if _echo or _debug: print(input)

    if sys.version_info[0] < 3:
        open2 = codecs.open
    else:
        open2 = open

    for i in range(30):
        try:
            if os.name == "nt":
                handle = open2(r'\\.\pipe\nanolaboIn', 'w', buffering=1, encoding='utf-8')
            elif os.name == "posix" and os.path.exists('/tmp/nanolaboIn'):
                handle = open2('/tmp/nanolaboIn', 'w', buffering=1, encoding='utf-8')
            break
        except IOError as e:
            if e.errno == 2:
                time.sleep(0.1)
                continue
            else:
                print("I/O error({0}): {1}".format(e.errno, e.strerror))
                raise e
    else:
        print("error: failed to open pipe nanolaboIn")

    try:
        if sys.version_info[0] < 3 and type(input) is str:
            handle.write(unicode(input, sys.stdin.encoding))
        else:
            handle.write(input)
        handle.flush()
        handle.close()
    except IOError as e:
        print("I/O error({0}): {1}".format(e.errno, e.strerror))
        raise e
    except Exception as e:
        print("error: failed to write to pipe nanolaboIn")
        raise e

def _create_pipe_out():
    global _pipe_out
    global _debug
    if _pipe_out is not None:
        if _debug: print("use existing pipe nanolaboOut")
        if os.name == "nt":
            win32pipe.DisconnectNamedPipe(_pipe_out)
            win32pipe.ConnectNamedPipe(_pipe_out, None)
        return

    try:
        if os.name == "nt":
            _pipe_out = win32pipe.CreateNamedPipe(
                r'\\.\pipe\nanolaboOut',
                win32pipe.PIPE_ACCESS_INBOUND,
                win32pipe.PIPE_TYPE_BYTE | win32pipe.PIPE_WAIT,
                1, 4096, 4096,
                100,
                None)
            #win32pipe.WaitNamedPipe(_pipe_out, 1000) 
            if _debug: print("created pipe nanolaboOut")
            win32pipe.ConnectNamedPipe(_pipe_out, None)

        elif os.name == "posix":
            pipe_path =  "/tmp/nanolaboOut"
            if not os.path.exists(pipe_path):
                os.mkfifo(pipe_path)
                if _debug: print("created pipe nanolaboOut")
            _pipe_out = os.open(pipe_path, os.O_RDONLY | os.O_NONBLOCK)
            if _debug: print("opened pipe nanolaboOut")

    except:
        print("error: failed to create pipe nanolaboOut")

    return

def _read_pipe_out():
    global _pipe_out
    global _pipe_out_result
    global _debug
    if os.name == "nt":
        for i in range(30):
            try:
                #win32file.SetFilePointer(_pipe_out,0,win32file.FILE_BEGIN)
                status, result = win32file.ReadFile(_pipe_out, 4096)
                break
            except IOError as e:
                if e.errno == 2:
                    time.sleep(0.1)
                    continue
                else:
                    print("I/O error({0}): {1}".format(e.errno, e.strerror))
                    raise e
        else:
            print("error: failed to read pipe nanolaboOut")
            return

        if _debug: print(status)
        _pipe_out_result = result.decode("utf-8")
        return
    elif os.name == "posix":
        for i in range(30):
            try:
                result = os.read(_pipe_out, 4096)
            except OSError as err:
                if err.errno == 11:
                    time.sleep(0.1)
                    continue
                else:
                    raise err
            if len(result) != 0:
                _pipe_out_result = result.decode("utf-8")
                #os.close(_pipe_out)
                break
            time.sleep(0.1)
        return
    else:
        return

def query_pipe(input):
    """Write input string to pipe nanolaboIn and read output string from pipe nanolaboOut"""
    global _pipe_out
    global _pipe_out_result
    global _debug
    if os.name == "nt" and _pipe_out is not None:
        _pipe_out.close()
        _pipe_out = None
    thread_out = threading.Thread(target = _create_pipe_out)
    thread_out.setDaemon(True)
    if _debug: print("start nanolaboOut thread")
    thread_out.start()

    if _debug: sys.stdout.write("waiting for pipe nanolaboOut created ... ")
    for i in range(30):
        if _pipe_out is not None:
            break
        time.sleep(0.1)
        if _debug: sys.stdout.write("\rwaiting for pipe nanolaboOut created ... {0}/30".format(i))
    else:
        print("")
        print("error: failed to create pipe nanolaboOut")
        return None
    if _debug: print("")

    if os.name == "posix":
        #flush previous result
        os.read(_pipe_out, 4096) 

    if _debug: print("input: " + input)
    write_pipe_in(input)
    if _debug: print("wrote to nanolaboIn")
    _pipe_out_result = None
    thread_read = threading.Thread(target = _read_pipe_out)
    thread_read.setDaemon(True)
    if _debug: print("start read thread")
    thread_read.start()
    if _debug: sys.stdout.write("waiting for read ...")
    for i in range(30):
        if _pipe_out_result is not None:
            break
        time.sleep(0.1)
        if _debug: sys.stdout.write("\rwaiting for read ... {0}/30".format(i))
    else:
        print("") 
        print("failed to read pipe nanolaboOut")
        return None
    if _debug: print("")

    if _debug: print("read from nanolaboOut")
    return _pipe_out_result

def _get_nanolabo_dir():
    global _nanolabo_dir
    if _nanolabo_dir is None:
        _nanolabo_dir = query_pipe("#projectsPath")
    return _nanolabo_dir
        
def _get_full_path(path):
    if _debug: print("get_full_path " + path)
    if os.path.isdir(path):
        return os.path.abspath(path)
    else:
        path2 = _get_nanolabo_dir()
        if path2 is None:
            return None
        path2 += "/" + path
        if os.path.isdir(path2):
            return os.path.abspath(path2)
        else:
            print("error: path not exist")
            return None

def open_project(path):
    """Open a project."""
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return
    query_pipe("#openProject " + path2)

def close_project(path):
    """Close a project."""
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return
    query_pipe("#closeProject " + path2)

def save_project(path, dst_path=""):
    """Save a project.

    If dst_path is specified, the project is saved as another project.

    """
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return
    dst_path2 = ""
    if dst_path == "":
        dst_path2 = path2
    else:
        if os.path.isabs(dst_path):
            dst_path2 = dst_path
        else:
            dst_path2 = os.path.abspath(_get_nanolabo_dir() + "/" + dst_path)
            if sys.version_info[0] < 3:
                dst_path2 = dst_path2.encode()
        if os.path.exists(dst_path2):
            print("error: destination path already exists")
            print(dst_path2)
            return
    if dst_path2 is None:
        print("error: invalid destination path")
        return
    query_pipe("#saveProject " + path2 + " " + dst_path2)

def mode_project(path, mode):
    """Change calculator of a project."""
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return
    if mode not in set(["QuantumESPRESSO", "LAMMPS"]): #TODO:add NWChem
        print("error: invalid calculation mode")
        return
    query_pipe("#modeProject " + path2 + " " + mode)

def run_project(path, jobType="", host="", queue=""):
    """Run a project.

    jobType: "SCF"(default), "OPTIMIZ", "MD", "DOS", "BAND", "TDDFT", "Phonon", "PhDisp", "NEB", "LAMMPS".

    host: "localhost"(default), or SSH/Lambda server host name (need settings be done within NanoLabo GUI beforehand).

    queue: specify in case you use SSH/Lambda server.

    """
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return
    if jobType not in set(["", "SCF", "OPTIMIZ", "MD", "DOS", "BAND", "TDDFT", "Phonon", "PhDisp", "NEB", "LAMMPS"]): #TODO:add NWChem
        print("error: invalid job type")
        return
    if host != "" and host.lower() != "localhost" and queue == "":
        print("error: queue name cannot be empty to run on SSH/Lambda server.")
        return
    query_pipe("#runProject " + path2 + " " + jobType + " " + host + " " + queue)

def create_project(file_path, project_path=""):
    """Create new project from atomic structure file.

    The project is saved to project_path if specified, or to the default projects directory otherwise.

    """
    if not os.path.isfile(file_path):
        print("error: invalid file path")
        return
    file_path2 = os.path.abspath(file_path)
    project_path2 = ""
    if project_path != "":
        if os.path.isabs(project_path):
            project_path2 = project_path
        else:
            project_path2 = os.path.abspath(_get_nanolabo_dir() + "/" + project_path)
            if sys.version_info[0] < 3:
                project_path2 = project_path2.encode()
    query_pipe("#createProject " + file_path2 + " " + project_path2)

def clear_all_atoms(path):
    """Clear all atoms in a project."""
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return
    query_pipe("#clearAllAtoms " + path2)

def set_all_atoms(path, atomsFile):
    """Set geometry info of a project from file. 

    Geometry info already in the project will be overwritten.

    The file format contains lattice vectors, number of atoms,

    and coordinates of atoms in this order, as follows:

    

    -------------------------

     3.09200995   0.00000000   0.00000000   # ax ay az

    -1.54600497   2.67775791   0.00000000   # bx by bz

     0.00000000   0.00000000   5.07335137   # cx cy cz

    4                                       # number of atoms

    Si     -0.000002   1.785172   2.534588   1   1   1   # name x y z FIXED_X FIXED_Y FIXED_Z

    Si      1.546002   0.892585   5.071262   0   0   0   #            0:fixed, 1:mobile

    C      -0.000002   1.785172   4.441264   0   0   0

    C       1.546002   0.892585   1.904590   0   0   0

    ------------------------- 

    """
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return
    if not os.path.isfile(atomsFile):
        print("error: invalid atomsFile")
        return
    atomsFile2 = os.path.abspath(atomsFile)
    query_pipe("#setAllAtoms " + path2 + " " + atomsFile2)

def get_lattice(path):
    """Get lattice vectors of a project"""
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return
    strlat = query_pipe("#getLattice " + path2)
    if strlat is None:
        return None
    strlat2 = strlat.split()
    if len(strlat2) != 9:
        return None
    lat = [float(x) for x in strlat2]
    return [lat[0:3], lat[3:6], lat[6:9]]

def set_lattice(path, lattice):
    """Set lattice vectors of a project.

    lattice: 2D list of size 3*3

    """
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return
    if [len(v) for v in lattice] != [3, 3, 3]:
        print("error: lattice must be 2D list of size 3x3")
        return
    strlat = " ".join([" ".join([str(x) for x in v]) for v in lattice])
    query_pipe("#setLattice " + path2 + " " + strlat)

def num_atoms(path):
    """Get number of atoms in a project."""
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return None
    result = query_pipe("#numAtoms " + path2)
    return int(result) if result is not None else None

def add_atom(path, name, x, y, z):
    """Add an atom to a project.

    name: element symbol of the atom to be added

    In case you have coordinates as a list, you can unpack it when calling the function:

    >>> coords = [0.0, 0.0, 0.0]

    >>> add_atom(path, name, *coords)

    """
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return None
    query_pipe("#addAtom " + path2 + " " + name + " " + str(x) + " " + str(y) + " " + str(z))

def remove_atom(path, index):
    """Remove an atom in a project. The index starts at 0."""
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return None
    query_pipe("#removeAtom " + path2 + " " + str(index))

def get_atom_name(path, index):
    """Get name (element symbol) of an atom in a project. The index starts at 0."""
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return None
    return query_pipe("#getAtomName " + path2 + " " + str(index))

def get_atom_xyz(path, index):
    """Get coordinates of an atom in a project as a list. The index starts at 0.

    Returns 2D list: [[x, y, z], [FIXED_X, FIXED_Y, FIXED_Z]], 0:fixed, 1:mobile.

    """
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return None
    result = query_pipe("#getAtomXYZ " + path2 + " " + str(index))
    if result is None:
        return None
    coord = result.split()
    if len(coord) != 6:
        return None
    return [[float(x) for x in coord[0:3]], [int(x) for x in coord[3:6]]]

def set_atom_name(path, index, name):
    """Change an atom in a project. The index starts at 0.

    name: element symbol of the atom

    """
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return None
    query_pipe("#setAtomName " + path2 + " " + str(index) + " " + name)

def set_atom_xyz(path, index, x, y, z, xfix=1, yfix=1, zfix=1):
    """Set coordinates of an atom in a project. The index starts at 0.

    In case you have coordinates as a list, you can unpack it when calling the function:

    >>> coords = [0.0, 0.0, 0.0]

    >>> set_atom_xyz(path, name, *coords)

    You can also set if the atom is fixed. 0:fixed, 1:mobile (default).

    """
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return None
    query_pipe(" ".join(["#setAtomXYZ", path2] + [str(x) for x in [index, x, y, z, xfix, yfix, zfix]]))

def qe_get_kpoints(path):
    """Get number of K points for SCF calculation of a project.

    Returns 2D list: [[nk1, nk2, nk3], [sk1, sk2, sk3]]

    sk's specify whether to apply offset. Please refer to QE manual (K_POINTS automatic) for detail.

    """
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return None
    result = query_pipe("#qeGetKPoints " + path2)
    if result is None:
        return None
    kpoints = result.split()
    if len(kpoints) != 6:
        return None
    return [[int(x) for x in kpoints[0:3]], [int(x) for x in kpoints[3:6]]]

def qe_set_kpoints(path, nk1, nk2, nk3, sk1, sk2, sk3):
    """Set number of K points for SCF calculation of a project.

    nk's: number of K points, sk's: whether to apply offset

    Please refer to QE manual (K_POINTS automatic) for detail.

    """
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return None
    query_pipe(" ".join(["#qeSetKPoints", path2] + [str(x) for x in [nk1, nk2, nk3, sk1, sk2, sk3]]))

def qe_get_mass(path, name):
    """Get atomic mass currently set for an element.

    name: element symbol

    """
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return None
    result = query_pipe("#qeGetMass " + path2 + " " + name)
    return float(result) if result is not None else None

def qe_set_mass(path, name, mass):
    """Set atomic mass for an element.

    name: element symbol

    """
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return None    
    query_pipe("#qeSetMass " + path2 + " " + name + " " + str(mass))

def qe_get_pseudo(path, name):
    """Get pseudo potential file name currently set for an element.

    name: element symbol

    """
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return None
    return query_pipe("#qeGetPseudo " + path2 + " " + name)

def qe_set_pseudo(path, name, pseudo):
    """Set pseudo potential file name for an element.

    name: element symbol

    """
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return None
    query_pipe("#qeSetPseudo " + path2 + " " + name + " " + pseudo)

def qe_get_total_energy(path):
    """Get total energy calculated by Quantum ESPRESSO

    Returns list: [isConverged, total energy]

                   1:converged, 0:not converged

    """
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return None
    result = query_pipe("#qeGetTotalEnergy " + path2)
    if result is None:
        return None
    result2 = result.split()
    if len(result2) != 2:
        return None
    conv, te = result2
    return [int(conv), float(te)]

def qe_get_geometry(path):
    """Export optimized geometry info to file and returns if the optimization is converged."""
    path2 = _get_full_path(path)
    if path2 is None:
        print("error: invalid project path")
        return None
    result = query_pipe("#qeGetGeometry " + path2)
    if result is None:
        return None
    return result.startswith("1")