Merge pull request #63 from brenda-br/Fix-35HEADmaster

Restructure Project and Deployment

1 files changed, 264 insertions, 0 deletions

diff --git a/src/main/python/utils/Container.py b/src/main/python/utils/Container.py
new file mode 100644
index 0000000..139346c
--- /dev/null
+++ b/src/main/python/utils/Container.py
@@ -0,0 +1,264 @@
+from collections import defaultdict
+import datetime
+import pickle 
+import os,sys
+
+current = os.path.dirname(os.path.realpath(__file__))
+parent = os.path.dirname(current)
+parentPath = os.path.dirname(parent)
+sys.path.append(parentPath)
+
+from python.OMChem.Flowsheet import Flowsheet
+from python.utils.ComponentSelector import *
+from python.utils.Graphics import NodeItem, Graphics, dock_widget_lst
+from python.DockWidgets.DockWidget import DockWidget
+
+class Container():
+    def __init__(self,msgbrowser, graphicsView):
+        self.unit_operations = []
+        self.thermo_package = None
+        self.compounds = None
+        self.flowsheet = None
+        self.conn = defaultdict(list)
+        self.op=defaultdict(list)
+        self.ip=defaultdict(list)
+        self.msg = msgbrowser
+        self.graphicsView = graphicsView
+        self.msg.setText("")
+        self.opl=[]
+        self.result=[]
+        self.graphics = Graphics(self.unit_operations, self.graphicsView)
+        self.scene = self.graphics.get_scene()
+
+    def current_time(self):
+        now = datetime.datetime.now()
+        time = str(now.hour) + ":" + str(now.minute) + ":" +str(now.second)
+        return time
+    
+    def add_unit_operation(self, obj):
+        box = None
+        self.obj = obj
+        self.scene = self.graphics.get_scene()
+        box  = self.graphics.create_node_item(self.obj, self)
+        if box is not None:
+            self.scene.addItem(box)
+            box.setPos(2500-30, 2500-30)
+
+            if(obj in self.unit_operations):
+                pass
+            else:
+                self.unit_operations.append(obj)
+                data = self.unit_operations[:]
+                data.append(compound_selected)
+                #push('Undo', data)
+                self.msg.append("<span style=\"color:blue\">["+str(self.current_time())+"]<b> "+obj.name+" </b>is instantiated .""</span>")
+
+    '''
+        Deletes the selected item from the canvas and also the objects created for that type.
+    '''
+    def delete(self,l):
+        for item in l:
+            self.scene.removeItem(item)
+            for i in dock_widget_lst:
+                if i.name == item.name:
+                    i.hide()
+                    del i
+                    break
+
+            if hasattr(item,'input'):
+                for x in item.input:
+                    if x.new_line:
+                        self.scene.removeItem(x.new_line)
+                        del x.new_line
+                    if x.other_line:
+                        self.scene.removeItem(x.other_line)
+                        del x.other_line
+            if hasattr(item,'output'):
+                for x in item.output:
+                    if x.new_line:
+                        self.scene.removeItem(x.new_line)
+                        del x.new_line
+                    if x.other_line:
+                        self.scene.removeItem(x.other_line)
+                        del x.other_line
+            if hasattr(item,'obj'):
+                self.unit_operations.remove(item.obj)
+                for k in list(self.conn):
+                    if item.obj==k:
+                        del self.conn[k]
+                    elif item.obj in self.conn[k]:
+                        self.conn[k].remove(item.obj)
+                self.msg.append("<span style=\"color:blue\">["+str(self.current_time())+"]<b> "+item.obj.name+" </b>is deleted .""</span>")
+                del item.obj
+            del item
+
+            # clean_file('Redo')
+            # data = self.unit_operations[:]
+            # data.append(compound_selected)
+            # push('Undo', data)
+
+    def fetch_object(self,name):
+        for i in self.unit_operations:
+            if(i.name==name):
+                return i
+                
+    def add_compounds(self,comp):
+        self.compounds = comp
+
+    def update_compounds(self):
+        self.graphics.update_compounds()
+
+    def add_thermo_package(self,thermo):
+        self.thermo_package = thermo
+
+    def msg_browser(self):
+        std = self.flowsheet.stdout.decode("utf-8")
+        if(std):
+            stdout = str(std)
+            stdout = stdout.replace("\n","<br/>")
+            self.msg.append("<span style=\"color:green\">"+stdout+"</span>")
+        
+        stde = self.flowsheet.stderr.decode("utf-8")
+        if(stde):
+            stdout = str(stde)
+            stdout = stdout.replace("\n","<br/>")
+            self.msg.append("<span style=\"color:red\">"+stdout+"</span>")
+    
+    def simulate(self,mode):
+
+        self.disableInterfaceforSimulation(True)
+        toAppend = ''
+        for i in self.graphics.scene.items():
+            showConnectionWarning = False
+            if isinstance(i, NodeItem):
+                try:
+                    i.dock_widget.clear_results()
+                except AttributeError:
+                    pass
+
+                for ip in i.input:
+                    if len(ip.in_lines) == 0:
+                        showConnectionWarning = True
+                for op in i.output:
+                    if len(op.out_lines) == 0:
+                        showConnectionWarning = True
+                if showConnectionWarning:
+                    if toAppend != '':
+                        toAppend+='<br>'
+                    toAppend+="<span style=\"color:#999900\">Warning: "+i.name+" - Missing Socket Connection(s).</span>"
+
+        #print("SIMULATE")
+        #print(mode)
+        self.compounds = compound_selected
+        self.flowsheet = Flowsheet()
+        self.flowsheet.add_compound_list([c[:c.index('(')] for c in self.compounds])
+        #print("######## connection master#########\n",self.conn)
+        for i in self.unit_operations :
+            self.flowsheet.add_unit_operations(i)
+            
+            
+        if mode=='SM':
+            self.msg.append("<span>["+str(self.current_time())+"] Simulating in <b>Sequential</b> mode ... </span>")
+            self.msg.append(toAppend)
+            self.flowsheet.simulate_SM(self.ip,self.op)
+            self.msg_browser()
+            self.result=self.flowsheet.result_data
+            
+        elif mode=='EQN':
+            self.msg.append("<span>["+str(self.current_time())+"] Simulating in <b>equation</b> mode ... </span>")
+            self.msg.append(toAppend)
+            self.flowsheet.simulate_EQN(self.msg)
+            self.result=self.flowsheet.result_data
+
+            if(len(self.result)== 4):
+                #self.msg_browser()
+                self.msg.append("<span style=\"color:green\">["+str(self.current_time())+"] Simulation <b>Successful.</b></span>")
+            else:
+                self.msg.append("<span style=\"color:red\">["+str(self.current_time())+"] Simulation <b>Failed.</b></span>")
+            #print("under Eqn mode simulation")
+        
+        if(len(self.result)== 4):
+            DockWidget.show_result(NodeItem.get_dock_widget())
+
+        for i in self.graphics.scene.items():
+            if (isinstance(i, NodeItem) and i.type == 'MaterialStream'):
+                i.update_tooltip_selectedVar()
+                no_input_lines = len(i.input[0].in_lines)
+                no_output_lines = len(i.output[0].out_lines)
+                if(no_input_lines>0): #Checks if material stream is input or output stream if it is output stream it continues
+                    i.obj.disableInputDataTab(i.dock_widget)
+                    
+        self.disableInterfaceforSimulation(False)
+
+    def enableToolbar(self,status):
+        self.graphicsView.parent().parent().actionNew.setProperty('enabled',status)
+        self.graphicsView.parent().parent().actionZoomIn.setProperty('enabled',status)
+        self.graphicsView.parent().parent().actionZoomOut.setProperty('enabled',status)
+        self.graphicsView.parent().parent().actionResetZoom.setProperty('enabled',status)
+        self.graphicsView.parent().parent().actionEquationOriented.setProperty('enabled',status)
+        self.graphicsView.parent().parent().actionTerminate.setProperty('enabled',not status)
+        self.graphicsView.parent().parent().actionSelectCompounds.setProperty('enabled',status)
+
+    def disableInterfaceforSimulation(self,status):
+        self.graphicsView.parent().parent().menubar.setProperty('enabled',not status)
+        self.enableToolbar(not status)
+        self.graphicsView.parent().parent().dockWidget.setProperty('enabled',not status)
+        self.graphicsView.setInteractive(not status)
+        if status:
+            QApplication.instance().setOverrideCursor(QCursor(Qt.WaitCursor))
+        else:
+            QApplication.instance().restoreOverrideCursor()
+            QApplication.instance().setOverrideCursor(QCursor(Qt.ArrowCursor))
+
+def flat_list(lst):
+    flat_lst=[]
+    for sublist in lst:
+        for item in sublist:
+            flat_lst.append(item)
+    return flat_lst
+
+def push(file_name, data):
+    with open(f"{file_name}.dat", "ab") as obj:
+        pickle.dump(data, obj)
+
+def clean_file(file_name):
+    with open(f"{file_name}.dat", "wb") as clean:
+        pass
+
+def pop(file_name):
+    last_command = None
+    if os.stat(f"{file_name}.dat").st_size != 0:
+        commands = []
+        with open(f"{file_name}.dat", "rb") as objs:
+            while True:
+                try:
+                    command = pickle.load(objs)
+                    commands.append(command)
+                except EOFError:
+                    break
+
+        last_command = commands[-1]
+        commands.remove(commands[-1])
+        if len(commands) != 0:
+            with open(f"{file_name}.dat", "wb") as updated_data:
+                for i in range(len(commands)):
+                    pickle.dump(commands[i], updated_data)
+        else:
+            clean_file(file_name)
+
+    return last_command
+
+def get_last_list(file_name):
+    commands = []
+    if os.stat(f"{file_name}.dat").st_size != 0:
+        with open(f"{file_name}.dat", "rb") as objs:
+            while True:
+                try:
+                    command = pickle.load(objs)
+                    commands.append(command)
+                except EOFError:
+                    break
+    if len(commands) is not 0:
+        return commands[-1]
+    else:
+        return None