path: root/cad/src/analysis/ESP/NanoHiveUtils.py

# Copyright 2005-2008 Nanorex, Inc.  See LICENSE file for details. 
"""
NanoHiveUtils.py

@author: Brian, Mark
@version: $Id$
@copyright: 2005-2008 Nanorex, Inc.  See LICENSE file for details. 

History:
    
Brian wrote the NH_Connection class.
Mark wrote everything else.

Module classification:

Mostly control & io code. Some model & ui code (via assy arg & assy.w).
Probably "simulation". [bruce 071214]
"""

import foundation.env as env, os, sys, time
from platform_dependent.PlatformDependent import find_or_make_Nanorex_subdir
from utilities.prefs_constants import nanohive_path_prefs_key, nanohive_enabled_prefs_key
from PyQt4.Qt import Qt, QApplication, QCursor
from widgets.StatusBar import NanoHiveProgressReporter

def get_nh_simspec_filename(basename):
    """
    Return the full path of the Nano-Hive simulation specification file.
    """
    if basename:
        nhdir = find_or_make_Nanorex_subdir("Nano-Hive")
        fn = os.path.normpath(os.path.join(nhdir,str(basename)+"-sim.xml"))
        #print "get_nh_simspec_filename(): filename=", fn
        return fn
    else:
        return None

def get_nh_workflow_filename(basename):
    """
    Return the full path of the Nano-Hive workflow file.
    """
    if basename:
        nhdir = find_or_make_Nanorex_subdir("Nano-Hive")
        fn = os.path.normpath(os.path.join(nhdir,str(basename)+"-flow.tcl"))
        #print "get_nh_workflow_filename(): filename=", fn
        return fn
    else:
        return None

def get_nh_mmp_filename(basename):
    """
    Return the full path of the Nano-Hive MMP input file.
    """
    if basename:
        nhdir = find_or_make_Nanorex_subdir("Nano-Hive")
        fn = os.path.normpath(os.path.join(nhdir,str(basename)+".mmp"))
        #print "get_nh_mmp_filename(): filename=", fn
        return fn
    else:
        return None

def get_nh_espimage_filename(assy, jigname):
    """
    Returns the filename of the ESP Image's png given assy and ESP Image's jigname,
    to be stored in the ESP Image's MMP info record.
    The filename format is "assyname-jigname.png"
    """
    cwd = os.path.join(assy.get_cwd(), assy.name + "-" + jigname + ".png")
    return os.path.normpath(cwd)
        
def get_nh_home_ORIG():    
    """
    Return the Nano-Hive home directory
    """
    nanohive_exe = env.prefs[nanohive_path_prefs_key]
    
    # On Windows, the default location of the Nano-Hive executable is 
    # C:\Program Files\Nano-Hive\bin\win32-x86\NanoHive.exe
    # The home directory is retreived by stripping off the last two directories
    # from the Nano-Hive executable path, which is 
    # C:\Program Files\Nano-Hive
    if sys.platform == 'win32':
        head, tail = os.path.split(nanohive_exe)
        head, tail = os.path.split(head)
        nh_home, tail = os.path.split(head)
    return nh_home
    
def get_nh_home():
    """
    Returns the Nano-Hive home (base) directory for each platform, if it exists. Otherwise, return None.
    """
    if sys.platform == "win32": # Windows
        basedir = "C:\Program Files\Nano-Hive"
    else: # Linux and MacOS
        basedir = "/usr/local/share/Nano-Hive"
        
    if not os.path.exists(basedir): return None
    return basedir
    
def get_nh_config_filename():
    """
    Return the full path of the Nano-Hive config.txt file.
    """
    if sys.platform == "win32": # Windows
        fn = os.path.normpath(get_nh_home() + "/conf/configs.txt")
    else: # Linxus and MacOS
        fn = os.path.normpath(os.path.expanduser("~/.Nano-Hive/conf/configs.txt"))
        
    if not os.path.exists(fn): return None
    return fn

def run_nh_simulation(assy, sim_id, sim_parms, sims_to_run, results_to_save):
    """
    Run a Nano-Hive simulation on the part (assy).  Only the MPQC_ESP plug-in
    used for creating an ESP Image file is supported in A7.
    
    sim_id is the simulation id of the simulation.  It is used to construct the 
    basename of all the simulation files and is the name of the Nano-Hive simulation run.
    
    sims_to_run is a list of simulations to run, where:
        MPQC_ESP = MPQC ESP Plane
        MPQC_GD = MPQC Gradient Dynamics (not supported in A7)
        AIREBO = AIREBO (not supported in A7)
        
    results_to_save is a list of results to save, where:
        MEASUREMENTS = Measurements to file
        POVRAYVIDEO = POVRay Video
        NETCDF = NetCDF

    Return values:
        0 = successful
        1 = Nano-Hive plug-in not enabled
        2 = Nano-Hive plug-in path is empty
        3 = Nano-Hive plug-in path points to a file that does not exist
        4 = Nano-Hive plug-in is not Version 1.2b
        5 = Couldn't connect to Nano-Hive instance
        6 = "load" command failed
        7 = "run" command failed
        8 = Simulation aborted
    """
    if not sims_to_run:
        return # No simulations to run in the list.
        
    # Validate that the Nano-Hive plug-in is enabled.
    if not env.prefs[nanohive_enabled_prefs_key]:
        r = activate_nh_plugin(assy.w)
        
        if r:
            return 1 # Nano-Hive plug-in not enabled.
            
    if not env.prefs[nanohive_path_prefs_key]:
        return 2 # Nano-Hive plug-in path is empty
    
    if not os.path.exists(env.prefs[nanohive_path_prefs_key]):
        return 3 # Nano-Hive plug-in path points to a file that does not exist
        
    r = verify_nh_program()
    if r:
        return 4 # Nano-Hive plug-in is not Version 1.2b
    
    if not sim_id:
        sim_id = get_sim_id()   
        
    output_dir = find_or_make_Nanorex_subdir("Nano-Hive") # ~/Nanorex/Nano-Hive
    
    # Put up the wait cursor.  The cursor will be restored by exit_nh().       
    QApplication.setOverrideCursor( assy.w.ArrowWaitCursor )
    
    # 1. Try to connect to Nano-Hive, get socket.
    # 99% of the time, no socket will be returned since Nano-Hive hasn't been started yet.
    # Let's check, just in case this is a Nano-Hive instance running.
    nh_socket = connect_to_nh()
    
    if nh_socket:
        kill_nh = False
    else: # No Nano-Hive instance is running.  Start it.
        kill_nh = True
        r = start_nh() # Start Nano-Hive server (instance).
        
        if r:
            print "Nano-Hive startup aborted."
        
        # It may take a second or two to connect to the new Nano-Hive instance.
        # Keep trying until we get a socket.  Give up if we haven't connected within 4 seconds.
        start = time.time()
        while not nh_socket:
            time.sleep(0.25)
            nh_socket = connect_to_nh() 
            duration = time.time() - start
            if duration > 4.0: # Give up after 4 seconds
                exit_nh(nh_socket, kill_nh) # Only restore's the cursor
                return 5 # Couldn't connect to Nano-Hive socket.
        
    # 2. Write the MMP file that Nano-Hive will use for the sim run.
    assy.writemmpfile(get_nh_mmp_filename(sim_id))
        
    # 3. Write the sim-spec file using the parameters from the Nano-Hive dialog widgets
    from analysis.ESP.files_nh import write_nh_simspec_file
    write_nh_simspec_file(sim_id, sim_parms, sims_to_run, results_to_save, output_dir)
    
    # 4. Write the Sim Workflow file
    from analysis.ESP.files_nh import write_nh_workflow_file
    write_nh_workflow_file(sim_id)
    
    # 5. Send commands to Nano-Hive.  There can be no spaces in partname.  Need to fix this.
    cmd = 'load simulation -f "' + get_nh_simspec_filename(sim_id) + '" -n ' + sim_id
    #print "NanoHiveUtils.run_nh_simulation(): N-H load command: ", cmd
    
    success, response = nh_socket.sendCommand(cmd) # Send "load" command.
    if not success:
        print success, response
        exit_nh(nh_socket, kill_nh)
        return 6 # "load" command failed
    
    cmd = "run " + sim_id
    #print "NanoHiveUtils.run_nh_simulation(): N-H run command: ", cmd
    
    success, response = nh_socket.sendCommand(cmd) # Send "run" command.
    if not success:
        print success, response
        exit_nh(nh_socket, kill_nh)
        return 7 # "run" command failed
    
    statusBar = assy.w.statusBar()
    progressReporter = NanoHiveProgressReporter(nh_socket, sim_id)
    r = statusBar.show_progressbar_and_stop_button(progressReporter, "NanoHive", True)
    
    if r:
        stop_nh_sim(sim_id)
        exit_nh(nh_socket, kill_nh)
        return 8 # simulation aborted
    
    exit_nh(nh_socket, kill_nh)
    
    return 0

def activate_nh_plugin(win):
    """
    Opens a message box informing the user that the Nano-Hive plugin
    needs to be enabled and asking if they wish to do so.
    win is the main window object.
    """
    from PyQt4.Qt import QMessageBox
    ret = QMessageBox.warning( win, "Activate Nano-Hive Plug-in",
        "Nano-Hive plug-in not enabled. Please select <b>OK</b> to \n" \
        "activate the Nano-Hive plug-in from the Preferences dialog.",
        "&OK", "Cancel", "",
        0, 1 )
            
    if ret == 0: # OK
        win.userPrefs.showDialog('Plug-ins') # Show Preferences | Plug-in.
        if not env.prefs[nanohive_enabled_prefs_key]:
            return 1 # Nano-Hive was not enabled by user.
        
    elif ret == 1: # Cancel
        return 1

    return 0

def verify_nh_program():
    """
    Returns 0 if nanohive_path_prefs_key is the path to the Nano-Hive v1.2b executable.
    Otherwise, returns 1.
    """
    vstring = "Nano-Hive version 1.2.0-beta-1 Copyright (C) 2004,2005 Nano-Hive, LLC"
    r = verify_program(env.prefs[nanohive_path_prefs_key], '-v', vstring)
    return r
    
# This is a general function that should be moved to utilities
def verify_program(program, version_flag, vstring):
    """
    Verifies a program by running it with the version_flag and matching the output to vstring.
    Returns 0 if there is a match.  Otherwise, returns 1
    """
    if not program:
        return 1
    
    if not os.path.exists(program):
        return 1
        
    args = [version_flag]
    
    from processes.Process import Process
    
    arguments = []
    for arg in args:
        if arg != "":
            arguments.append(arg)
    
    print
    print "arguments:", arguments
    
    p = Process()
    p.start(program, arguments)
    
    if not p.waitForFinished (10000): # Wait for 10000 milliseconds = 10 seconds
        return 1
    
    output = 'Not vstring'
    
    output = str(p.readAllStandardOutput())
    
    #print "output=", output
    #print "vstring=", vstring
    
    if output.find(vstring) == -1:
        return 1
    else:
        return 0 # Match found.
    
def start_nh():
    """
    Starts Nano-Hive server in the background.
    Returns 1 if Nano-Hive path is not set or if the path does not exist.
    Returns 2 if Nano-Hive config file does not exist.
    """
    # Get Nano-Hive executable path from the prefs db.
    nanohive_exe = env.prefs[nanohive_path_prefs_key]
    
    if not nanohive_exe:
        return 1
    
    if not os.path.exists(nanohive_exe):
        return 1
    
    nanohive_config = get_nh_config_filename()
    
    if not nanohive_config:
        return 2
        
    args = ['-f', nanohive_config]
    
    #print "start_nh(): args=", args
    
    from processes.Process import Process
    
    arguments = []
    for arg in args:
        if arg != "":
            arguments.append(arg)
    
    nhProcess = Process()
    nhProcess.start(nanohive_exe, args)
    
    return 0

def stop_nh_sim(nh_socket, sim_id=None):
    """
    Stops a running Nano-Hive simulation.
    <sim_id> - the id (name) of the simulator to stop.
    """
    if nh_socket:
        if sim_id:
            success, response = nh_socket.sendCommand("stop " + sim_id) # Send "stop" command.
    QApplication.restoreOverrideCursor() # Restore the cursor
        
def exit_nh(nh_socket, kill_nh):
    """
    Exits (kills) the Nano-Hive instance if kill_nh is True, 
    closes the socket and restores the cursor."
    """
    if nh_socket:
        if kill_nh:
            success, response = nh_socket.sendCommand("exit") # Send "exit" command.
        nh_socket.close()
    QApplication.restoreOverrideCursor() # Restore the cursor

def connect_to_nh():
    """
    Connects to a Nano-Hive instance.  
    Returns NH_Connection socket if successful, None if failure.
    """
    hostIP = "127.0.0.1"
    port = 3000 # Nano-Hive 1.2b uses port 3000, not 3002 as 1.2a did.  mark 2006-01-04.
    serverTimeout = 5.0
    clientTimeout = 30.0
    
    method = "NanoHiveUtils.connect_to_nh()"
    
    nh_conn = NH_Connection() # Obtain connection object
    
    # Try connecting the Nano-Hive instance.
    success, msg = nh_conn.connect(hostIP, port, serverTimeout, clientTimeout)
    
    if success:
        success, result = nh_conn.sendCommand("status 1") # Send status command.
        if success:
            msg = method + ": Success: " + str(success)  + "\nMessage: " + str(result)
            #env.history.message(msg)
            #print msg
            return nh_conn
            
        else:
            msg = method + ": Command Error:\nSuccess=" + str(success)  + "\nMessage: " + str(result)
            #env.history.message(msg)
            #print msg
            return None
        
    else:
        msg = method + ": Connection Failed:\nSuccess=" + str(success)  + "\nMessage: " + str(msg)
        #env.history.message(msg)
        #print msg
        return None


# Version 2

import socket

class NH_Connection:
    """
    A sockets connection to a Nano-Hive instance.
    """    
    def connect(self, hostIP, port, serverTimeout, clientTimeout):
        """
        Connects to the specified N-H instance.
                
        Parameters:
            hostIP
                The IP address of the N-H host
            port
                The port listened to by the SocketsControl plugin of the N-H host
            serverTimeout
                A float specifying how long, in seconds, to give when reading
                from, and writing to, N-H
            clientTimeout
                A float specifying the timeout period of the SocketsControl
                plugin of the N-H host. Not implemented yet, but this will
                keep the N-H connection alive with "ping" commands
                                
        Returns:
            success indicator
                A one if the N-H instance was successfully connected to, or a
                zero if an error occurred and connection failed
            error message
                If connection failed, describes the problem
        """
        try:
            self.connectionHandle = \
                socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.connectionHandle.connect((hostIP, port))
            self.connectionHandle.settimeout(serverTimeout)
                        
        except socket.error, errorMessage:
            return 0, errorMessage
                        
        return 1, ""
                
                
    def close(self):
        """
        Closes the connection to the N-H instance.
        """
        self.connectionHandle.close()
                
                
    def sendCommand(self, command):
        """
        Sends a command to the N-H instance and returns the response.
                
        Parameters:
            command
                The command to send to the N-H instance
                                
        Returns:
            success indicator
                A one if the command was successfully sent and a response was
                received
            response or error message
                If all was successful, the encoded N-H instance response, or a
                description of the error if unsuccessful. The encoded response
                can be decoded with the
                Nano-Hive/data/local/en_resultCodes.txt file
        """          
        # Send command
        success = 1
        try:
            self.connectionHandle.send(command)

        except socket.error, errorMessage:
            success = 0
                
        # Read response length
        if success:
            try:
                responseLengthChars = self.connectionHandle.recv(4)
                                
            except socket.error, errorMessage:
                success = 0
                                
        if success:
            responseLength = ord(responseLengthChars[0])
            responseLength |= ord(responseLengthChars[1]) << 8
            responseLength |= ord(responseLengthChars[2]) << 16
            responseLength |= ord(responseLengthChars[3]) << 24;

            # Read response
            try:
                response = self.connectionHandle.recv(responseLength)

            except socket.error, errorMessage:
                success = 0

        if success:
            return 1, response
        else:
            return 0, errorMessage